unittests/CodeGen/MachineOperandTest.cpp

   1 //===- MachineOperandTest.cpp ---------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/CodeGen/MachineOperand.h"
  11 #include "llvm/ADT/ilist_node.h"
  12 #include "llvm/IR/Constants.h"
  13 #include "llvm/IR/InstrTypes.h"
  14 #include "llvm/IR/LLVMContext.h"
  15 #include "llvm/IR/Module.h"
  16 #include "llvm/IR/ModuleSlotTracker.h"
  17 #include "llvm/MC/MCContext.h"
  18 #include "llvm/MC/MCAsmInfo.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include "gtest/gtest.h"
  21
  22 using namespace llvm;
  23
  24 namespace {
  25
  26 TEST(MachineOperandTest, ChangeToTargetIndexTest) {
  27   // Creating a MachineOperand to change it to TargetIndex
  28   MachineOperand MO = MachineOperand::CreateImm(50);
  29
  30   // Checking some precondition on the newly created
  31   // MachineOperand.
  32   ASSERT_TRUE(MO.isImm());
  33   ASSERT_TRUE(MO.getImm() == 50);
  34   ASSERT_FALSE(MO.isTargetIndex());
  35
  36   // Changing to TargetIndex with some arbitrary values
  37   // for index, offset and flags.
  38   MO.ChangeToTargetIndex(74, 57, 12);
  39
  40   // Checking that the mutation to TargetIndex happened
  41   // correctly.
  42   ASSERT_TRUE(MO.isTargetIndex());
  43   ASSERT_TRUE(MO.getIndex() == 74);
  44   ASSERT_TRUE(MO.getOffset() == 57);
  45   ASSERT_TRUE(MO.getTargetFlags() == 12);
  46 }
  47
  48 TEST(MachineOperandTest, PrintRegisterMask) {
  49   uint32_t Dummy;
  50   MachineOperand MO = MachineOperand::CreateRegMask(&Dummy);
  51
  52   // Checking some preconditions on the newly created
  53   // MachineOperand.
  54   ASSERT_TRUE(MO.isRegMask());
  55   ASSERT_TRUE(MO.getRegMask() == &Dummy);
  56
  57   // Print a MachineOperand containing a RegMask. Here we check that without a
  58   // TRI and IntrinsicInfo we still print a less detailed regmask.
  59   std::string str;
  60   raw_string_ostream OS(str);
  61   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
  62   ASSERT_TRUE(OS.str() == "<regmask ...>");
  63 }
  64
  65 TEST(MachineOperandTest, PrintSubReg) {
  66   // Create a MachineOperand with RegNum=1 and SubReg=5.
  67   MachineOperand MO = MachineOperand::CreateReg(
  68       /*Reg=*/1, /*isDef=*/false, /*isImp=*/false, /*isKill=*/false,
  69       /*isDead=*/false, /*isUndef=*/false, /*isEarlyClobber=*/false,
  70       /*SubReg=*/5, /*isDebug=*/false, /*isInternalRead=*/false);
  71
  72   // Checking some preconditions on the newly created
  73   // MachineOperand.
  74   ASSERT_TRUE(MO.isReg());
  75   ASSERT_TRUE(MO.getReg() == 1);
  76   ASSERT_TRUE(MO.getSubReg() == 5);
  77
  78   // Print a MachineOperand containing a SubReg. Here we check that without a
  79   // TRI and IntrinsicInfo we can still print the subreg index.
  80   std::string str;
  81   raw_string_ostream OS(str);
  82   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
  83   ASSERT_TRUE(OS.str() == "$physreg1.subreg5");
  84 }
  85
  86 TEST(MachineOperandTest, PrintCImm) {
  87   LLVMContext Context;
  88   APInt Int(128, UINT64_MAX);
  89   ++Int;
  90   ConstantInt *CImm = ConstantInt::get(Context, Int);
  91   // Create a MachineOperand with an Imm=(UINT64_MAX + 1)
  92   MachineOperand MO = MachineOperand::CreateCImm(CImm);
  93
  94   // Checking some preconditions on the newly created
  95   // MachineOperand.
  96   ASSERT_TRUE(MO.isCImm());
  97   ASSERT_TRUE(MO.getCImm() == CImm);
  98   ASSERT_TRUE(MO.getCImm()->getValue() == Int);
  99
 100   // Print a MachineOperand containing a SubReg. Here we check that without a
 101   // TRI and IntrinsicInfo we can still print the subreg index.
 102   std::string str;
 103   raw_string_ostream OS(str);
 104   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 105   ASSERT_TRUE(OS.str() == "i128 18446744073709551616");
 106 }
 107
 108 TEST(MachineOperandTest, PrintSubRegIndex) {
 109   // Create a MachineOperand with an immediate and print it as a subreg index.
 110   MachineOperand MO = MachineOperand::CreateImm(3);
 111
 112   // Checking some preconditions on the newly created
 113   // MachineOperand.
 114   ASSERT_TRUE(MO.isImm());
 115   ASSERT_TRUE(MO.getImm() == 3);
 116
 117   // Print a MachineOperand containing a SubRegIdx. Here we check that without a
 118   // TRI and IntrinsicInfo we can print the operand as a subreg index.
 119   std::string str;
 120   raw_string_ostream OS(str);
 121   MachineOperand::printSubRegIdx(OS, MO.getImm(), nullptr);
 122   ASSERT_TRUE(OS.str() == "%subreg.3");
 123 }
 124
 125 TEST(MachineOperandTest, PrintCPI) {
 126   // Create a MachineOperand with a constant pool index and print it.
 127   MachineOperand MO = MachineOperand::CreateCPI(0, 8);
 128
 129   // Checking some preconditions on the newly created
 130   // MachineOperand.
 131   ASSERT_TRUE(MO.isCPI());
 132   ASSERT_TRUE(MO.getIndex() == 0);
 133   ASSERT_TRUE(MO.getOffset() == 8);
 134
 135   // Print a MachineOperand containing a constant pool index and a positive
 136   // offset.
 137   std::string str;
 138   {
 139     raw_string_ostream OS(str);
 140     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 141     ASSERT_TRUE(OS.str() == "%const.0 + 8");
 142   }
 143
 144   str.clear();
 145
 146   MO.setOffset(-12);
 147
 148   // Print a MachineOperand containing a constant pool index and a negative
 149   // offset.
 150   {
 151     raw_string_ostream OS(str);
 152     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 153     ASSERT_TRUE(OS.str() == "%const.0 - 12");
 154   }
 155 }
 156
 157 TEST(MachineOperandTest, PrintTargetIndexName) {
 158   // Create a MachineOperand with a target index and print it.
 159   MachineOperand MO = MachineOperand::CreateTargetIndex(0, 8);
 160
 161   // Checking some preconditions on the newly created
 162   // MachineOperand.
 163   ASSERT_TRUE(MO.isTargetIndex());
 164   ASSERT_TRUE(MO.getIndex() == 0);
 165   ASSERT_TRUE(MO.getOffset() == 8);
 166
 167   // Print a MachineOperand containing a target index and a positive offset.
 168   std::string str;
 169   {
 170     raw_string_ostream OS(str);
 171     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 172     ASSERT_TRUE(OS.str() == "target-index(<unknown>) + 8");
 173   }
 174
 175   str.clear();
 176
 177   MO.setOffset(-12);
 178
 179   // Print a MachineOperand containing a target index and a negative offset.
 180   {
 181     raw_string_ostream OS(str);
 182     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 183     ASSERT_TRUE(OS.str() == "target-index(<unknown>) - 12");
 184   }
 185 }
 186
 187 TEST(MachineOperandTest, PrintJumpTableIndex) {
 188   // Create a MachineOperand with a jump-table index and print it.
 189   MachineOperand MO = MachineOperand::CreateJTI(3);
 190
 191   // Checking some preconditions on the newly created
 192   // MachineOperand.
 193   ASSERT_TRUE(MO.isJTI());
 194   ASSERT_TRUE(MO.getIndex() == 3);
 195
 196   // Print a MachineOperand containing a jump-table index.
 197   std::string str;
 198   raw_string_ostream OS(str);
 199   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 200   ASSERT_TRUE(OS.str() == "%jump-table.3");
 201 }
 202
 203 TEST(MachineOperandTest, PrintExternalSymbol) {
 204   // Create a MachineOperand with an external symbol and print it.
 205   MachineOperand MO = MachineOperand::CreateES("foo");
 206
 207   // Checking some preconditions on the newly created
 208   // MachineOperand.
 209   ASSERT_TRUE(MO.isSymbol());
 210   ASSERT_TRUE(MO.getSymbolName() == StringRef("foo"));
 211
 212   // Print a MachineOperand containing an external symbol and no offset.
 213   std::string str;
 214   {
 215     raw_string_ostream OS(str);
 216     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 217     ASSERT_TRUE(OS.str() == "&foo");
 218   }
 219
 220   str.clear();
 221   MO.setOffset(12);
 222
 223   // Print a MachineOperand containing an external symbol and a positive offset.
 224   {
 225     raw_string_ostream OS(str);
 226     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 227     ASSERT_TRUE(OS.str() == "&foo + 12");
 228   }
 229
 230   str.clear();
 231   MO.setOffset(-12);
 232
 233   // Print a MachineOperand containing an external symbol and a negative offset.
 234   {
 235     raw_string_ostream OS(str);
 236     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 237     ASSERT_TRUE(OS.str() == "&foo - 12");
 238   }
 239 }
 240
 241 TEST(MachineOperandTest, PrintGlobalAddress) {
 242   LLVMContext Ctx;
 243   Module M("MachineOperandGVTest", Ctx);
 244   M.getOrInsertGlobal("foo", Type::getInt32Ty(Ctx));
 245
 246   GlobalValue *GV = M.getNamedValue("foo");
 247
 248   // Create a MachineOperand with a global address and a positive offset and
 249   // print it.
 250   MachineOperand MO = MachineOperand::CreateGA(GV, 12);
 251
 252   // Checking some preconditions on the newly created
 253   // MachineOperand.
 254   ASSERT_TRUE(MO.isGlobal());
 255   ASSERT_TRUE(MO.getGlobal() == GV);
 256   ASSERT_TRUE(MO.getOffset() == 12);
 257
 258   std::string str;
 259   // Print a MachineOperand containing a global address and a positive offset.
 260   {
 261     raw_string_ostream OS(str);
 262     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 263     ASSERT_TRUE(OS.str() == "@foo + 12");
 264   }
 265
 266   str.clear();
 267   MO.setOffset(-12);
 268
 269   // Print a MachineOperand containing a global address and a negative offset.
 270   {
 271     raw_string_ostream OS(str);
 272     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 273     ASSERT_TRUE(OS.str() == "@foo - 12");
 274   }
 275 }
 276
 277 TEST(MachineOperandTest, PrintRegisterLiveOut) {
 278   // Create a MachineOperand with a register live out list and print it.
 279   uint32_t Mask = 0;
 280   MachineOperand MO = MachineOperand::CreateRegLiveOut(&Mask);
 281
 282   // Checking some preconditions on the newly created
 283   // MachineOperand.
 284   ASSERT_TRUE(MO.isRegLiveOut());
 285   ASSERT_TRUE(MO.getRegLiveOut() == &Mask);
 286
 287   std::string str;
 288   // Print a MachineOperand containing a register live out list without a TRI.
 289   raw_string_ostream OS(str);
 290   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 291   ASSERT_TRUE(OS.str() == "liveout(<unknown>)");
 292 }
 293
 294 TEST(MachineOperandTest, PrintMetadata) {
 295   LLVMContext Ctx;
 296   Module M("MachineOperandMDNodeTest", Ctx);
 297   NamedMDNode *MD = M.getOrInsertNamedMetadata("namedmd");
 298   ModuleSlotTracker MST(&M);
 299   Metadata *MDS = MDString::get(Ctx, "foo");
 300   MDNode *Node = MDNode::get(Ctx, MDS);
 301   MD->addOperand(Node);
 302
 303   // Create a MachineOperand with a metadata and print it.
 304   MachineOperand MO = MachineOperand::CreateMetadata(Node);
 305
 306   // Checking some preconditions on the newly created
 307   // MachineOperand.
 308   ASSERT_TRUE(MO.isMetadata());
 309   ASSERT_TRUE(MO.getMetadata() == Node);
 310
 311   std::string str;
 312   // Print a MachineOperand containing a metadata node.
 313   raw_string_ostream OS(str);
 314   MO.print(OS, MST, LLT{}, /*PrintDef=*/false, /*IsStandalone=*/false,
 315            /*ShouldPrintRegisterTies=*/false, 0, /*TRI=*/nullptr,
 316            /*IntrinsicInfo=*/nullptr);
 317   ASSERT_TRUE(OS.str() == "!0");
 318 }
 319
 320 TEST(MachineOperandTest, PrintMCSymbol) {
 321   MCAsmInfo MAI;
 322   MCContext Ctx(&MAI, /*MRI=*/nullptr, /*MOFI=*/nullptr);
 323   MCSymbol *Sym = Ctx.getOrCreateSymbol("foo");
 324
 325   // Create a MachineOperand with a metadata and print it.
 326   MachineOperand MO = MachineOperand::CreateMCSymbol(Sym);
 327
 328   // Checking some preconditions on the newly created
 329   // MachineOperand.
 330   ASSERT_TRUE(MO.isMCSymbol());
 331   ASSERT_TRUE(MO.getMCSymbol() == Sym);
 332
 333   std::string str;
 334   // Print a MachineOperand containing a metadata node.
 335   raw_string_ostream OS(str);
 336   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 337   ASSERT_TRUE(OS.str() == "<mcsymbol foo>");
 338 }
 339
 340 TEST(MachineOperandTest, PrintCFI) {
 341   // Create a MachineOperand with a CFI index but no function and print it.
 342   MachineOperand MO = MachineOperand::CreateCFIIndex(8);
 343
 344   // Checking some preconditions on the newly created
 345   // MachineOperand.
 346   ASSERT_TRUE(MO.isCFIIndex());
 347   ASSERT_TRUE(MO.getCFIIndex() == 8);
 348
 349   std::string str;
 350   // Print a MachineOperand containing a CFI Index node but no machine function
 351   // attached to it.
 352   raw_string_ostream OS(str);
 353   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 354   ASSERT_TRUE(OS.str() == "<cfi directive>");
 355 }
 356
 357 TEST(MachineOperandTest, PrintIntrinsicID) {
 358   // Create a MachineOperand with a generic intrinsic ID.
 359   MachineOperand MO = MachineOperand::CreateIntrinsicID(Intrinsic::bswap);
 360
 361   // Checking some preconditions on the newly created
 362   // MachineOperand.
 363   ASSERT_TRUE(MO.isIntrinsicID());
 364   ASSERT_TRUE(MO.getIntrinsicID() == Intrinsic::bswap);
 365
 366   std::string str;
 367   {
 368     // Print a MachineOperand containing a generic intrinsic ID.
 369     raw_string_ostream OS(str);
 370     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 371     ASSERT_TRUE(OS.str() == "intrinsic(@llvm.bswap)");
 372   }
 373
 374   str.clear();
 375   // Set a target-specific intrinsic.
 376   MO = MachineOperand::CreateIntrinsicID((Intrinsic::ID)-1);
 377   {
 378     // Print a MachineOperand containing a target-specific intrinsic ID but not
 379     // IntrinsicInfo.
 380     raw_string_ostream OS(str);
 381     MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 382     ASSERT_TRUE(OS.str() == "intrinsic(4294967295)");
 383   }
 384 }
 385
 386 TEST(MachineOperandTest, PrintPredicate) {
 387   // Create a MachineOperand with a generic intrinsic ID.
 388   MachineOperand MO = MachineOperand::CreatePredicate(CmpInst::ICMP_EQ);
 389
 390   // Checking some preconditions on the newly created
 391   // MachineOperand.
 392   ASSERT_TRUE(MO.isPredicate());
 393   ASSERT_TRUE(MO.getPredicate() == CmpInst::ICMP_EQ);
 394
 395   std::string str;
 396   // Print a MachineOperand containing a int predicate ICMP_EQ.
 397   raw_string_ostream OS(str);
 398   MO.print(OS, /*TRI=*/nullptr, /*IntrinsicInfo=*/nullptr);
 399   ASSERT_TRUE(OS.str() == "intpred(eq)");
 400 }
 401
 402 } // end namespace