llvm/unittests/IR/InstructionsTest.cpp

   1 //===- llvm/unittest/IR/InstructionsTest.cpp - Instructions unit tests ----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/IR/Instructions.h"
  10 #include "llvm/ADT/CombinationGenerator.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/Analysis/ValueTracking.h"
  13 #include "llvm/Analysis/VectorUtils.h"
  14 #include "llvm/AsmParser/Parser.h"
  15 #include "llvm/IR/BasicBlock.h"
  16 #include "llvm/IR/Constants.h"
  17 #include "llvm/IR/DataLayout.h"
  18 #include "llvm/IR/DebugInfoMetadata.h"
  19 #include "llvm/IR/DerivedTypes.h"
  20 #include "llvm/IR/FPEnv.h"
  21 #include "llvm/IR/Function.h"
  22 #include "llvm/IR/IRBuilder.h"
  23 #include "llvm/IR/LLVMContext.h"
  24 #include "llvm/IR/MDBuilder.h"
  25 #include "llvm/IR/Module.h"
  26 #include "llvm/IR/NoFolder.h"
  27 #include "llvm/IR/Operator.h"
  28 #include "llvm/Support/CommandLine.h"
  29 #include "llvm/Support/SourceMgr.h"
  30 #include "llvm-c/Core.h"
  31 #include "gmock/gmock-matchers.h"
  32 #include "gtest/gtest.h"
  33 #include <memory>
  34
  35 extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
  36
  37 namespace llvm {
  38 namespace {
  39
  40 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
  41   SMDiagnostic Err;
  42   std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
  43   if (!Mod)
  44     Err.print("InstructionsTests", errs());
  45   return Mod;
  46 }
  47
  48 TEST(InstructionsTest, ReturnInst) {
  49   LLVMContext C;
  50
  51   // test for PR6589
  52   const ReturnInst* r0 = ReturnInst::Create(C);
  53   EXPECT_EQ(r0->getNumOperands(), 0U);
  54   EXPECT_EQ(r0->op_begin(), r0->op_end());
  55
  56   IntegerType* Int1 = IntegerType::get(C, 1);
  57   Constant* One = ConstantInt::get(Int1, 1, true);
  58   const ReturnInst* r1 = ReturnInst::Create(C, One);
  59   EXPECT_EQ(1U, r1->getNumOperands());
  60   User::const_op_iterator b(r1->op_begin());
  61   EXPECT_NE(r1->op_end(), b);
  62   EXPECT_EQ(One, *b);
  63   EXPECT_EQ(One, r1->getOperand(0));
  64   ++b;
  65   EXPECT_EQ(r1->op_end(), b);
  66
  67   // clean up
  68   delete r0;
  69   delete r1;
  70 }
  71
  72 // Test fixture that provides a module and a single function within it. Useful
  73 // for tests that need to refer to the function in some way.
  74 class ModuleWithFunctionTest : public testing::Test {
  75 protected:
  76   ModuleWithFunctionTest() : M(new Module("MyModule", Ctx)) {
  77     FArgTypes.push_back(Type::getInt8Ty(Ctx));
  78     FArgTypes.push_back(Type::getInt32Ty(Ctx));
  79     FArgTypes.push_back(Type::getInt64Ty(Ctx));
  80     FunctionType *FTy =
  81         FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false);
  82     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
  83   }
  84
  85   LLVMContext Ctx;
  86   std::unique_ptr<Module> M;
  87   SmallVector<Type *, 3> FArgTypes;
  88   Function *F;
  89 };
  90
  91 TEST_F(ModuleWithFunctionTest, CallInst) {
  92   Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
  93                    ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
  94                    ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
  95   std::unique_ptr<CallInst> Call(CallInst::Create(F, Args));
  96
  97   // Make sure iteration over a call's arguments works as expected.
  98   unsigned Idx = 0;
  99   for (Value *Arg : Call->args()) {
 100     EXPECT_EQ(FArgTypes[Idx], Arg->getType());
 101     EXPECT_EQ(Call->getArgOperand(Idx)->getType(), Arg->getType());
 102     Idx++;
 103   }
 104
 105   Call->addRetAttr(Attribute::get(Call->getContext(), "test-str-attr"));
 106   EXPECT_TRUE(Call->hasRetAttr("test-str-attr"));
 107   EXPECT_FALSE(Call->hasRetAttr("not-on-call"));
 108
 109   Call->addFnAttr(Attribute::get(Call->getContext(), "test-str-fn-attr"));
 110   ASSERT_TRUE(Call->hasFnAttr("test-str-fn-attr"));
 111   Call->removeFnAttr("test-str-fn-attr");
 112   EXPECT_FALSE(Call->hasFnAttr("test-str-fn-attr"));
 113 }
 114
 115 TEST_F(ModuleWithFunctionTest, InvokeInst) {
 116   BasicBlock *BB1 = BasicBlock::Create(Ctx, "", F);
 117   BasicBlock *BB2 = BasicBlock::Create(Ctx, "", F);
 118
 119   Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
 120                    ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
 121                    ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
 122   std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create(F, BB1, BB2, Args));
 123
 124   // Make sure iteration over invoke's arguments works as expected.
 125   unsigned Idx = 0;
 126   for (Value *Arg : Invoke->args()) {
 127     EXPECT_EQ(FArgTypes[Idx], Arg->getType());
 128     EXPECT_EQ(Invoke->getArgOperand(Idx)->getType(), Arg->getType());
 129     Idx++;
 130   }
 131 }
 132
 133 TEST(InstructionsTest, BranchInst) {
 134   LLVMContext C;
 135
 136   // Make a BasicBlocks
 137   BasicBlock* bb0 = BasicBlock::Create(C);
 138   BasicBlock* bb1 = BasicBlock::Create(C);
 139
 140   // Mandatory BranchInst
 141   const BranchInst* b0 = BranchInst::Create(bb0);
 142
 143   EXPECT_TRUE(b0->isUnconditional());
 144   EXPECT_FALSE(b0->isConditional());
 145   EXPECT_EQ(1U, b0->getNumSuccessors());
 146
 147   // check num operands
 148   EXPECT_EQ(1U, b0->getNumOperands());
 149
 150   EXPECT_NE(b0->op_begin(), b0->op_end());
 151   EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
 152
 153   EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
 154
 155   IntegerType* Int1 = IntegerType::get(C, 1);
 156   Constant* One = ConstantInt::get(Int1, 1, true);
 157
 158   // Conditional BranchInst
 159   BranchInst* b1 = BranchInst::Create(bb0, bb1, One);
 160
 161   EXPECT_FALSE(b1->isUnconditional());
 162   EXPECT_TRUE(b1->isConditional());
 163   EXPECT_EQ(2U, b1->getNumSuccessors());
 164
 165   // check num operands
 166   EXPECT_EQ(3U, b1->getNumOperands());
 167
 168   User::const_op_iterator b(b1->op_begin());
 169
 170   // check COND
 171   EXPECT_NE(b, b1->op_end());
 172   EXPECT_EQ(One, *b);
 173   EXPECT_EQ(One, b1->getOperand(0));
 174   EXPECT_EQ(One, b1->getCondition());
 175   ++b;
 176
 177   // check ELSE
 178   EXPECT_EQ(bb1, *b);
 179   EXPECT_EQ(bb1, b1->getOperand(1));
 180   EXPECT_EQ(bb1, b1->getSuccessor(1));
 181   ++b;
 182
 183   // check THEN
 184   EXPECT_EQ(bb0, *b);
 185   EXPECT_EQ(bb0, b1->getOperand(2));
 186   EXPECT_EQ(bb0, b1->getSuccessor(0));
 187   ++b;
 188
 189   EXPECT_EQ(b1->op_end(), b);
 190
 191   // clean up
 192   delete b0;
 193   delete b1;
 194
 195   delete bb0;
 196   delete bb1;
 197 }
 198
 199 TEST(InstructionsTest, CastInst) {
 200   LLVMContext C;
 201
 202   Type *Int8Ty = Type::getInt8Ty(C);
 203   Type *Int16Ty = Type::getInt16Ty(C);
 204   Type *Int32Ty = Type::getInt32Ty(C);
 205   Type *Int64Ty = Type::getInt64Ty(C);
 206   Type *V8x8Ty = FixedVectorType::get(Int8Ty, 8);
 207   Type *V8x64Ty = FixedVectorType::get(Int64Ty, 8);
 208   Type *X86MMXTy = Type::getX86_MMXTy(C);
 209
 210   Type *HalfTy = Type::getHalfTy(C);
 211   Type *FloatTy = Type::getFloatTy(C);
 212   Type *DoubleTy = Type::getDoubleTy(C);
 213
 214   Type *V2Int32Ty = FixedVectorType::get(Int32Ty, 2);
 215   Type *V2Int64Ty = FixedVectorType::get(Int64Ty, 2);
 216   Type *V4Int16Ty = FixedVectorType::get(Int16Ty, 4);
 217   Type *V1Int16Ty = FixedVectorType::get(Int16Ty, 1);
 218
 219   Type *VScaleV2Int32Ty = ScalableVectorType::get(Int32Ty, 2);
 220   Type *VScaleV2Int64Ty = ScalableVectorType::get(Int64Ty, 2);
 221   Type *VScaleV4Int16Ty = ScalableVectorType::get(Int16Ty, 4);
 222   Type *VScaleV1Int16Ty = ScalableVectorType::get(Int16Ty, 1);
 223
 224   Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
 225   Type *Int64PtrTy = PointerType::get(Int64Ty, 0);
 226
 227   Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
 228   Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1);
 229
 230   Type *V2Int32PtrAS1Ty = FixedVectorType::get(Int32PtrAS1Ty, 2);
 231   Type *V2Int64PtrAS1Ty = FixedVectorType::get(Int64PtrAS1Ty, 2);
 232   Type *V4Int32PtrAS1Ty = FixedVectorType::get(Int32PtrAS1Ty, 4);
 233   Type *VScaleV4Int32PtrAS1Ty = ScalableVectorType::get(Int32PtrAS1Ty, 4);
 234   Type *V4Int64PtrAS1Ty = FixedVectorType::get(Int64PtrAS1Ty, 4);
 235
 236   Type *V2Int64PtrTy = FixedVectorType::get(Int64PtrTy, 2);
 237   Type *V2Int32PtrTy = FixedVectorType::get(Int32PtrTy, 2);
 238   Type *VScaleV2Int32PtrTy = ScalableVectorType::get(Int32PtrTy, 2);
 239   Type *V4Int32PtrTy = FixedVectorType::get(Int32PtrTy, 4);
 240   Type *VScaleV4Int32PtrTy = ScalableVectorType::get(Int32PtrTy, 4);
 241   Type *VScaleV4Int64PtrTy = ScalableVectorType::get(Int64PtrTy, 4);
 242
 243   const Constant* c8 = Constant::getNullValue(V8x8Ty);
 244   const Constant* c64 = Constant::getNullValue(V8x64Ty);
 245
 246   const Constant *v2ptr32 = Constant::getNullValue(V2Int32PtrTy);
 247
 248   EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true));
 249   EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true));
 250
 251   EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, X86MMXTy));
 252   EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy, V8x8Ty));
 253   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, X86MMXTy));
 254   EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty, V8x8Ty));
 255   EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, V8x64Ty));
 256
 257   // Check address space casts are rejected since we don't know the sizes here
 258   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, Int32PtrAS1Ty));
 259   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrTy));
 260   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, V2Int32PtrAS1Ty));
 261   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrTy));
 262   EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty));
 263   EXPECT_EQ(CastInst::AddrSpaceCast, CastInst::getCastOpcode(v2ptr32, true,
 264                                                              V2Int32PtrAS1Ty,
 265                                                              true));
 266
 267   // Test mismatched number of elements for pointers
 268   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int64PtrAS1Ty));
 269   EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty, V2Int32PtrAS1Ty));
 270   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int32PtrAS1Ty));
 271   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, V2Int32PtrTy));
 272   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int32PtrTy));
 273
 274   EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy));
 275   EXPECT_FALSE(CastInst::isBitCastable(DoubleTy, FloatTy));
 276   EXPECT_FALSE(CastInst::isBitCastable(FloatTy, DoubleTy));
 277   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
 278   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
 279   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty));
 280   EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy));
 281   EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy));
 282   EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty));
 283
 284   EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty));
 285   EXPECT_FALSE(CastInst::isBitCastable(Int32Ty, Int64Ty));
 286   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, Int32Ty));
 287
 288   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int64Ty));
 289   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, V2Int32PtrTy));
 290   EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy));
 291   EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy));
 292   EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty, V2Int64Ty));
 293   EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty, V2Int32Ty));
 294
 295
 296   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 297                                      Constant::getNullValue(V4Int32PtrTy),
 298                                      V2Int32PtrTy));
 299   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 300                                      Constant::getNullValue(V2Int32PtrTy),
 301                                      V4Int32PtrTy));
 302
 303   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 304                                      Constant::getNullValue(V4Int32PtrAS1Ty),
 305                                      V2Int32PtrTy));
 306   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 307                                      Constant::getNullValue(V2Int32PtrTy),
 308                                      V4Int32PtrAS1Ty));
 309
 310   // Address space cast of fixed/scalable vectors of pointers to scalable/fixed
 311   // vector of pointers.
 312   EXPECT_FALSE(CastInst::castIsValid(
 313       Instruction::AddrSpaceCast, Constant::getNullValue(VScaleV4Int32PtrAS1Ty),
 314       V4Int32PtrTy));
 315   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 316                                      Constant::getNullValue(V4Int32PtrTy),
 317                                      VScaleV4Int32PtrAS1Ty));
 318   // Address space cast of scalable vectors of pointers to scalable vector of
 319   // pointers.
 320   EXPECT_FALSE(CastInst::castIsValid(
 321       Instruction::AddrSpaceCast, Constant::getNullValue(VScaleV4Int32PtrAS1Ty),
 322       VScaleV2Int32PtrTy));
 323   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 324                                      Constant::getNullValue(VScaleV2Int32PtrTy),
 325                                      VScaleV4Int32PtrAS1Ty));
 326   EXPECT_TRUE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 327                                     Constant::getNullValue(VScaleV4Int64PtrTy),
 328                                     VScaleV4Int32PtrAS1Ty));
 329   // Same number of lanes, different address space.
 330   EXPECT_TRUE(CastInst::castIsValid(
 331       Instruction::AddrSpaceCast, Constant::getNullValue(VScaleV4Int32PtrAS1Ty),
 332       VScaleV4Int32PtrTy));
 333   // Same number of lanes, same address space.
 334   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
 335                                      Constant::getNullValue(VScaleV4Int64PtrTy),
 336                                      VScaleV4Int32PtrTy));
 337
 338   // Bit casting fixed/scalable vector to scalable/fixed vectors.
 339   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 340                                      Constant::getNullValue(V2Int32Ty),
 341                                      VScaleV2Int32Ty));
 342   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 343                                      Constant::getNullValue(V2Int64Ty),
 344                                      VScaleV2Int64Ty));
 345   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 346                                      Constant::getNullValue(V4Int16Ty),
 347                                      VScaleV4Int16Ty));
 348   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 349                                      Constant::getNullValue(VScaleV2Int32Ty),
 350                                      V2Int32Ty));
 351   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 352                                      Constant::getNullValue(VScaleV2Int64Ty),
 353                                      V2Int64Ty));
 354   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 355                                      Constant::getNullValue(VScaleV4Int16Ty),
 356                                      V4Int16Ty));
 357
 358   // Bit casting scalable vectors to scalable vectors.
 359   EXPECT_TRUE(CastInst::castIsValid(Instruction::BitCast,
 360                                     Constant::getNullValue(VScaleV4Int16Ty),
 361                                     VScaleV2Int32Ty));
 362   EXPECT_TRUE(CastInst::castIsValid(Instruction::BitCast,
 363                                     Constant::getNullValue(VScaleV2Int32Ty),
 364                                     VScaleV4Int16Ty));
 365   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 366                                      Constant::getNullValue(VScaleV2Int64Ty),
 367                                      VScaleV2Int32Ty));
 368   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 369                                      Constant::getNullValue(VScaleV2Int32Ty),
 370                                      VScaleV2Int64Ty));
 371
 372   // Bitcasting to/from <vscale x 1 x Ty>
 373   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 374                                      Constant::getNullValue(VScaleV1Int16Ty),
 375                                      V1Int16Ty));
 376   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
 377                                      Constant::getNullValue(V1Int16Ty),
 378                                      VScaleV1Int16Ty));
 379
 380   // Check that assertion is not hit when creating a cast with a vector of
 381   // pointers
 382   // First form
 383   BasicBlock *BB = BasicBlock::Create(C);
 384   Constant *NullV2I32Ptr = Constant::getNullValue(V2Int32PtrTy);
 385   auto Inst1 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB);
 386
 387   Constant *NullVScaleV2I32Ptr = Constant::getNullValue(VScaleV2Int32PtrTy);
 388   auto Inst1VScale = CastInst::CreatePointerCast(
 389       NullVScaleV2I32Ptr, VScaleV2Int32Ty, "foo.vscale", BB);
 390
 391   // Second form
 392   auto Inst2 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty);
 393   auto Inst2VScale =
 394       CastInst::CreatePointerCast(NullVScaleV2I32Ptr, VScaleV2Int32Ty);
 395
 396   delete Inst2;
 397   delete Inst2VScale;
 398   Inst1->eraseFromParent();
 399   Inst1VScale->eraseFromParent();
 400   delete BB;
 401 }
 402
 403 TEST(InstructionsTest, CastCAPI) {
 404   LLVMContext C;
 405
 406   Type *Int8Ty = Type::getInt8Ty(C);
 407   Type *Int32Ty = Type::getInt32Ty(C);
 408   Type *Int64Ty = Type::getInt64Ty(C);
 409
 410   Type *FloatTy = Type::getFloatTy(C);
 411   Type *DoubleTy = Type::getDoubleTy(C);
 412
 413   Type *Int8PtrTy = PointerType::get(Int8Ty, 0);
 414   Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
 415
 416   const Constant *C8 = Constant::getNullValue(Int8Ty);
 417   const Constant *C64 = Constant::getNullValue(Int64Ty);
 418
 419   EXPECT_EQ(LLVMBitCast,
 420             LLVMGetCastOpcode(wrap(C64), true, wrap(Int64Ty), true));
 421   EXPECT_EQ(LLVMTrunc, LLVMGetCastOpcode(wrap(C64), true, wrap(Int8Ty), true));
 422   EXPECT_EQ(LLVMSExt, LLVMGetCastOpcode(wrap(C8), true, wrap(Int64Ty), true));
 423   EXPECT_EQ(LLVMZExt, LLVMGetCastOpcode(wrap(C8), false, wrap(Int64Ty), true));
 424
 425   const Constant *CF32 = Constant::getNullValue(FloatTy);
 426   const Constant *CF64 = Constant::getNullValue(DoubleTy);
 427
 428   EXPECT_EQ(LLVMFPToUI,
 429             LLVMGetCastOpcode(wrap(CF32), true, wrap(Int8Ty), false));
 430   EXPECT_EQ(LLVMFPToSI,
 431             LLVMGetCastOpcode(wrap(CF32), true, wrap(Int8Ty), true));
 432   EXPECT_EQ(LLVMUIToFP,
 433             LLVMGetCastOpcode(wrap(C8), false, wrap(FloatTy), true));
 434   EXPECT_EQ(LLVMSIToFP, LLVMGetCastOpcode(wrap(C8), true, wrap(FloatTy), true));
 435   EXPECT_EQ(LLVMFPTrunc,
 436             LLVMGetCastOpcode(wrap(CF64), true, wrap(FloatTy), true));
 437   EXPECT_EQ(LLVMFPExt,
 438             LLVMGetCastOpcode(wrap(CF32), true, wrap(DoubleTy), true));
 439
 440   const Constant *CPtr8 = Constant::getNullValue(Int8PtrTy);
 441
 442   EXPECT_EQ(LLVMPtrToInt,
 443             LLVMGetCastOpcode(wrap(CPtr8), true, wrap(Int8Ty), true));
 444   EXPECT_EQ(LLVMIntToPtr,
 445             LLVMGetCastOpcode(wrap(C8), true, wrap(Int8PtrTy), true));
 446
 447   Type *V8x8Ty = FixedVectorType::get(Int8Ty, 8);
 448   Type *V8x64Ty = FixedVectorType::get(Int64Ty, 8);
 449   const Constant *CV8 = Constant::getNullValue(V8x8Ty);
 450   const Constant *CV64 = Constant::getNullValue(V8x64Ty);
 451
 452   EXPECT_EQ(LLVMTrunc, LLVMGetCastOpcode(wrap(CV64), true, wrap(V8x8Ty), true));
 453   EXPECT_EQ(LLVMSExt, LLVMGetCastOpcode(wrap(CV8), true, wrap(V8x64Ty), true));
 454
 455   Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
 456   Type *V2Int32PtrAS1Ty = FixedVectorType::get(Int32PtrAS1Ty, 2);
 457   Type *V2Int32PtrTy = FixedVectorType::get(Int32PtrTy, 2);
 458   const Constant *CV2ptr32 = Constant::getNullValue(V2Int32PtrTy);
 459
 460   EXPECT_EQ(LLVMAddrSpaceCast, LLVMGetCastOpcode(wrap(CV2ptr32), true,
 461                                                  wrap(V2Int32PtrAS1Ty), true));
 462 }
 463
 464 TEST(InstructionsTest, VectorGep) {
 465   LLVMContext C;
 466
 467   // Type Definitions
 468   Type *I8Ty = IntegerType::get(C, 8);
 469   Type *I32Ty = IntegerType::get(C, 32);
 470   PointerType *Ptri8Ty = PointerType::get(I8Ty, 0);
 471   PointerType *Ptri32Ty = PointerType::get(I32Ty, 0);
 472
 473   VectorType *V2xi8PTy = FixedVectorType::get(Ptri8Ty, 2);
 474   VectorType *V2xi32PTy = FixedVectorType::get(Ptri32Ty, 2);
 475
 476   // Test different aspects of the vector-of-pointers type
 477   // and GEPs which use this type.
 478   ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492));
 479   ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948));
 480   std::vector<Constant*> ConstVa(2, Ci32a);
 481   std::vector<Constant*> ConstVb(2, Ci32b);
 482   Constant *C2xi32a = ConstantVector::get(ConstVa);
 483   Constant *C2xi32b = ConstantVector::get(ConstVb);
 484
 485   CastInst *PtrVecA = new IntToPtrInst(C2xi32a, V2xi32PTy);
 486   CastInst *PtrVecB = new IntToPtrInst(C2xi32b, V2xi32PTy);
 487
 488   ICmpInst *ICmp0 = new ICmpInst(ICmpInst::ICMP_SGT, PtrVecA, PtrVecB);
 489   ICmpInst *ICmp1 = new ICmpInst(ICmpInst::ICMP_ULT, PtrVecA, PtrVecB);
 490   EXPECT_NE(ICmp0, ICmp1); // suppress warning.
 491
 492   BasicBlock* BB0 = BasicBlock::Create(C);
 493   // Test InsertAtEnd ICmpInst constructor.
 494   ICmpInst *ICmp2 = new ICmpInst(BB0, ICmpInst::ICMP_SGE, PtrVecA, PtrVecB);
 495   EXPECT_NE(ICmp0, ICmp2); // suppress warning.
 496
 497   GetElementPtrInst *Gep0 = GetElementPtrInst::Create(I32Ty, PtrVecA, C2xi32a);
 498   GetElementPtrInst *Gep1 = GetElementPtrInst::Create(I32Ty, PtrVecA, C2xi32b);
 499   GetElementPtrInst *Gep2 = GetElementPtrInst::Create(I32Ty, PtrVecB, C2xi32a);
 500   GetElementPtrInst *Gep3 = GetElementPtrInst::Create(I32Ty, PtrVecB, C2xi32b);
 501
 502   CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy);
 503   CastInst *BTC1 = new BitCastInst(Gep1, V2xi8PTy);
 504   CastInst *BTC2 = new BitCastInst(Gep2, V2xi8PTy);
 505   CastInst *BTC3 = new BitCastInst(Gep3, V2xi8PTy);
 506
 507   Value *S0 = BTC0->stripPointerCasts();
 508   Value *S1 = BTC1->stripPointerCasts();
 509   Value *S2 = BTC2->stripPointerCasts();
 510   Value *S3 = BTC3->stripPointerCasts();
 511
 512   EXPECT_NE(S0, Gep0);
 513   EXPECT_NE(S1, Gep1);
 514   EXPECT_NE(S2, Gep2);
 515   EXPECT_NE(S3, Gep3);
 516
 517   int64_t Offset;
 518   DataLayout TD("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3"
 519                 "2:32:32-f64:64:64-v64:64:64-v128:128:128-a:0:64-s:64:64-f80"
 520                 ":128:128-n8:16:32:64-S128");
 521   // Make sure we don't crash
 522   GetPointerBaseWithConstantOffset(Gep0, Offset, TD);
 523   GetPointerBaseWithConstantOffset(Gep1, Offset, TD);
 524   GetPointerBaseWithConstantOffset(Gep2, Offset, TD);
 525   GetPointerBaseWithConstantOffset(Gep3, Offset, TD);
 526
 527   // Gep of Geps
 528   GetElementPtrInst *GepII0 = GetElementPtrInst::Create(I32Ty, Gep0, C2xi32b);
 529   GetElementPtrInst *GepII1 = GetElementPtrInst::Create(I32Ty, Gep1, C2xi32a);
 530   GetElementPtrInst *GepII2 = GetElementPtrInst::Create(I32Ty, Gep2, C2xi32b);
 531   GetElementPtrInst *GepII3 = GetElementPtrInst::Create(I32Ty, Gep3, C2xi32a);
 532
 533   EXPECT_EQ(GepII0->getNumIndices(), 1u);
 534   EXPECT_EQ(GepII1->getNumIndices(), 1u);
 535   EXPECT_EQ(GepII2->getNumIndices(), 1u);
 536   EXPECT_EQ(GepII3->getNumIndices(), 1u);
 537
 538   EXPECT_FALSE(GepII0->hasAllZeroIndices());
 539   EXPECT_FALSE(GepII1->hasAllZeroIndices());
 540   EXPECT_FALSE(GepII2->hasAllZeroIndices());
 541   EXPECT_FALSE(GepII3->hasAllZeroIndices());
 542
 543   delete GepII0;
 544   delete GepII1;
 545   delete GepII2;
 546   delete GepII3;
 547
 548   delete BTC0;
 549   delete BTC1;
 550   delete BTC2;
 551   delete BTC3;
 552
 553   delete Gep0;
 554   delete Gep1;
 555   delete Gep2;
 556   delete Gep3;
 557
 558   ICmp2->eraseFromParent();
 559   delete BB0;
 560
 561   delete ICmp0;
 562   delete ICmp1;
 563   delete PtrVecA;
 564   delete PtrVecB;
 565 }
 566
 567 TEST(InstructionsTest, FPMathOperator) {
 568   LLVMContext Context;
 569   IRBuilder<> Builder(Context);
 570   MDBuilder MDHelper(Context);
 571   Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
 572   MDNode *MD1 = MDHelper.createFPMath(1.0);
 573   Value *V1 = Builder.CreateFAdd(I, I, "", MD1);
 574   EXPECT_TRUE(isa<FPMathOperator>(V1));
 575   FPMathOperator *O1 = cast<FPMathOperator>(V1);
 576   EXPECT_EQ(O1->getFPAccuracy(), 1.0);
 577   V1->deleteValue();
 578   I->deleteValue();
 579 }
 580
 581 TEST(InstructionTest, ConstrainedTrans) {
 582   LLVMContext Context;
 583   std::unique_ptr<Module> M(new Module("MyModule", Context));
 584   FunctionType *FTy =
 585       FunctionType::get(Type::getVoidTy(Context),
 586                         {Type::getFloatTy(Context), Type::getFloatTy(Context),
 587                          Type::getInt32Ty(Context)},
 588                         false);
 589   auto *F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
 590   auto *BB = BasicBlock::Create(Context, "bb", F);
 591   IRBuilder<> Builder(Context);
 592   Builder.SetInsertPoint(BB);
 593   auto *Arg0 = F->arg_begin();
 594   auto *Arg1 = F->arg_begin() + 1;
 595
 596   {
 597     auto *I = cast<Instruction>(Builder.CreateFAdd(Arg0, Arg1));
 598     EXPECT_EQ(Intrinsic::experimental_constrained_fadd,
 599               getConstrainedIntrinsicID(*I));
 600   }
 601
 602   {
 603     auto *I = cast<Instruction>(
 604         Builder.CreateFPToSI(Arg0, Type::getInt32Ty(Context)));
 605     EXPECT_EQ(Intrinsic::experimental_constrained_fptosi,
 606               getConstrainedIntrinsicID(*I));
 607   }
 608
 609   {
 610     auto *I = cast<Instruction>(Builder.CreateIntrinsic(
 611         Intrinsic::ceil, {Type::getFloatTy(Context)}, {Arg0}));
 612     EXPECT_EQ(Intrinsic::experimental_constrained_ceil,
 613               getConstrainedIntrinsicID(*I));
 614   }
 615
 616   {
 617     auto *I = cast<Instruction>(Builder.CreateFCmpOEQ(Arg0, Arg1));
 618     EXPECT_EQ(Intrinsic::experimental_constrained_fcmp,
 619               getConstrainedIntrinsicID(*I));
 620   }
 621
 622   {
 623     auto *Arg2 = F->arg_begin() + 2;
 624     auto *I = cast<Instruction>(Builder.CreateAdd(Arg2, Arg2));
 625     EXPECT_EQ(Intrinsic::not_intrinsic, getConstrainedIntrinsicID(*I));
 626   }
 627
 628   {
 629     auto *I = cast<Instruction>(Builder.CreateConstrainedFPBinOp(
 630         Intrinsic::experimental_constrained_fadd, Arg0, Arg0));
 631     EXPECT_EQ(Intrinsic::not_intrinsic, getConstrainedIntrinsicID(*I));
 632   }
 633 }
 634
 635 TEST(InstructionsTest, isEliminableCastPair) {
 636   LLVMContext C;
 637
 638   Type* Int16Ty = Type::getInt16Ty(C);
 639   Type* Int32Ty = Type::getInt32Ty(C);
 640   Type* Int64Ty = Type::getInt64Ty(C);
 641   Type *Int64PtrTy = PointerType::get(C, 0);
 642
 643   // Source and destination pointers have same size -> bitcast.
 644   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
 645                                            CastInst::IntToPtr,
 646                                            Int64PtrTy, Int64Ty, Int64PtrTy,
 647                                            Int32Ty, nullptr, Int32Ty),
 648             CastInst::BitCast);
 649
 650   // Source and destination have unknown sizes, but the same address space and
 651   // the intermediate int is the maximum pointer size -> bitcast
 652   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
 653                                            CastInst::IntToPtr,
 654                                            Int64PtrTy, Int64Ty, Int64PtrTy,
 655                                            nullptr, nullptr, nullptr),
 656             CastInst::BitCast);
 657
 658   // Source and destination have unknown sizes, but the same address space and
 659   // the intermediate int is not the maximum pointer size -> nothing
 660   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
 661                                            CastInst::IntToPtr,
 662                                            Int64PtrTy, Int32Ty, Int64PtrTy,
 663                                            nullptr, nullptr, nullptr),
 664             0U);
 665
 666   // Middle pointer big enough -> bitcast.
 667   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
 668                                            CastInst::PtrToInt,
 669                                            Int64Ty, Int64PtrTy, Int64Ty,
 670                                            nullptr, Int64Ty, nullptr),
 671             CastInst::BitCast);
 672
 673   // Middle pointer too small -> fail.
 674   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
 675                                            CastInst::PtrToInt,
 676                                            Int64Ty, Int64PtrTy, Int64Ty,
 677                                            nullptr, Int32Ty, nullptr),
 678             0U);
 679
 680   // Test that we don't eliminate bitcasts between different address spaces,
 681   // or if we don't have available pointer size information.
 682   DataLayout DL("e-p:32:32:32-p1:16:16:16-p2:64:64:64-i1:8:8-i8:8:8-i16:16:16"
 683                 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64"
 684                 "-v128:128:128-a:0:64-s:64:64-f80:128:128-n8:16:32:64-S128");
 685
 686   Type *Int64PtrTyAS1 = PointerType::get(C, 1);
 687   Type *Int64PtrTyAS2 = PointerType::get(C, 2);
 688
 689   IntegerType *Int16SizePtr = DL.getIntPtrType(C, 1);
 690   IntegerType *Int64SizePtr = DL.getIntPtrType(C, 2);
 691
 692   // Cannot simplify inttoptr, addrspacecast
 693   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
 694                                            CastInst::AddrSpaceCast,
 695                                            Int16Ty, Int64PtrTyAS1, Int64PtrTyAS2,
 696                                            nullptr, Int16SizePtr, Int64SizePtr),
 697             0U);
 698
 699   // Cannot simplify addrspacecast, ptrtoint
 700   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::AddrSpaceCast,
 701                                            CastInst::PtrToInt,
 702                                            Int64PtrTyAS1, Int64PtrTyAS2, Int16Ty,
 703                                            Int64SizePtr, Int16SizePtr, nullptr),
 704             0U);
 705
 706   // Pass since the bitcast address spaces are the same
 707   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
 708                                            CastInst::BitCast,
 709                                            Int16Ty, Int64PtrTyAS1, Int64PtrTyAS1,
 710                                            nullptr, nullptr, nullptr),
 711             CastInst::IntToPtr);
 712
 713 }
 714
 715 TEST(InstructionsTest, CloneCall) {
 716   LLVMContext C;
 717   Type *Int32Ty = Type::getInt32Ty(C);
 718   Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty};
 719   FunctionType *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
 720   Value *Callee = Constant::getNullValue(PointerType::getUnqual(C));
 721   Value *Args[] = {
 722     ConstantInt::get(Int32Ty, 1),
 723     ConstantInt::get(Int32Ty, 2),
 724     ConstantInt::get(Int32Ty, 3)
 725   };
 726   std::unique_ptr<CallInst> Call(
 727       CallInst::Create(FnTy, Callee, Args, "result"));
 728
 729   // Test cloning the tail call kind.
 730   CallInst::TailCallKind Kinds[] = {CallInst::TCK_None, CallInst::TCK_Tail,
 731                                     CallInst::TCK_MustTail};
 732   for (CallInst::TailCallKind TCK : Kinds) {
 733     Call->setTailCallKind(TCK);
 734     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
 735     EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
 736   }
 737   Call->setTailCallKind(CallInst::TCK_None);
 738
 739   // Test cloning an attribute.
 740   {
 741     AttrBuilder AB(C);
 742     AB.addAttribute(Attribute::NoUnwind);
 743     Call->setAttributes(
 744         AttributeList::get(C, AttributeList::FunctionIndex, AB));
 745     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
 746     EXPECT_TRUE(Clone->doesNotThrow());
 747   }
 748 }
 749
 750 TEST(InstructionsTest, AlterCallBundles) {
 751   LLVMContext C;
 752   Type *Int32Ty = Type::getInt32Ty(C);
 753   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
 754   Value *Callee = Constant::getNullValue(PointerType::getUnqual(C));
 755   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
 756   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
 757   std::unique_ptr<CallInst> Call(
 758       CallInst::Create(FnTy, Callee, Args, OldBundle, "result"));
 759   Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail);
 760   AttrBuilder AB(C);
 761   AB.addAttribute(Attribute::Cold);
 762   Call->setAttributes(AttributeList::get(C, AttributeList::FunctionIndex, AB));
 763   Call->setDebugLoc(DebugLoc(MDNode::get(C, std::nullopt)));
 764
 765   OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
 766   std::unique_ptr<CallInst> Clone(CallInst::Create(Call.get(), NewBundle));
 767   EXPECT_EQ(Call->arg_size(), Clone->arg_size());
 768   EXPECT_EQ(Call->getArgOperand(0), Clone->getArgOperand(0));
 769   EXPECT_EQ(Call->getCallingConv(), Clone->getCallingConv());
 770   EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
 771   EXPECT_TRUE(Clone->hasFnAttr(Attribute::AttrKind::Cold));
 772   EXPECT_EQ(Call->getDebugLoc(), Clone->getDebugLoc());
 773   EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
 774   EXPECT_TRUE(Clone->getOperandBundle("after"));
 775 }
 776
 777 TEST(InstructionsTest, AlterInvokeBundles) {
 778   LLVMContext C;
 779   Type *Int32Ty = Type::getInt32Ty(C);
 780   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
 781   Value *Callee = Constant::getNullValue(PointerType::getUnqual(C));
 782   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
 783   std::unique_ptr<BasicBlock> NormalDest(BasicBlock::Create(C));
 784   std::unique_ptr<BasicBlock> UnwindDest(BasicBlock::Create(C));
 785   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
 786   std::unique_ptr<InvokeInst> Invoke(
 787       InvokeInst::Create(FnTy, Callee, NormalDest.get(), UnwindDest.get(), Args,
 788                          OldBundle, "result"));
 789   AttrBuilder AB(C);
 790   AB.addAttribute(Attribute::Cold);
 791   Invoke->setAttributes(
 792       AttributeList::get(C, AttributeList::FunctionIndex, AB));
 793   Invoke->setDebugLoc(DebugLoc(MDNode::get(C, std::nullopt)));
 794
 795   OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
 796   std::unique_ptr<InvokeInst> Clone(
 797       InvokeInst::Create(Invoke.get(), NewBundle));
 798   EXPECT_EQ(Invoke->getNormalDest(), Clone->getNormalDest());
 799   EXPECT_EQ(Invoke->getUnwindDest(), Clone->getUnwindDest());
 800   EXPECT_EQ(Invoke->arg_size(), Clone->arg_size());
 801   EXPECT_EQ(Invoke->getArgOperand(0), Clone->getArgOperand(0));
 802   EXPECT_EQ(Invoke->getCallingConv(), Clone->getCallingConv());
 803   EXPECT_TRUE(Clone->hasFnAttr(Attribute::AttrKind::Cold));
 804   EXPECT_EQ(Invoke->getDebugLoc(), Clone->getDebugLoc());
 805   EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
 806   EXPECT_TRUE(Clone->getOperandBundle("after"));
 807 }
 808
 809 TEST_F(ModuleWithFunctionTest, DropPoisonGeneratingFlags) {
 810   auto *OnlyBB = BasicBlock::Create(Ctx, "bb", F);
 811   auto *Arg0 = &*F->arg_begin();
 812
 813   IRBuilder<NoFolder> B(Ctx);
 814   B.SetInsertPoint(OnlyBB);
 815
 816   {
 817     auto *UI =
 818         cast<Instruction>(B.CreateUDiv(Arg0, Arg0, "", /*isExact*/ true));
 819     ASSERT_TRUE(UI->isExact());
 820     UI->dropPoisonGeneratingFlags();
 821     ASSERT_FALSE(UI->isExact());
 822   }
 823
 824   {
 825     auto *ShrI =
 826         cast<Instruction>(B.CreateLShr(Arg0, Arg0, "", /*isExact*/ true));
 827     ASSERT_TRUE(ShrI->isExact());
 828     ShrI->dropPoisonGeneratingFlags();
 829     ASSERT_FALSE(ShrI->isExact());
 830   }
 831
 832   {
 833     auto *AI = cast<Instruction>(
 834         B.CreateAdd(Arg0, Arg0, "", /*HasNUW*/ true, /*HasNSW*/ false));
 835     ASSERT_TRUE(AI->hasNoUnsignedWrap());
 836     AI->dropPoisonGeneratingFlags();
 837     ASSERT_FALSE(AI->hasNoUnsignedWrap());
 838     ASSERT_FALSE(AI->hasNoSignedWrap());
 839   }
 840
 841   {
 842     auto *SI = cast<Instruction>(
 843         B.CreateAdd(Arg0, Arg0, "", /*HasNUW*/ false, /*HasNSW*/ true));
 844     ASSERT_TRUE(SI->hasNoSignedWrap());
 845     SI->dropPoisonGeneratingFlags();
 846     ASSERT_FALSE(SI->hasNoUnsignedWrap());
 847     ASSERT_FALSE(SI->hasNoSignedWrap());
 848   }
 849
 850   {
 851     auto *ShlI = cast<Instruction>(
 852         B.CreateShl(Arg0, Arg0, "", /*HasNUW*/ true, /*HasNSW*/ true));
 853     ASSERT_TRUE(ShlI->hasNoSignedWrap());
 854     ASSERT_TRUE(ShlI->hasNoUnsignedWrap());
 855     ShlI->dropPoisonGeneratingFlags();
 856     ASSERT_FALSE(ShlI->hasNoUnsignedWrap());
 857     ASSERT_FALSE(ShlI->hasNoSignedWrap());
 858   }
 859
 860   {
 861     Value *GEPBase = Constant::getNullValue(B.getPtrTy());
 862     auto *GI = cast<GetElementPtrInst>(
 863         B.CreateInBoundsGEP(B.getInt8Ty(), GEPBase, Arg0));
 864     ASSERT_TRUE(GI->isInBounds());
 865     GI->dropPoisonGeneratingFlags();
 866     ASSERT_FALSE(GI->isInBounds());
 867   }
 868 }
 869
 870 TEST(InstructionsTest, GEPIndices) {
 871   LLVMContext Context;
 872   IRBuilder<NoFolder> Builder(Context);
 873   Type *ElementTy = Builder.getInt8Ty();
 874   Type *ArrTy = ArrayType::get(ArrayType::get(ElementTy, 64), 64);
 875   Value *Indices[] = {
 876     Builder.getInt32(0),
 877     Builder.getInt32(13),
 878     Builder.getInt32(42) };
 879
 880   Value *V = Builder.CreateGEP(ArrTy, UndefValue::get(PointerType::getUnqual(ArrTy)),
 881                                Indices);
 882   ASSERT_TRUE(isa<GetElementPtrInst>(V));
 883
 884   auto *GEPI = cast<GetElementPtrInst>(V);
 885   ASSERT_NE(GEPI->idx_begin(), GEPI->idx_end());
 886   ASSERT_EQ(GEPI->idx_end(), std::next(GEPI->idx_begin(), 3));
 887   EXPECT_EQ(Indices[0], GEPI->idx_begin()[0]);
 888   EXPECT_EQ(Indices[1], GEPI->idx_begin()[1]);
 889   EXPECT_EQ(Indices[2], GEPI->idx_begin()[2]);
 890   EXPECT_EQ(GEPI->idx_begin(), GEPI->indices().begin());
 891   EXPECT_EQ(GEPI->idx_end(), GEPI->indices().end());
 892
 893   const auto *CGEPI = GEPI;
 894   ASSERT_NE(CGEPI->idx_begin(), CGEPI->idx_end());
 895   ASSERT_EQ(CGEPI->idx_end(), std::next(CGEPI->idx_begin(), 3));
 896   EXPECT_EQ(Indices[0], CGEPI->idx_begin()[0]);
 897   EXPECT_EQ(Indices[1], CGEPI->idx_begin()[1]);
 898   EXPECT_EQ(Indices[2], CGEPI->idx_begin()[2]);
 899   EXPECT_EQ(CGEPI->idx_begin(), CGEPI->indices().begin());
 900   EXPECT_EQ(CGEPI->idx_end(), CGEPI->indices().end());
 901
 902   delete GEPI;
 903 }
 904
 905 TEST(InstructionsTest, SwitchInst) {
 906   LLVMContext C;
 907
 908   std::unique_ptr<BasicBlock> BB1, BB2, BB3;
 909   BB1.reset(BasicBlock::Create(C));
 910   BB2.reset(BasicBlock::Create(C));
 911   BB3.reset(BasicBlock::Create(C));
 912
 913   // We create block 0 after the others so that it gets destroyed first and
 914   // clears the uses of the other basic blocks.
 915   std::unique_ptr<BasicBlock> BB0(BasicBlock::Create(C));
 916
 917   auto *Int32Ty = Type::getInt32Ty(C);
 918
 919   SwitchInst *SI =
 920       SwitchInst::Create(UndefValue::get(Int32Ty), BB0.get(), 3, BB0.get());
 921   SI->addCase(ConstantInt::get(Int32Ty, 1), BB1.get());
 922   SI->addCase(ConstantInt::get(Int32Ty, 2), BB2.get());
 923   SI->addCase(ConstantInt::get(Int32Ty, 3), BB3.get());
 924
 925   auto CI = SI->case_begin();
 926   ASSERT_NE(CI, SI->case_end());
 927   EXPECT_EQ(1, CI->getCaseValue()->getSExtValue());
 928   EXPECT_EQ(BB1.get(), CI->getCaseSuccessor());
 929   EXPECT_EQ(2, (CI + 1)->getCaseValue()->getSExtValue());
 930   EXPECT_EQ(BB2.get(), (CI + 1)->getCaseSuccessor());
 931   EXPECT_EQ(3, (CI + 2)->getCaseValue()->getSExtValue());
 932   EXPECT_EQ(BB3.get(), (CI + 2)->getCaseSuccessor());
 933   EXPECT_EQ(CI + 1, std::next(CI));
 934   EXPECT_EQ(CI + 2, std::next(CI, 2));
 935   EXPECT_EQ(CI + 3, std::next(CI, 3));
 936   EXPECT_EQ(SI->case_end(), CI + 3);
 937   EXPECT_EQ(0, CI - CI);
 938   EXPECT_EQ(1, (CI + 1) - CI);
 939   EXPECT_EQ(2, (CI + 2) - CI);
 940   EXPECT_EQ(3, SI->case_end() - CI);
 941   EXPECT_EQ(3, std::distance(CI, SI->case_end()));
 942
 943   auto CCI = const_cast<const SwitchInst *>(SI)->case_begin();
 944   SwitchInst::ConstCaseIt CCE = SI->case_end();
 945   ASSERT_NE(CCI, SI->case_end());
 946   EXPECT_EQ(1, CCI->getCaseValue()->getSExtValue());
 947   EXPECT_EQ(BB1.get(), CCI->getCaseSuccessor());
 948   EXPECT_EQ(2, (CCI + 1)->getCaseValue()->getSExtValue());
 949   EXPECT_EQ(BB2.get(), (CCI + 1)->getCaseSuccessor());
 950   EXPECT_EQ(3, (CCI + 2)->getCaseValue()->getSExtValue());
 951   EXPECT_EQ(BB3.get(), (CCI + 2)->getCaseSuccessor());
 952   EXPECT_EQ(CCI + 1, std::next(CCI));
 953   EXPECT_EQ(CCI + 2, std::next(CCI, 2));
 954   EXPECT_EQ(CCI + 3, std::next(CCI, 3));
 955   EXPECT_EQ(CCE, CCI + 3);
 956   EXPECT_EQ(0, CCI - CCI);
 957   EXPECT_EQ(1, (CCI + 1) - CCI);
 958   EXPECT_EQ(2, (CCI + 2) - CCI);
 959   EXPECT_EQ(3, CCE - CCI);
 960   EXPECT_EQ(3, std::distance(CCI, CCE));
 961
 962   // Make sure that the const iterator is compatible with a const auto ref.
 963   const auto &Handle = *CCI;
 964   EXPECT_EQ(1, Handle.getCaseValue()->getSExtValue());
 965   EXPECT_EQ(BB1.get(), Handle.getCaseSuccessor());
 966 }
 967
 968 TEST(InstructionsTest, SwitchInstProfUpdateWrapper) {
 969   LLVMContext C;
 970
 971   std::unique_ptr<BasicBlock> BB1, BB2, BB3;
 972   BB1.reset(BasicBlock::Create(C));
 973   BB2.reset(BasicBlock::Create(C));
 974   BB3.reset(BasicBlock::Create(C));
 975
 976   // We create block 0 after the others so that it gets destroyed first and
 977   // clears the uses of the other basic blocks.
 978   std::unique_ptr<BasicBlock> BB0(BasicBlock::Create(C));
 979
 980   auto *Int32Ty = Type::getInt32Ty(C);
 981
 982   SwitchInst *SI =
 983       SwitchInst::Create(UndefValue::get(Int32Ty), BB0.get(), 4, BB0.get());
 984   SI->addCase(ConstantInt::get(Int32Ty, 1), BB1.get());
 985   SI->addCase(ConstantInt::get(Int32Ty, 2), BB2.get());
 986   SI->setMetadata(LLVMContext::MD_prof,
 987                   MDBuilder(C).createBranchWeights({ 9, 1, 22 }));
 988
 989   {
 990     SwitchInstProfUpdateWrapper SIW(*SI);
 991     EXPECT_EQ(*SIW.getSuccessorWeight(0), 9u);
 992     EXPECT_EQ(*SIW.getSuccessorWeight(1), 1u);
 993     EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
 994     SIW.setSuccessorWeight(0, 99u);
 995     SIW.setSuccessorWeight(1, 11u);
 996     EXPECT_EQ(*SIW.getSuccessorWeight(0), 99u);
 997     EXPECT_EQ(*SIW.getSuccessorWeight(1), 11u);
 998     EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
 999   }
1000
1001   { // Create another wrapper and check that the data persist.
1002     SwitchInstProfUpdateWrapper SIW(*SI);
1003     EXPECT_EQ(*SIW.getSuccessorWeight(0), 99u);
1004     EXPECT_EQ(*SIW.getSuccessorWeight(1), 11u);
1005     EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
1006   }
1007 }
1008
1009 TEST(InstructionsTest, CommuteShuffleMask) {
1010   SmallVector<int, 16> Indices({-1, 0, 7});
1011   ShuffleVectorInst::commuteShuffleMask(Indices, 4);
1012   EXPECT_THAT(Indices, testing::ContainerEq(ArrayRef<int>({-1, 4, 3})));
1013 }
1014
1015 TEST(InstructionsTest, ShuffleMaskQueries) {
1016   // Create the elements for various constant vectors.
1017   LLVMContext Ctx;
1018   Type *Int32Ty = Type::getInt32Ty(Ctx);
1019   Constant *CU = UndefValue::get(Int32Ty);
1020   Constant *C0 = ConstantInt::get(Int32Ty, 0);
1021   Constant *C1 = ConstantInt::get(Int32Ty, 1);
1022   Constant *C2 = ConstantInt::get(Int32Ty, 2);
1023   Constant *C3 = ConstantInt::get(Int32Ty, 3);
1024   Constant *C4 = ConstantInt::get(Int32Ty, 4);
1025   Constant *C5 = ConstantInt::get(Int32Ty, 5);
1026   Constant *C6 = ConstantInt::get(Int32Ty, 6);
1027   Constant *C7 = ConstantInt::get(Int32Ty, 7);
1028
1029   Constant *Identity = ConstantVector::get({C0, CU, C2, C3, C4});
1030   EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(
1031       Identity, cast<FixedVectorType>(Identity->getType())->getNumElements()));
1032   EXPECT_FALSE(ShuffleVectorInst::isSelectMask(
1033       Identity,
1034       cast<FixedVectorType>(Identity->getType())
1035           ->getNumElements())); // identity is distinguished from select
1036   EXPECT_FALSE(ShuffleVectorInst::isReverseMask(
1037       Identity, cast<FixedVectorType>(Identity->getType())->getNumElements()));
1038   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1039       Identity, cast<FixedVectorType>(Identity->getType())
1040                     ->getNumElements())); // identity is always single source
1041   EXPECT_FALSE(ShuffleVectorInst::isZeroEltSplatMask(
1042       Identity, cast<FixedVectorType>(Identity->getType())->getNumElements()));
1043   EXPECT_FALSE(ShuffleVectorInst::isTransposeMask(
1044       Identity, cast<FixedVectorType>(Identity->getType())->getNumElements()));
1045
1046   Constant *Select = ConstantVector::get({CU, C1, C5});
1047   EXPECT_FALSE(ShuffleVectorInst::isIdentityMask(
1048       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1049   EXPECT_TRUE(ShuffleVectorInst::isSelectMask(
1050       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1051   EXPECT_FALSE(ShuffleVectorInst::isReverseMask(
1052       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1053   EXPECT_FALSE(ShuffleVectorInst::isSingleSourceMask(
1054       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1055   EXPECT_FALSE(ShuffleVectorInst::isZeroEltSplatMask(
1056       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1057   EXPECT_FALSE(ShuffleVectorInst::isTransposeMask(
1058       Select, cast<FixedVectorType>(Select->getType())->getNumElements()));
1059
1060   Constant *Reverse = ConstantVector::get({C3, C2, C1, CU});
1061   EXPECT_FALSE(ShuffleVectorInst::isIdentityMask(
1062       Reverse, cast<FixedVectorType>(Reverse->getType())->getNumElements()));
1063   EXPECT_FALSE(ShuffleVectorInst::isSelectMask(
1064       Reverse, cast<FixedVectorType>(Reverse->getType())->getNumElements()));
1065   EXPECT_TRUE(ShuffleVectorInst::isReverseMask(
1066       Reverse, cast<FixedVectorType>(Reverse->getType())->getNumElements()));
1067   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1068       Reverse, cast<FixedVectorType>(Reverse->getType())
1069                    ->getNumElements())); // reverse is always single source
1070   EXPECT_FALSE(ShuffleVectorInst::isZeroEltSplatMask(
1071       Reverse, cast<FixedVectorType>(Reverse->getType())->getNumElements()));
1072   EXPECT_FALSE(ShuffleVectorInst::isTransposeMask(
1073       Reverse, cast<FixedVectorType>(Reverse->getType())->getNumElements()));
1074
1075   Constant *SingleSource = ConstantVector::get({C2, C2, C0, CU});
1076   EXPECT_FALSE(ShuffleVectorInst::isIdentityMask(
1077       SingleSource,
1078       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1079   EXPECT_FALSE(ShuffleVectorInst::isSelectMask(
1080       SingleSource,
1081       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1082   EXPECT_FALSE(ShuffleVectorInst::isReverseMask(
1083       SingleSource,
1084       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1085   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1086       SingleSource,
1087       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1088   EXPECT_FALSE(ShuffleVectorInst::isZeroEltSplatMask(
1089       SingleSource,
1090       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1091   EXPECT_FALSE(ShuffleVectorInst::isTransposeMask(
1092       SingleSource,
1093       cast<FixedVectorType>(SingleSource->getType())->getNumElements()));
1094
1095   Constant *ZeroEltSplat = ConstantVector::get({C0, C0, CU, C0});
1096   EXPECT_FALSE(ShuffleVectorInst::isIdentityMask(
1097       ZeroEltSplat,
1098       cast<FixedVectorType>(ZeroEltSplat->getType())->getNumElements()));
1099   EXPECT_FALSE(ShuffleVectorInst::isSelectMask(
1100       ZeroEltSplat,
1101       cast<FixedVectorType>(ZeroEltSplat->getType())->getNumElements()));
1102   EXPECT_FALSE(ShuffleVectorInst::isReverseMask(
1103       ZeroEltSplat,
1104       cast<FixedVectorType>(ZeroEltSplat->getType())->getNumElements()));
1105   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1106       ZeroEltSplat, cast<FixedVectorType>(ZeroEltSplat->getType())
1107                         ->getNumElements())); // 0-splat is always single source
1108   EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(
1109       ZeroEltSplat,
1110       cast<FixedVectorType>(ZeroEltSplat->getType())->getNumElements()));
1111   EXPECT_FALSE(ShuffleVectorInst::isTransposeMask(
1112       ZeroEltSplat,
1113       cast<FixedVectorType>(ZeroEltSplat->getType())->getNumElements()));
1114
1115   Constant *Transpose = ConstantVector::get({C0, C4, C2, C6});
1116   EXPECT_FALSE(ShuffleVectorInst::isIdentityMask(
1117       Transpose,
1118       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1119   EXPECT_FALSE(ShuffleVectorInst::isSelectMask(
1120       Transpose,
1121       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1122   EXPECT_FALSE(ShuffleVectorInst::isReverseMask(
1123       Transpose,
1124       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1125   EXPECT_FALSE(ShuffleVectorInst::isSingleSourceMask(
1126       Transpose,
1127       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1128   EXPECT_FALSE(ShuffleVectorInst::isZeroEltSplatMask(
1129       Transpose,
1130       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1131   EXPECT_TRUE(ShuffleVectorInst::isTransposeMask(
1132       Transpose,
1133       cast<FixedVectorType>(Transpose->getType())->getNumElements()));
1134
1135   // More tests to make sure the logic is/stays correct...
1136   EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(
1137       ConstantVector::get({CU, C1, CU, C3}), 4));
1138   EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(
1139       ConstantVector::get({C4, CU, C6, CU}), 4));
1140
1141   EXPECT_TRUE(ShuffleVectorInst::isSelectMask(
1142       ConstantVector::get({C4, C1, C6, CU}), 4));
1143   EXPECT_TRUE(ShuffleVectorInst::isSelectMask(
1144       ConstantVector::get({CU, C1, C6, C3}), 4));
1145
1146   EXPECT_TRUE(ShuffleVectorInst::isReverseMask(
1147       ConstantVector::get({C7, C6, CU, C4}), 4));
1148   EXPECT_TRUE(ShuffleVectorInst::isReverseMask(
1149       ConstantVector::get({C3, CU, C1, CU}), 4));
1150
1151   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1152       ConstantVector::get({C7, C5, CU, C7}), 4));
1153   EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(
1154       ConstantVector::get({C3, C0, CU, C3}), 4));
1155
1156   EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(
1157       ConstantVector::get({C4, CU, CU, C4}), 4));
1158   EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(
1159       ConstantVector::get({CU, C0, CU, C0}), 4));
1160
1161   EXPECT_TRUE(ShuffleVectorInst::isTransposeMask(
1162       ConstantVector::get({C1, C5, C3, C7}), 4));
1163   EXPECT_TRUE(
1164       ShuffleVectorInst::isTransposeMask(ConstantVector::get({C1, C3}), 2));
1165
1166   // Nothing special about the values here - just re-using inputs to reduce code.
1167   Constant *V0 = ConstantVector::get({C0, C1, C2, C3});
1168   Constant *V1 = ConstantVector::get({C3, C2, C1, C0});
1169
1170   // Identity with undef elts.
1171   ShuffleVectorInst *Id1 = new ShuffleVectorInst(V0, V1,
1172                                                  ConstantVector::get({C0, C1, CU, CU}));
1173   EXPECT_TRUE(Id1->isIdentity());
1174   EXPECT_FALSE(Id1->isIdentityWithPadding());
1175   EXPECT_FALSE(Id1->isIdentityWithExtract());
1176   EXPECT_FALSE(Id1->isConcat());
1177   delete Id1;
1178
1179   // Result has less elements than operands.
1180   ShuffleVectorInst *Id2 = new ShuffleVectorInst(V0, V1,
1181                                                  ConstantVector::get({C0, C1, C2}));
1182   EXPECT_FALSE(Id2->isIdentity());
1183   EXPECT_FALSE(Id2->isIdentityWithPadding());
1184   EXPECT_TRUE(Id2->isIdentityWithExtract());
1185   EXPECT_FALSE(Id2->isConcat());
1186   delete Id2;
1187
1188   // Result has less elements than operands; choose from Op1.
1189   ShuffleVectorInst *Id3 = new ShuffleVectorInst(V0, V1,
1190                                                  ConstantVector::get({C4, CU, C6}));
1191   EXPECT_FALSE(Id3->isIdentity());
1192   EXPECT_FALSE(Id3->isIdentityWithPadding());
1193   EXPECT_TRUE(Id3->isIdentityWithExtract());
1194   EXPECT_FALSE(Id3->isConcat());
1195   delete Id3;
1196
1197   // Result has less elements than operands; choose from Op0 and Op1 is not identity.
1198   ShuffleVectorInst *Id4 = new ShuffleVectorInst(V0, V1,
1199                                                  ConstantVector::get({C4, C1, C6}));
1200   EXPECT_FALSE(Id4->isIdentity());
1201   EXPECT_FALSE(Id4->isIdentityWithPadding());
1202   EXPECT_FALSE(Id4->isIdentityWithExtract());
1203   EXPECT_FALSE(Id4->isConcat());
1204   delete Id4;
1205
1206   // Result has more elements than operands, and extra elements are undef.
1207   ShuffleVectorInst *Id5 = new ShuffleVectorInst(V0, V1,
1208                                                  ConstantVector::get({CU, C1, C2, C3, CU, CU}));
1209   EXPECT_FALSE(Id5->isIdentity());
1210   EXPECT_TRUE(Id5->isIdentityWithPadding());
1211   EXPECT_FALSE(Id5->isIdentityWithExtract());
1212   EXPECT_FALSE(Id5->isConcat());
1213   delete Id5;
1214
1215   // Result has more elements than operands, and extra elements are undef; choose from Op1.
1216   ShuffleVectorInst *Id6 = new ShuffleVectorInst(V0, V1,
1217                                                  ConstantVector::get({C4, C5, C6, CU, CU, CU}));
1218   EXPECT_FALSE(Id6->isIdentity());
1219   EXPECT_TRUE(Id6->isIdentityWithPadding());
1220   EXPECT_FALSE(Id6->isIdentityWithExtract());
1221   EXPECT_FALSE(Id6->isConcat());
1222   delete Id6;
1223
1224   // Result has more elements than operands, but extra elements are not undef.
1225   ShuffleVectorInst *Id7 = new ShuffleVectorInst(V0, V1,
1226                                                  ConstantVector::get({C0, C1, C2, C3, CU, C1}));
1227   EXPECT_FALSE(Id7->isIdentity());
1228   EXPECT_FALSE(Id7->isIdentityWithPadding());
1229   EXPECT_FALSE(Id7->isIdentityWithExtract());
1230   EXPECT_FALSE(Id7->isConcat());
1231   delete Id7;
1232
1233   // Result has more elements than operands; choose from Op0 and Op1 is not identity.
1234   ShuffleVectorInst *Id8 = new ShuffleVectorInst(V0, V1,
1235                                                  ConstantVector::get({C4, CU, C2, C3, CU, CU}));
1236   EXPECT_FALSE(Id8->isIdentity());
1237   EXPECT_FALSE(Id8->isIdentityWithPadding());
1238   EXPECT_FALSE(Id8->isIdentityWithExtract());
1239   EXPECT_FALSE(Id8->isConcat());
1240   delete Id8;
1241
1242   // Result has twice as many elements as operands; choose consecutively from Op0 and Op1 is concat.
1243   ShuffleVectorInst *Id9 = new ShuffleVectorInst(V0, V1,
1244                                                  ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7}));
1245   EXPECT_FALSE(Id9->isIdentity());
1246   EXPECT_FALSE(Id9->isIdentityWithPadding());
1247   EXPECT_FALSE(Id9->isIdentityWithExtract());
1248   EXPECT_TRUE(Id9->isConcat());
1249   delete Id9;
1250
1251   // Result has less than twice as many elements as operands, so not a concat.
1252   ShuffleVectorInst *Id10 = new ShuffleVectorInst(V0, V1,
1253                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6}));
1254   EXPECT_FALSE(Id10->isIdentity());
1255   EXPECT_FALSE(Id10->isIdentityWithPadding());
1256   EXPECT_FALSE(Id10->isIdentityWithExtract());
1257   EXPECT_FALSE(Id10->isConcat());
1258   delete Id10;
1259
1260   // Result has more than twice as many elements as operands, so not a concat.
1261   ShuffleVectorInst *Id11 = new ShuffleVectorInst(V0, V1,
1262                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7, CU}));
1263   EXPECT_FALSE(Id11->isIdentity());
1264   EXPECT_FALSE(Id11->isIdentityWithPadding());
1265   EXPECT_FALSE(Id11->isIdentityWithExtract());
1266   EXPECT_FALSE(Id11->isConcat());
1267   delete Id11;
1268
1269   // If an input is undef, it's not a concat.
1270   // TODO: IdentityWithPadding should be true here even though the high mask values are not undef.
1271   ShuffleVectorInst *Id12 = new ShuffleVectorInst(V0, ConstantVector::get({CU, CU, CU, CU}),
1272                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7}));
1273   EXPECT_FALSE(Id12->isIdentity());
1274   EXPECT_FALSE(Id12->isIdentityWithPadding());
1275   EXPECT_FALSE(Id12->isIdentityWithExtract());
1276   EXPECT_FALSE(Id12->isConcat());
1277   delete Id12;
1278
1279   // Not possible to express shuffle mask for scalable vector for extract
1280   // subvector.
1281   Type *VScaleV4Int32Ty = ScalableVectorType::get(Int32Ty, 4);
1282   ShuffleVectorInst *Id13 =
1283       new ShuffleVectorInst(Constant::getAllOnesValue(VScaleV4Int32Ty),
1284                             UndefValue::get(VScaleV4Int32Ty),
1285                             Constant::getNullValue(VScaleV4Int32Ty));
1286   int Index = 0;
1287   EXPECT_FALSE(Id13->isExtractSubvectorMask(Index));
1288   EXPECT_FALSE(Id13->changesLength());
1289   EXPECT_FALSE(Id13->increasesLength());
1290   delete Id13;
1291
1292   // Result has twice as many operands.
1293   Type *VScaleV2Int32Ty = ScalableVectorType::get(Int32Ty, 2);
1294   ShuffleVectorInst *Id14 =
1295       new ShuffleVectorInst(Constant::getAllOnesValue(VScaleV2Int32Ty),
1296                             UndefValue::get(VScaleV2Int32Ty),
1297                             Constant::getNullValue(VScaleV4Int32Ty));
1298   EXPECT_TRUE(Id14->changesLength());
1299   EXPECT_TRUE(Id14->increasesLength());
1300   delete Id14;
1301
1302   // Not possible to express these masks for scalable vectors, make sure we
1303   // don't crash.
1304   ShuffleVectorInst *Id15 =
1305       new ShuffleVectorInst(Constant::getAllOnesValue(VScaleV2Int32Ty),
1306                             Constant::getNullValue(VScaleV2Int32Ty),
1307                             Constant::getNullValue(VScaleV2Int32Ty));
1308   EXPECT_FALSE(Id15->isIdentityWithPadding());
1309   EXPECT_FALSE(Id15->isIdentityWithExtract());
1310   EXPECT_FALSE(Id15->isConcat());
1311   delete Id15;
1312 }
1313
1314 TEST(InstructionsTest, ShuffleMaskIsReplicationMask) {
1315   for (int ReplicationFactor : seq_inclusive(1, 8)) {
1316     for (int VF : seq_inclusive(1, 8)) {
1317       const auto ReplicatedMask = createReplicatedMask(ReplicationFactor, VF);
1318       int GuessedReplicationFactor = -1, GuessedVF = -1;
1319       EXPECT_TRUE(ShuffleVectorInst::isReplicationMask(
1320           ReplicatedMask, GuessedReplicationFactor, GuessedVF));
1321       EXPECT_EQ(GuessedReplicationFactor, ReplicationFactor);
1322       EXPECT_EQ(GuessedVF, VF);
1323
1324       for (int OpVF : seq_inclusive(VF, 2 * VF + 1)) {
1325         LLVMContext Ctx;
1326         Type *OpVFTy = FixedVectorType::get(IntegerType::getInt1Ty(Ctx), OpVF);
1327         Value *Op = ConstantVector::getNullValue(OpVFTy);
1328         ShuffleVectorInst *SVI = new ShuffleVectorInst(Op, Op, ReplicatedMask);
1329         EXPECT_EQ(SVI->isReplicationMask(GuessedReplicationFactor, GuessedVF),
1330                   OpVF == VF);
1331         delete SVI;
1332       }
1333     }
1334   }
1335 }
1336
1337 TEST(InstructionsTest, ShuffleMaskIsReplicationMask_undef) {
1338   for (int ReplicationFactor : seq_inclusive(1, 4)) {
1339     for (int VF : seq_inclusive(1, 4)) {
1340       const auto ReplicatedMask = createReplicatedMask(ReplicationFactor, VF);
1341       int GuessedReplicationFactor = -1, GuessedVF = -1;
1342
1343       // If we change some mask elements to undef, we should still match.
1344
1345       SmallVector<SmallVector<bool>> ElementChoices(ReplicatedMask.size(),
1346                                                     {false, true});
1347
1348       CombinationGenerator<bool, decltype(ElementChoices)::value_type,
1349                            /*variable_smallsize=*/4>
1350           G(ElementChoices);
1351
1352       G.generate([&](ArrayRef<bool> UndefOverrides) -> bool {
1353         SmallVector<int> AdjustedMask;
1354         AdjustedMask.reserve(ReplicatedMask.size());
1355         for (auto I : zip(ReplicatedMask, UndefOverrides))
1356           AdjustedMask.emplace_back(std::get<1>(I) ? -1 : std::get<0>(I));
1357         assert(AdjustedMask.size() == ReplicatedMask.size() &&
1358                "Size misprediction");
1359
1360         EXPECT_TRUE(ShuffleVectorInst::isReplicationMask(
1361             AdjustedMask, GuessedReplicationFactor, GuessedVF));
1362         // Do not check GuessedReplicationFactor and GuessedVF,
1363         // with enough undef's we may deduce a different tuple.
1364
1365         return /*Abort=*/false;
1366       });
1367     }
1368   }
1369 }
1370
1371 TEST(InstructionsTest, ShuffleMaskIsReplicationMask_Exhaustive_Correctness) {
1372   for (int ShufMaskNumElts : seq_inclusive(1, 6)) {
1373     SmallVector<int> PossibleShufMaskElts;
1374     PossibleShufMaskElts.reserve(ShufMaskNumElts + 2);
1375     for (int PossibleShufMaskElt : seq_inclusive(-1, ShufMaskNumElts))
1376       PossibleShufMaskElts.emplace_back(PossibleShufMaskElt);
1377     assert(PossibleShufMaskElts.size() == ShufMaskNumElts + 2U &&
1378            "Size misprediction");
1379
1380     SmallVector<SmallVector<int>> ElementChoices(ShufMaskNumElts,
1381                                                  PossibleShufMaskElts);
1382
1383     CombinationGenerator<int, decltype(ElementChoices)::value_type,
1384                          /*variable_smallsize=*/4>
1385         G(ElementChoices);
1386
1387     G.generate([&](ArrayRef<int> Mask) -> bool {
1388       int GuessedReplicationFactor = -1, GuessedVF = -1;
1389       bool Match = ShuffleVectorInst::isReplicationMask(
1390           Mask, GuessedReplicationFactor, GuessedVF);
1391       if (!Match)
1392         return /*Abort=*/false;
1393
1394       const auto ActualMask =
1395           createReplicatedMask(GuessedReplicationFactor, GuessedVF);
1396       EXPECT_EQ(Mask.size(), ActualMask.size());
1397       for (auto I : zip(Mask, ActualMask)) {
1398         int Elt = std::get<0>(I);
1399         int ActualElt = std::get<0>(I);
1400
1401         if (Elt != -1) {
1402           EXPECT_EQ(Elt, ActualElt);
1403         }
1404       }
1405
1406       return /*Abort=*/false;
1407     });
1408   }
1409 }
1410
1411 TEST(InstructionsTest, GetSplat) {
1412   // Create the elements for various constant vectors.
1413   LLVMContext Ctx;
1414   Type *Int32Ty = Type::getInt32Ty(Ctx);
1415   Constant *CU = UndefValue::get(Int32Ty);
1416   Constant *CP = PoisonValue::get(Int32Ty);
1417   Constant *C0 = ConstantInt::get(Int32Ty, 0);
1418   Constant *C1 = ConstantInt::get(Int32Ty, 1);
1419
1420   Constant *Splat0 = ConstantVector::get({C0, C0, C0, C0});
1421   Constant *Splat1 = ConstantVector::get({C1, C1, C1, C1 ,C1});
1422   Constant *Splat0Undef = ConstantVector::get({C0, CU, C0, CU});
1423   Constant *Splat1Undef = ConstantVector::get({CU, CU, C1, CU});
1424   Constant *NotSplat = ConstantVector::get({C1, C1, C0, C1 ,C1});
1425   Constant *NotSplatUndef = ConstantVector::get({CU, C1, CU, CU ,C0});
1426   Constant *Splat0Poison = ConstantVector::get({C0, CP, C0, CP});
1427   Constant *Splat1Poison = ConstantVector::get({CP, CP, C1, CP});
1428   Constant *NotSplatPoison = ConstantVector::get({CP, C1, CP, CP, C0});
1429
1430   // Default - undef/poison is not allowed.
1431   EXPECT_EQ(Splat0->getSplatValue(), C0);
1432   EXPECT_EQ(Splat1->getSplatValue(), C1);
1433   EXPECT_EQ(Splat0Undef->getSplatValue(), nullptr);
1434   EXPECT_EQ(Splat1Undef->getSplatValue(), nullptr);
1435   EXPECT_EQ(Splat0Poison->getSplatValue(), nullptr);
1436   EXPECT_EQ(Splat1Poison->getSplatValue(), nullptr);
1437   EXPECT_EQ(NotSplat->getSplatValue(), nullptr);
1438   EXPECT_EQ(NotSplatUndef->getSplatValue(), nullptr);
1439   EXPECT_EQ(NotSplatPoison->getSplatValue(), nullptr);
1440
1441   // Disallow poison explicitly.
1442   EXPECT_EQ(Splat0->getSplatValue(false), C0);
1443   EXPECT_EQ(Splat1->getSplatValue(false), C1);
1444   EXPECT_EQ(Splat0Undef->getSplatValue(false), nullptr);
1445   EXPECT_EQ(Splat1Undef->getSplatValue(false), nullptr);
1446   EXPECT_EQ(Splat0Poison->getSplatValue(false), nullptr);
1447   EXPECT_EQ(Splat1Poison->getSplatValue(false), nullptr);
1448   EXPECT_EQ(NotSplat->getSplatValue(false), nullptr);
1449   EXPECT_EQ(NotSplatUndef->getSplatValue(false), nullptr);
1450   EXPECT_EQ(NotSplatPoison->getSplatValue(false), nullptr);
1451
1452   // Allow poison but not undef.
1453   EXPECT_EQ(Splat0->getSplatValue(true), C0);
1454   EXPECT_EQ(Splat1->getSplatValue(true), C1);
1455   EXPECT_EQ(Splat0Undef->getSplatValue(true), nullptr);
1456   EXPECT_EQ(Splat1Undef->getSplatValue(true), nullptr);
1457   EXPECT_EQ(Splat0Poison->getSplatValue(true), C0);
1458   EXPECT_EQ(Splat1Poison->getSplatValue(true), C1);
1459   EXPECT_EQ(NotSplat->getSplatValue(true), nullptr);
1460   EXPECT_EQ(NotSplatUndef->getSplatValue(true), nullptr);
1461   EXPECT_EQ(NotSplatPoison->getSplatValue(true), nullptr);
1462 }
1463
1464 TEST(InstructionsTest, SkipDebug) {
1465   LLVMContext C;
1466   bool OldDbgValueMode = UseNewDbgInfoFormat;
1467   UseNewDbgInfoFormat = false;
1468   std::unique_ptr<Module> M = parseIR(C,
1469                                       R"(
1470       declare void @llvm.dbg.value(metadata, metadata, metadata)
1471
1472       define void @f() {
1473       entry:
1474         call void @llvm.dbg.value(metadata i32 0, metadata !11, metadata !DIExpression()), !dbg !13
1475         ret void
1476       }
1477
1478       !llvm.dbg.cu = !{!0}
1479       !llvm.module.flags = !{!3, !4}
1480       !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 6.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
1481       !1 = !DIFile(filename: "t2.c", directory: "foo")
1482       !2 = !{}
1483       !3 = !{i32 2, !"Dwarf Version", i32 4}
1484       !4 = !{i32 2, !"Debug Info Version", i32 3}
1485       !8 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !9, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, unit: !0, retainedNodes: !2)
1486       !9 = !DISubroutineType(types: !10)
1487       !10 = !{null}
1488       !11 = !DILocalVariable(name: "x", scope: !8, file: !1, line: 2, type: !12)
1489       !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
1490       !13 = !DILocation(line: 2, column: 7, scope: !8)
1491   )");
1492   ASSERT_TRUE(M);
1493   Function *F = cast<Function>(M->getNamedValue("f"));
1494   BasicBlock &BB = F->front();
1495
1496   // The first non-debug instruction is the terminator.
1497   auto *Term = BB.getTerminator();
1498   EXPECT_EQ(Term, BB.begin()->getNextNonDebugInstruction());
1499   EXPECT_EQ(Term->getIterator(), skipDebugIntrinsics(BB.begin()));
1500
1501   // After the terminator, there are no non-debug instructions.
1502   EXPECT_EQ(nullptr, Term->getNextNonDebugInstruction());
1503   UseNewDbgInfoFormat = OldDbgValueMode;
1504 }
1505
1506 TEST(InstructionsTest, PhiMightNotBeFPMathOperator) {
1507   LLVMContext Context;
1508   IRBuilder<> Builder(Context);
1509   MDBuilder MDHelper(Context);
1510   Instruction *I = Builder.CreatePHI(Builder.getInt32Ty(), 0);
1511   EXPECT_FALSE(isa<FPMathOperator>(I));
1512   I->deleteValue();
1513   Instruction *FP = Builder.CreatePHI(Builder.getDoubleTy(), 0);
1514   EXPECT_TRUE(isa<FPMathOperator>(FP));
1515   FP->deleteValue();
1516 }
1517
1518 TEST(InstructionsTest, FPCallIsFPMathOperator) {
1519   LLVMContext C;
1520
1521   Type *ITy = Type::getInt32Ty(C);
1522   FunctionType *IFnTy = FunctionType::get(ITy, {});
1523   PointerType *PtrTy = PointerType::getUnqual(C);
1524   Value *ICallee = Constant::getNullValue(PtrTy);
1525   std::unique_ptr<CallInst> ICall(CallInst::Create(IFnTy, ICallee, {}, ""));
1526   EXPECT_FALSE(isa<FPMathOperator>(ICall));
1527
1528   Type *VITy = FixedVectorType::get(ITy, 2);
1529   FunctionType *VIFnTy = FunctionType::get(VITy, {});
1530   Value *VICallee = Constant::getNullValue(PtrTy);
1531   std::unique_ptr<CallInst> VICall(CallInst::Create(VIFnTy, VICallee, {}, ""));
1532   EXPECT_FALSE(isa<FPMathOperator>(VICall));
1533
1534   Type *AITy = ArrayType::get(ITy, 2);
1535   FunctionType *AIFnTy = FunctionType::get(AITy, {});
1536   Value *AICallee = Constant::getNullValue(PtrTy);
1537   std::unique_ptr<CallInst> AICall(CallInst::Create(AIFnTy, AICallee, {}, ""));
1538   EXPECT_FALSE(isa<FPMathOperator>(AICall));
1539
1540   Type *FTy = Type::getFloatTy(C);
1541   FunctionType *FFnTy = FunctionType::get(FTy, {});
1542   Value *FCallee = Constant::getNullValue(PtrTy);
1543   std::unique_ptr<CallInst> FCall(CallInst::Create(FFnTy, FCallee, {}, ""));
1544   EXPECT_TRUE(isa<FPMathOperator>(FCall));
1545
1546   Type *VFTy = FixedVectorType::get(FTy, 2);
1547   FunctionType *VFFnTy = FunctionType::get(VFTy, {});
1548   Value *VFCallee = Constant::getNullValue(PtrTy);
1549   std::unique_ptr<CallInst> VFCall(CallInst::Create(VFFnTy, VFCallee, {}, ""));
1550   EXPECT_TRUE(isa<FPMathOperator>(VFCall));
1551
1552   Type *AFTy = ArrayType::get(FTy, 2);
1553   FunctionType *AFFnTy = FunctionType::get(AFTy, {});
1554   Value *AFCallee = Constant::getNullValue(PtrTy);
1555   std::unique_ptr<CallInst> AFCall(CallInst::Create(AFFnTy, AFCallee, {}, ""));
1556   EXPECT_TRUE(isa<FPMathOperator>(AFCall));
1557
1558   Type *AVFTy = ArrayType::get(VFTy, 2);
1559   FunctionType *AVFFnTy = FunctionType::get(AVFTy, {});
1560   Value *AVFCallee = Constant::getNullValue(PtrTy);
1561   std::unique_ptr<CallInst> AVFCall(
1562       CallInst::Create(AVFFnTy, AVFCallee, {}, ""));
1563   EXPECT_TRUE(isa<FPMathOperator>(AVFCall));
1564
1565   Type *AAVFTy = ArrayType::get(AVFTy, 2);
1566   FunctionType *AAVFFnTy = FunctionType::get(AAVFTy, {});
1567   Value *AAVFCallee = Constant::getNullValue(PtrTy);
1568   std::unique_ptr<CallInst> AAVFCall(
1569       CallInst::Create(AAVFFnTy, AAVFCallee, {}, ""));
1570   EXPECT_TRUE(isa<FPMathOperator>(AAVFCall));
1571 }
1572
1573 TEST(InstructionsTest, FNegInstruction) {
1574   LLVMContext Context;
1575   Type *FltTy = Type::getFloatTy(Context);
1576   Constant *One = ConstantFP::get(FltTy, 1.0);
1577   BinaryOperator *FAdd = BinaryOperator::CreateFAdd(One, One);
1578   FAdd->setHasNoNaNs(true);
1579   UnaryOperator *FNeg = UnaryOperator::CreateFNegFMF(One, FAdd);
1580   EXPECT_TRUE(FNeg->hasNoNaNs());
1581   EXPECT_FALSE(FNeg->hasNoInfs());
1582   EXPECT_FALSE(FNeg->hasNoSignedZeros());
1583   EXPECT_FALSE(FNeg->hasAllowReciprocal());
1584   EXPECT_FALSE(FNeg->hasAllowContract());
1585   EXPECT_FALSE(FNeg->hasAllowReassoc());
1586   EXPECT_FALSE(FNeg->hasApproxFunc());
1587   FAdd->deleteValue();
1588   FNeg->deleteValue();
1589 }
1590
1591 TEST(InstructionsTest, CallBrInstruction) {
1592   LLVMContext Context;
1593   std::unique_ptr<Module> M = parseIR(Context, R"(
1594 define void @foo() {
1595 entry:
1596   callbr void asm sideeffect "// XXX: ${0:l}", "!i"()
1597           to label %land.rhs.i [label %branch_test.exit]
1598
1599 land.rhs.i:
1600   br label %branch_test.exit
1601
1602 branch_test.exit:
1603   %0 = phi i1 [ true, %entry ], [ false, %land.rhs.i ]
1604   br i1 %0, label %if.end, label %if.then
1605
1606 if.then:
1607   ret void
1608
1609 if.end:
1610   ret void
1611 }
1612 )");
1613   Function *Foo = M->getFunction("foo");
1614   auto BBs = Foo->begin();
1615   CallBrInst &CBI = cast<CallBrInst>(BBs->front());
1616   ++BBs;
1617   ++BBs;
1618   BasicBlock &BranchTestExit = *BBs;
1619   ++BBs;
1620   BasicBlock &IfThen = *BBs;
1621
1622   // Test that setting the first indirect destination of callbr updates the dest
1623   EXPECT_EQ(&BranchTestExit, CBI.getIndirectDest(0));
1624   CBI.setIndirectDest(0, &IfThen);
1625   EXPECT_EQ(&IfThen, CBI.getIndirectDest(0));
1626 }
1627
1628 TEST(InstructionsTest, UnaryOperator) {
1629   LLVMContext Context;
1630   IRBuilder<> Builder(Context);
1631   Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
1632   Value *F = Builder.CreateFNeg(I);
1633
1634   EXPECT_TRUE(isa<Value>(F));
1635   EXPECT_TRUE(isa<Instruction>(F));
1636   EXPECT_TRUE(isa<UnaryInstruction>(F));
1637   EXPECT_TRUE(isa<UnaryOperator>(F));
1638   EXPECT_FALSE(isa<BinaryOperator>(F));
1639
1640   F->deleteValue();
1641   I->deleteValue();
1642 }
1643
1644 TEST(InstructionsTest, DropLocation) {
1645   LLVMContext C;
1646   std::unique_ptr<Module> M = parseIR(C,
1647                                       R"(
1648       declare void @callee()
1649
1650       define void @no_parent_scope() {
1651         call void @callee()           ; I1: Call with no location.
1652         call void @callee(), !dbg !11 ; I2: Call with location.
1653         ret void, !dbg !11            ; I3: Non-call with location.
1654       }
1655
1656       define void @with_parent_scope() !dbg !8 {
1657         call void @callee()           ; I1: Call with no location.
1658         call void @callee(), !dbg !11 ; I2: Call with location.
1659         ret void, !dbg !11            ; I3: Non-call with location.
1660       }
1661
1662       !llvm.dbg.cu = !{!0}
1663       !llvm.module.flags = !{!3, !4}
1664       !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
1665       !1 = !DIFile(filename: "t2.c", directory: "foo")
1666       !2 = !{}
1667       !3 = !{i32 2, !"Dwarf Version", i32 4}
1668       !4 = !{i32 2, !"Debug Info Version", i32 3}
1669       !8 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !9, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, unit: !0, retainedNodes: !2)
1670       !9 = !DISubroutineType(types: !10)
1671       !10 = !{null}
1672       !11 = !DILocation(line: 2, column: 7, scope: !8, inlinedAt: !12)
1673       !12 = !DILocation(line: 3, column: 8, scope: !8)
1674   )");
1675   ASSERT_TRUE(M);
1676
1677   {
1678     Function *NoParentScopeF =
1679         cast<Function>(M->getNamedValue("no_parent_scope"));
1680     BasicBlock &BB = NoParentScopeF->front();
1681
1682     auto *I1 = BB.getFirstNonPHI();
1683     auto *I2 = I1->getNextNode();
1684     auto *I3 = BB.getTerminator();
1685
1686     EXPECT_EQ(I1->getDebugLoc(), DebugLoc());
1687     I1->dropLocation();
1688     EXPECT_EQ(I1->getDebugLoc(), DebugLoc());
1689
1690     EXPECT_EQ(I2->getDebugLoc().getLine(), 2U);
1691     I2->dropLocation();
1692     EXPECT_EQ(I1->getDebugLoc(), DebugLoc());
1693
1694     EXPECT_EQ(I3->getDebugLoc().getLine(), 2U);
1695     I3->dropLocation();
1696     EXPECT_EQ(I3->getDebugLoc(), DebugLoc());
1697   }
1698
1699   {
1700     Function *WithParentScopeF =
1701         cast<Function>(M->getNamedValue("with_parent_scope"));
1702     BasicBlock &BB = WithParentScopeF->front();
1703
1704     auto *I2 = BB.getFirstNonPHI()->getNextNode();
1705
1706     MDNode *Scope = cast<MDNode>(WithParentScopeF->getSubprogram());
1707     EXPECT_EQ(I2->getDebugLoc().getLine(), 2U);
1708     I2->dropLocation();
1709     EXPECT_EQ(I2->getDebugLoc().getLine(), 0U);
1710     EXPECT_EQ(I2->getDebugLoc().getScope(), Scope);
1711     EXPECT_EQ(I2->getDebugLoc().getInlinedAt(), nullptr);
1712   }
1713 }
1714
1715 TEST(InstructionsTest, BranchWeightOverflow) {
1716   LLVMContext C;
1717   std::unique_ptr<Module> M = parseIR(C,
1718                                       R"(
1719       declare void @callee()
1720
1721       define void @caller() {
1722         call void @callee(), !prof !1
1723         ret void
1724       }
1725
1726       !1 = !{!"branch_weights", i32 20000}
1727   )");
1728   ASSERT_TRUE(M);
1729   CallInst *CI =
1730       cast<CallInst>(&M->getFunction("caller")->getEntryBlock().front());
1731   uint64_t ProfWeight;
1732   CI->extractProfTotalWeight(ProfWeight);
1733   ASSERT_EQ(ProfWeight, 20000U);
1734   CI->updateProfWeight(10000000, 1);
1735   CI->extractProfTotalWeight(ProfWeight);
1736   ASSERT_EQ(ProfWeight, UINT32_MAX);
1737 }
1738
1739 TEST(InstructionsTest, AllocaInst) {
1740   LLVMContext Ctx;
1741   std::unique_ptr<Module> M = parseIR(Ctx, R"(
1742       %T = type { i64, [3 x i32]}
1743       define void @f(i32 %n) {
1744       entry:
1745         %A = alloca i32, i32 1
1746         %B = alloca i32, i32 4
1747         %C = alloca i32, i32 %n
1748         %D = alloca <8 x double>
1749         %E = alloca <vscale x 8 x double>
1750         %F = alloca [2 x half]
1751         %G = alloca [2 x [3 x i128]]
1752         %H = alloca %T
1753         %I = alloca i32, i64 9223372036854775807
1754         ret void
1755       }
1756     )");
1757   const DataLayout &DL = M->getDataLayout();
1758   ASSERT_TRUE(M);
1759   Function *Fun = cast<Function>(M->getNamedValue("f"));
1760   BasicBlock &BB = Fun->front();
1761   auto It = BB.begin();
1762   AllocaInst &A = cast<AllocaInst>(*It++);
1763   AllocaInst &B = cast<AllocaInst>(*It++);
1764   AllocaInst &C = cast<AllocaInst>(*It++);
1765   AllocaInst &D = cast<AllocaInst>(*It++);
1766   AllocaInst &E = cast<AllocaInst>(*It++);
1767   AllocaInst &F = cast<AllocaInst>(*It++);
1768   AllocaInst &G = cast<AllocaInst>(*It++);
1769   AllocaInst &H = cast<AllocaInst>(*It++);
1770   AllocaInst &I = cast<AllocaInst>(*It++);
1771   EXPECT_EQ(A.getAllocationSizeInBits(DL), TypeSize::getFixed(32));
1772   EXPECT_EQ(B.getAllocationSizeInBits(DL), TypeSize::getFixed(128));
1773   EXPECT_FALSE(C.getAllocationSizeInBits(DL));
1774   EXPECT_EQ(D.getAllocationSizeInBits(DL), TypeSize::getFixed(512));
1775   EXPECT_EQ(E.getAllocationSizeInBits(DL), TypeSize::getScalable(512));
1776   EXPECT_EQ(F.getAllocationSizeInBits(DL), TypeSize::getFixed(32));
1777   EXPECT_EQ(G.getAllocationSizeInBits(DL), TypeSize::getFixed(768));
1778   EXPECT_EQ(H.getAllocationSizeInBits(DL), TypeSize::getFixed(160));
1779   EXPECT_FALSE(I.getAllocationSizeInBits(DL));
1780 }
1781
1782 TEST(InstructionsTest, InsertAtBegin) {
1783   LLVMContext Ctx;
1784   std::unique_ptr<Module> M = parseIR(Ctx, R"(
1785     define void @f(i32 %a, i32 %b) {
1786      entry:
1787        ret void
1788     }
1789 )");
1790   Function *F = &*M->begin();
1791   Argument *ArgA = F->getArg(0);
1792   Argument *ArgB = F->getArg(1);
1793   BasicBlock *BB = &*F->begin();
1794   Instruction *Ret = &*BB->begin();
1795   Instruction *I = BinaryOperator::CreateAdd(ArgA, ArgB);
1796   auto It = I->insertInto(BB, BB->begin());
1797   EXPECT_EQ(&*It, I);
1798   EXPECT_EQ(I->getNextNode(), Ret);
1799 }
1800
1801 TEST(InstructionsTest, InsertAtEnd) {
1802   LLVMContext Ctx;
1803   std::unique_ptr<Module> M = parseIR(Ctx, R"(
1804     define void @f(i32 %a, i32 %b) {
1805      entry:
1806        ret void
1807     }
1808 )");
1809   Function *F = &*M->begin();
1810   Argument *ArgA = F->getArg(0);
1811   Argument *ArgB = F->getArg(1);
1812   BasicBlock *BB = &*F->begin();
1813   Instruction *Ret = &*BB->begin();
1814   Instruction *I = BinaryOperator::CreateAdd(ArgA, ArgB);
1815   auto It = I->insertInto(BB, BB->end());
1816   EXPECT_EQ(&*It, I);
1817   EXPECT_EQ(Ret->getNextNode(), I);
1818 }
1819
1820 } // end anonymous namespace
1821 } // end namespace llvm