Home | History | Annotate | Download | only in IR 
      1 //===- llvm/unittest/IR/Metadata.cpp - Metadata unit tests ----------------===//
      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/IR/Metadata.h"
     11 #include "llvm/IR/Constants.h"
     12 #include "llvm/IR/Instructions.h"
     13 #include "llvm/IR/LLVMContext.h"
     14 #include "llvm/IR/Module.h"
     15 #include "llvm/IR/Type.h"
     16 #include "llvm/IR/ValueHandle.h"
     17 #include "llvm/Support/raw_ostream.h"
     18 #include "gtest/gtest.h"
     19 using namespace llvm;
     20 
     21 namespace {
     22 
     23 class MetadataTest : public testing::Test {
     24 protected:
     25   LLVMContext Context;
     26 };
     27 typedef MetadataTest MDStringTest;
     28 
     29 // Test that construction of MDString with different value produces different
     30 // MDString objects, even with the same string pointer and nulls in the string.
     31 TEST_F(MDStringTest, CreateDifferent) {
     32   char x[3] = { 'f', 0, 'A' };
     33   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
     34   x[2] = 'B';
     35   MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
     36   EXPECT_NE(s1, s2);
     37 }
     38 
     39 // Test that creation of MDStrings with the same string contents produces the
     40 // same MDString object, even with different pointers.
     41 TEST_F(MDStringTest, CreateSame) {
     42   char x[4] = { 'a', 'b', 'c', 'X' };
     43   char y[4] = { 'a', 'b', 'c', 'Y' };
     44 
     45   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
     46   MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
     47   EXPECT_EQ(s1, s2);
     48 }
     49 
     50 // Test that MDString prints out the string we fed it.
     51 TEST_F(MDStringTest, PrintingSimple) {
     52   char *str = new char[13];
     53   strncpy(str, "testing 1 2 3", 13);
     54   MDString *s = MDString::get(Context, StringRef(str, 13));
     55   strncpy(str, "aaaaaaaaaaaaa", 13);
     56   delete[] str;
     57 
     58   std::string Str;
     59   raw_string_ostream oss(Str);
     60   s->print(oss);
     61   EXPECT_STREQ("metadata !\"testing 1 2 3\"", oss.str().c_str());
     62 }
     63 
     64 // Test printing of MDString with non-printable characters.
     65 TEST_F(MDStringTest, PrintingComplex) {
     66   char str[5] = {0, '\n', '"', '\\', (char)-1};
     67   MDString *s = MDString::get(Context, StringRef(str+0, 5));
     68   std::string Str;
     69   raw_string_ostream oss(Str);
     70   s->print(oss);
     71   EXPECT_STREQ("metadata !\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
     72 }
     73 
     74 typedef MetadataTest MDNodeTest;
     75 
     76 // Test the two constructors, and containing other Constants.
     77 TEST_F(MDNodeTest, Simple) {
     78   char x[3] = { 'a', 'b', 'c' };
     79   char y[3] = { '1', '2', '3' };
     80 
     81   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
     82   MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
     83   ConstantInt *CI = ConstantInt::get(getGlobalContext(), APInt(8, 0));
     84 
     85   std::vector<Value *> V;
     86   V.push_back(s1);
     87   V.push_back(CI);
     88   V.push_back(s2);
     89 
     90   MDNode *n1 = MDNode::get(Context, V);
     91   Value *const c1 = n1;
     92   MDNode *n2 = MDNode::get(Context, c1);
     93   Value *const c2 = n2;
     94   MDNode *n3 = MDNode::get(Context, V);
     95   MDNode *n4 = MDNode::getIfExists(Context, V);
     96   MDNode *n5 = MDNode::getIfExists(Context, c1);
     97   MDNode *n6 = MDNode::getIfExists(Context, c2);
     98   EXPECT_NE(n1, n2);
     99 #ifdef ENABLE_MDNODE_UNIQUING
    100   EXPECT_EQ(n1, n3);
    101 #else
    102   (void) n3;
    103 #endif
    104   EXPECT_EQ(n4, n1);
    105   EXPECT_EQ(n5, n2);
    106   EXPECT_EQ(n6, (Value*)nullptr);
    107 
    108   EXPECT_EQ(3u, n1->getNumOperands());
    109   EXPECT_EQ(s1, n1->getOperand(0));
    110   EXPECT_EQ(CI, n1->getOperand(1));
    111   EXPECT_EQ(s2, n1->getOperand(2));
    112 
    113   EXPECT_EQ(1u, n2->getNumOperands());
    114   EXPECT_EQ(n1, n2->getOperand(0));
    115 }
    116 
    117 TEST_F(MDNodeTest, Delete) {
    118   Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);
    119   Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));
    120 
    121   Value *const V = I;
    122   MDNode *n = MDNode::get(Context, V);
    123   WeakVH wvh = n;
    124 
    125   EXPECT_EQ(n, wvh);
    126 
    127   delete I;
    128 }
    129 
    130 TEST(NamedMDNodeTest, Search) {
    131   LLVMContext Context;
    132   Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
    133   Constant *C2 = ConstantInt::get(Type::getInt32Ty(Context), 2);
    134 
    135   Value *const V = C;
    136   Value *const V2 = C2;
    137   MDNode *n = MDNode::get(Context, V);
    138   MDNode *n2 = MDNode::get(Context, V2);
    139 
    140   Module M("MyModule", Context);
    141   const char *Name = "llvm.NMD1";
    142   NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
    143   NMD->addOperand(n);
    144   NMD->addOperand(n2);
    145 
    146   std::string Str;
    147   raw_string_ostream oss(Str);
    148   NMD->print(oss);
    149   EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
    150                oss.str().c_str());
    151 }
    152 }
    153