2015-02-03 02:20:15 +08:00
|
|
|
//===- unittests/IR/MetadataTest.cpp - Metadata unit tests ----------------===//
|
2009-04-04 15:22:01 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-01-13 08:46:34 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
2015-03-04 00:45:34 +08:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2015-02-03 02:53:21 +08:00
|
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
2015-02-19 04:32:57 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2015-01-14 19:23:27 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2015-06-27 08:38:26 +08:00
|
|
|
#include "llvm/IR/ModuleSlotTracker.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Type.h"
|
2015-04-25 05:53:27 +08:00
|
|
|
#include "llvm/IR/Verifier.h"
|
2012-12-04 18:23:08 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include "gtest/gtest.h"
|
2009-04-04 15:22:01 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2015-01-20 03:02:06 +08:00
|
|
|
TEST(ContextAndReplaceableUsesTest, FromContext) {
|
|
|
|
LLVMContext Context;
|
|
|
|
ContextAndReplaceableUses CRU(Context);
|
|
|
|
EXPECT_EQ(&Context, &CRU.getContext());
|
|
|
|
EXPECT_FALSE(CRU.hasReplaceableUses());
|
|
|
|
EXPECT_FALSE(CRU.getReplaceableUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(ContextAndReplaceableUsesTest, FromReplaceableUses) {
|
|
|
|
LLVMContext Context;
|
|
|
|
ContextAndReplaceableUses CRU(make_unique<ReplaceableMetadataImpl>(Context));
|
|
|
|
EXPECT_EQ(&Context, &CRU.getContext());
|
|
|
|
EXPECT_TRUE(CRU.hasReplaceableUses());
|
|
|
|
EXPECT_TRUE(CRU.getReplaceableUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(ContextAndReplaceableUsesTest, makeReplaceable) {
|
|
|
|
LLVMContext Context;
|
|
|
|
ContextAndReplaceableUses CRU(Context);
|
|
|
|
CRU.makeReplaceable(make_unique<ReplaceableMetadataImpl>(Context));
|
|
|
|
EXPECT_EQ(&Context, &CRU.getContext());
|
|
|
|
EXPECT_TRUE(CRU.hasReplaceableUses());
|
|
|
|
EXPECT_TRUE(CRU.getReplaceableUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(ContextAndReplaceableUsesTest, takeReplaceableUses) {
|
|
|
|
LLVMContext Context;
|
|
|
|
auto ReplaceableUses = make_unique<ReplaceableMetadataImpl>(Context);
|
|
|
|
auto *Ptr = ReplaceableUses.get();
|
|
|
|
ContextAndReplaceableUses CRU(std::move(ReplaceableUses));
|
|
|
|
ReplaceableUses = CRU.takeReplaceableUses();
|
|
|
|
EXPECT_EQ(&Context, &CRU.getContext());
|
|
|
|
EXPECT_FALSE(CRU.hasReplaceableUses());
|
|
|
|
EXPECT_FALSE(CRU.getReplaceableUses());
|
|
|
|
EXPECT_EQ(Ptr, ReplaceableUses.get());
|
|
|
|
}
|
|
|
|
|
2010-03-05 07:24:19 +08:00
|
|
|
class MetadataTest : public testing::Test {
|
2015-03-28 01:29:58 +08:00
|
|
|
public:
|
2015-03-31 00:19:15 +08:00
|
|
|
MetadataTest() : M("test", Context), Counter(0) {}
|
2015-03-28 01:29:58 +08:00
|
|
|
|
2010-03-05 07:24:19 +08:00
|
|
|
protected:
|
|
|
|
LLVMContext Context;
|
2015-03-31 00:19:15 +08:00
|
|
|
Module M;
|
2015-03-28 01:29:58 +08:00
|
|
|
int Counter;
|
|
|
|
|
IR: Make MDNode::dump() useful by adding addresses
It's horrible to inspect `MDNode`s in a debugger. All of their operands
that are `MDNode`s get dumped as `<badref>`, since we can't assign
metadata slots in the context of a `Metadata::dump()`. (Why not? Why
not assign numbers lazily? Because then each time you called `dump()`,
a given `MDNode` could have a different lazily assigned number.)
Fortunately, the C memory model gives us perfectly good identifiers for
`MDNode`. Add pointer addresses to the dumps, transforming this:
(lldb) e N->dump()
!{i32 662302, i32 26, <badref>, null}
(lldb) e ((MDNode*)N->getOperand(2))->dump()
!{i32 4, !"foo"}
into:
(lldb) e N->dump()
!{i32 662302, i32 26, <0x100706ee0>, null}
(lldb) e ((MDNode*)0x100706ee0)->dump()
!{i32 4, !"foo"}
and this:
(lldb) e N->dump()
0x101200248 = !{<badref>, <badref>, <badref>, <badref>, <badref>}
(lldb) e N->getOperand(0)
(const llvm::MDOperand) $0 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(1)
(const llvm::MDOperand) $1 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(2)
(const llvm::MDOperand) $2 = {
MD = 0x0000000101200058
}
(lldb) e N->getOperand(3)
(const llvm::MDOperand) $3 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(4)
(const llvm::MDOperand) $4 = {
MD = 0x0000000101200058
}
(lldb) e ((MDNode*)0x00000001012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x0000000101200058)->dump()
!{null}
into:
(lldb) e N->dump()
!{<0x1012004e0>, <0x1012004e0>, <0x101200058>, <0x1012004e0>, <0x101200058>}
(lldb) e ((MDNode*)0x1012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x101200058)->dump()
!{null}
llvm-svn: 224325
2014-12-16 15:09:37 +08:00
|
|
|
MDNode *getNode() { return MDNode::get(Context, None); }
|
|
|
|
MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
|
|
|
|
MDNode *getNode(Metadata *MD1, Metadata *MD2) {
|
|
|
|
Metadata *MDs[] = {MD1, MD2};
|
|
|
|
return MDNode::get(Context, MDs);
|
|
|
|
}
|
2015-03-27 06:05:04 +08:00
|
|
|
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *getTuple() { return MDTuple::getDistinct(Context, None); }
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubroutineType *getSubroutineType() {
|
2016-06-09 04:34:29 +08:00
|
|
|
return DISubroutineType::getDistinct(Context, 0, 0, getNode(nullptr));
|
2015-03-31 00:19:15 +08:00
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubprogram *getSubprogram() {
|
|
|
|
return DISubprogram::getDistinct(Context, nullptr, "", "", nullptr, 0,
|
2016-04-15 23:57:41 +08:00
|
|
|
nullptr, false, false, 0, nullptr,
|
|
|
|
0, 0, 0, false, nullptr);
|
2015-03-27 06:05:04 +08:00
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *getFile() {
|
|
|
|
return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
|
2015-03-28 01:29:58 +08:00
|
|
|
}
|
2016-04-15 23:57:41 +08:00
|
|
|
DICompileUnit *getUnit() {
|
|
|
|
return DICompileUnit::getDistinct(Context, 1, getFile(), "clang", false,
|
|
|
|
"-g", 2, "", DICompileUnit::FullDebug,
|
|
|
|
getTuple(), getTuple(), getTuple(),
|
|
|
|
getTuple(), getTuple(), 0);
|
|
|
|
}
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *getBasicType(StringRef Name) {
|
|
|
|
return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name);
|
2015-03-28 01:29:58 +08:00
|
|
|
}
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *getDerivedType() {
|
2015-04-30 00:38:44 +08:00
|
|
|
return DIDerivedType::getDistinct(Context, dwarf::DW_TAG_pointer_type, "",
|
2015-03-28 01:29:58 +08:00
|
|
|
nullptr, 0, nullptr,
|
2016-04-24 05:08:00 +08:00
|
|
|
getBasicType("basictype"), 1, 2, 0, 0);
|
2015-03-28 01:29:58 +08:00
|
|
|
}
|
2015-04-12 04:27:40 +08:00
|
|
|
Constant *getConstant() {
|
|
|
|
return ConstantInt::get(Type::getInt32Ty(Context), Counter++);
|
|
|
|
}
|
2015-03-28 01:29:58 +08:00
|
|
|
ConstantAsMetadata *getConstantAsMetadata() {
|
2015-04-12 04:27:40 +08:00
|
|
|
return ConstantAsMetadata::get(getConstant());
|
2015-03-28 01:29:58 +08:00
|
|
|
}
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *getCompositeType() {
|
2015-04-30 00:38:44 +08:00
|
|
|
return DICompositeType::getDistinct(
|
2016-04-24 05:08:00 +08:00
|
|
|
Context, dwarf::DW_TAG_structure_type, "", nullptr, 0, nullptr, nullptr,
|
|
|
|
32, 32, 0, 0, nullptr, 0, nullptr, nullptr, "");
|
2015-03-28 07:05:04 +08:00
|
|
|
}
|
2015-04-12 04:27:40 +08:00
|
|
|
Function *getFunction(StringRef Name) {
|
|
|
|
return cast<Function>(M.getOrInsertFunction(
|
2015-03-31 00:19:15 +08:00
|
|
|
Name, FunctionType::get(Type::getVoidTy(Context), None, false)));
|
|
|
|
}
|
2010-03-05 07:24:19 +08:00
|
|
|
};
|
|
|
|
typedef MetadataTest MDStringTest;
|
2009-08-01 05:38:10 +08:00
|
|
|
|
2009-04-04 15:22:01 +08:00
|
|
|
// Test that construction of MDString with different value produces different
|
|
|
|
// MDString objects, even with the same string pointer and nulls in the string.
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDStringTest, CreateDifferent) {
|
2009-04-04 15:22:01 +08:00
|
|
|
char x[3] = { 'f', 0, 'A' };
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
|
2009-04-04 15:22:01 +08:00
|
|
|
x[2] = 'B';
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
|
2009-04-04 15:22:01 +08:00
|
|
|
EXPECT_NE(s1, s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test that creation of MDStrings with the same string contents produces the
|
|
|
|
// same MDString object, even with different pointers.
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDStringTest, CreateSame) {
|
2009-04-04 15:22:01 +08:00
|
|
|
char x[4] = { 'a', 'b', 'c', 'X' };
|
|
|
|
char y[4] = { 'a', 'b', 'c', 'Y' };
|
|
|
|
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
|
|
|
|
MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
|
2009-04-04 15:22:01 +08:00
|
|
|
EXPECT_EQ(s1, s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test that MDString prints out the string we fed it.
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDStringTest, PrintingSimple) {
|
2009-04-04 15:22:01 +08:00
|
|
|
char *str = new char[13];
|
|
|
|
strncpy(str, "testing 1 2 3", 13);
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s = MDString::get(Context, StringRef(str, 13));
|
2009-04-04 15:22:01 +08:00
|
|
|
strncpy(str, "aaaaaaaaaaaaa", 13);
|
|
|
|
delete[] str;
|
|
|
|
|
2009-08-23 12:47:35 +08:00
|
|
|
std::string Str;
|
|
|
|
raw_string_ostream oss(Str);
|
2009-04-04 15:22:01 +08:00
|
|
|
s->print(oss);
|
2014-12-16 15:40:31 +08:00
|
|
|
EXPECT_STREQ("!\"testing 1 2 3\"", oss.str().c_str());
|
2009-04-04 15:22:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Test printing of MDString with non-printable characters.
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDStringTest, PrintingComplex) {
|
2011-08-31 04:53:29 +08:00
|
|
|
char str[5] = {0, '\n', '"', '\\', (char)-1};
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s = MDString::get(Context, StringRef(str+0, 5));
|
2009-08-23 12:47:35 +08:00
|
|
|
std::string Str;
|
|
|
|
raw_string_ostream oss(Str);
|
2009-04-04 15:22:01 +08:00
|
|
|
s->print(oss);
|
2014-12-16 15:40:31 +08:00
|
|
|
EXPECT_STREQ("!\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
|
2009-04-04 15:22:01 +08:00
|
|
|
}
|
|
|
|
|
2010-03-05 07:24:19 +08:00
|
|
|
typedef MetadataTest MDNodeTest;
|
|
|
|
|
2009-04-04 15:22:01 +08:00
|
|
|
// Test the two constructors, and containing other Constants.
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDNodeTest, Simple) {
|
2009-04-04 15:22:01 +08:00
|
|
|
char x[3] = { 'a', 'b', 'c' };
|
|
|
|
char y[3] = { '1', '2', '3' };
|
|
|
|
|
2009-08-01 05:38:10 +08:00
|
|
|
MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
|
|
|
|
MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
|
2016-04-15 05:59:01 +08:00
|
|
|
ConstantAsMetadata *CI =
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
|
2009-04-04 15:22:01 +08:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
std::vector<Metadata *> V;
|
2009-04-04 15:22:01 +08:00
|
|
|
V.push_back(s1);
|
|
|
|
V.push_back(CI);
|
|
|
|
V.push_back(s2);
|
|
|
|
|
2011-04-22 03:59:31 +08:00
|
|
|
MDNode *n1 = MDNode::get(Context, V);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
Metadata *const c1 = n1;
|
2011-04-22 03:59:31 +08:00
|
|
|
MDNode *n2 = MDNode::get(Context, c1);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
Metadata *const c2 = n2;
|
2011-04-22 03:59:31 +08:00
|
|
|
MDNode *n3 = MDNode::get(Context, V);
|
2012-03-31 16:20:11 +08:00
|
|
|
MDNode *n4 = MDNode::getIfExists(Context, V);
|
|
|
|
MDNode *n5 = MDNode::getIfExists(Context, c1);
|
|
|
|
MDNode *n6 = MDNode::getIfExists(Context, c2);
|
2009-04-04 15:22:01 +08:00
|
|
|
EXPECT_NE(n1, n2);
|
2009-09-03 09:39:20 +08:00
|
|
|
EXPECT_EQ(n1, n3);
|
2012-03-31 16:20:11 +08:00
|
|
|
EXPECT_EQ(n4, n1);
|
|
|
|
EXPECT_EQ(n5, n2);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
EXPECT_EQ(n6, (Metadata *)nullptr);
|
2009-04-04 15:22:01 +08:00
|
|
|
|
2009-12-31 09:22:29 +08:00
|
|
|
EXPECT_EQ(3u, n1->getNumOperands());
|
|
|
|
EXPECT_EQ(s1, n1->getOperand(0));
|
|
|
|
EXPECT_EQ(CI, n1->getOperand(1));
|
|
|
|
EXPECT_EQ(s2, n1->getOperand(2));
|
2009-04-04 15:22:01 +08:00
|
|
|
|
2009-12-31 09:22:29 +08:00
|
|
|
EXPECT_EQ(1u, n2->getNumOperands());
|
|
|
|
EXPECT_EQ(n1, n2->getOperand(0));
|
2009-04-04 15:22:01 +08:00
|
|
|
}
|
2009-05-11 04:57:05 +08:00
|
|
|
|
2010-03-05 07:24:19 +08:00
|
|
|
TEST_F(MDNodeTest, Delete) {
|
2016-04-15 05:59:01 +08:00
|
|
|
Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
|
|
|
|
Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context));
|
2009-05-11 04:57:05 +08:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
Metadata *const V = LocalAsMetadata::get(I);
|
2011-04-22 03:59:31 +08:00
|
|
|
MDNode *n = MDNode::get(Context, V);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
TrackingMDRef wvh(n);
|
2009-05-11 04:57:05 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(n, wvh);
|
|
|
|
|
|
|
|
delete I;
|
|
|
|
}
|
2009-07-30 08:03:41 +08:00
|
|
|
|
2014-12-08 03:52:06 +08:00
|
|
|
TEST_F(MDNodeTest, SelfReference) {
|
2014-12-16 15:45:05 +08:00
|
|
|
// !0 = !{!0}
|
|
|
|
// !1 = !{!0}
|
2014-12-08 03:52:06 +08:00
|
|
|
{
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp = MDNode::getTemporary(Context, None);
|
|
|
|
Metadata *Args[] = {Temp.get()};
|
2014-12-08 03:52:06 +08:00
|
|
|
MDNode *Self = MDNode::get(Context, Args);
|
|
|
|
Self->replaceOperandWith(0, Self);
|
|
|
|
ASSERT_EQ(Self, Self->getOperand(0));
|
|
|
|
|
|
|
|
// Self-references should be distinct, so MDNode::get() should grab a
|
|
|
|
// uniqued node that references Self, not Self.
|
|
|
|
Args[0] = Self;
|
|
|
|
MDNode *Ref1 = MDNode::get(Context, Args);
|
|
|
|
MDNode *Ref2 = MDNode::get(Context, Args);
|
|
|
|
EXPECT_NE(Self, Ref1);
|
|
|
|
EXPECT_EQ(Ref1, Ref2);
|
|
|
|
}
|
|
|
|
|
2014-12-16 15:45:05 +08:00
|
|
|
// !0 = !{!0, !{}}
|
|
|
|
// !1 = !{!0, !{}}
|
2014-12-08 03:52:06 +08:00
|
|
|
{
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp = MDNode::getTemporary(Context, None);
|
|
|
|
Metadata *Args[] = {Temp.get(), MDNode::get(Context, None)};
|
2014-12-08 03:52:06 +08:00
|
|
|
MDNode *Self = MDNode::get(Context, Args);
|
|
|
|
Self->replaceOperandWith(0, Self);
|
|
|
|
ASSERT_EQ(Self, Self->getOperand(0));
|
|
|
|
|
|
|
|
// Self-references should be distinct, so MDNode::get() should grab a
|
|
|
|
// uniqued node that references Self, not Self itself.
|
|
|
|
Args[0] = Self;
|
|
|
|
MDNode *Ref1 = MDNode::get(Context, Args);
|
|
|
|
MDNode *Ref2 = MDNode::get(Context, Args);
|
|
|
|
EXPECT_NE(Self, Ref1);
|
|
|
|
EXPECT_EQ(Ref1, Ref2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IR: Make MDNode::dump() useful by adding addresses
It's horrible to inspect `MDNode`s in a debugger. All of their operands
that are `MDNode`s get dumped as `<badref>`, since we can't assign
metadata slots in the context of a `Metadata::dump()`. (Why not? Why
not assign numbers lazily? Because then each time you called `dump()`,
a given `MDNode` could have a different lazily assigned number.)
Fortunately, the C memory model gives us perfectly good identifiers for
`MDNode`. Add pointer addresses to the dumps, transforming this:
(lldb) e N->dump()
!{i32 662302, i32 26, <badref>, null}
(lldb) e ((MDNode*)N->getOperand(2))->dump()
!{i32 4, !"foo"}
into:
(lldb) e N->dump()
!{i32 662302, i32 26, <0x100706ee0>, null}
(lldb) e ((MDNode*)0x100706ee0)->dump()
!{i32 4, !"foo"}
and this:
(lldb) e N->dump()
0x101200248 = !{<badref>, <badref>, <badref>, <badref>, <badref>}
(lldb) e N->getOperand(0)
(const llvm::MDOperand) $0 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(1)
(const llvm::MDOperand) $1 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(2)
(const llvm::MDOperand) $2 = {
MD = 0x0000000101200058
}
(lldb) e N->getOperand(3)
(const llvm::MDOperand) $3 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(4)
(const llvm::MDOperand) $4 = {
MD = 0x0000000101200058
}
(lldb) e ((MDNode*)0x00000001012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x0000000101200058)->dump()
!{null}
into:
(lldb) e N->dump()
!{<0x1012004e0>, <0x1012004e0>, <0x101200058>, <0x1012004e0>, <0x101200058>}
(lldb) e ((MDNode*)0x1012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x101200058)->dump()
!{null}
llvm-svn: 224325
2014-12-16 15:09:37 +08:00
|
|
|
TEST_F(MDNodeTest, Print) {
|
|
|
|
Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
|
|
|
|
MDString *S = MDString::get(Context, "foo");
|
|
|
|
MDNode *N0 = getNode();
|
|
|
|
MDNode *N1 = getNode(N0);
|
|
|
|
MDNode *N2 = getNode(N0, N1);
|
|
|
|
|
|
|
|
Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
|
|
|
|
MDNode *N = MDNode::get(Context, Args);
|
|
|
|
|
|
|
|
std::string Expected;
|
|
|
|
{
|
|
|
|
raw_string_ostream OS(Expected);
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
llvm-svn: 232275
2015-03-15 04:19:36 +08:00
|
|
|
OS << "<" << (void *)N << "> = !{";
|
IR: Make MDNode::dump() useful by adding addresses
It's horrible to inspect `MDNode`s in a debugger. All of their operands
that are `MDNode`s get dumped as `<badref>`, since we can't assign
metadata slots in the context of a `Metadata::dump()`. (Why not? Why
not assign numbers lazily? Because then each time you called `dump()`,
a given `MDNode` could have a different lazily assigned number.)
Fortunately, the C memory model gives us perfectly good identifiers for
`MDNode`. Add pointer addresses to the dumps, transforming this:
(lldb) e N->dump()
!{i32 662302, i32 26, <badref>, null}
(lldb) e ((MDNode*)N->getOperand(2))->dump()
!{i32 4, !"foo"}
into:
(lldb) e N->dump()
!{i32 662302, i32 26, <0x100706ee0>, null}
(lldb) e ((MDNode*)0x100706ee0)->dump()
!{i32 4, !"foo"}
and this:
(lldb) e N->dump()
0x101200248 = !{<badref>, <badref>, <badref>, <badref>, <badref>}
(lldb) e N->getOperand(0)
(const llvm::MDOperand) $0 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(1)
(const llvm::MDOperand) $1 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(2)
(const llvm::MDOperand) $2 = {
MD = 0x0000000101200058
}
(lldb) e N->getOperand(3)
(const llvm::MDOperand) $3 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(4)
(const llvm::MDOperand) $4 = {
MD = 0x0000000101200058
}
(lldb) e ((MDNode*)0x00000001012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x0000000101200058)->dump()
!{null}
into:
(lldb) e N->dump()
!{<0x1012004e0>, <0x1012004e0>, <0x101200058>, <0x1012004e0>, <0x101200058>}
(lldb) e ((MDNode*)0x1012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x101200058)->dump()
!{null}
llvm-svn: 224325
2014-12-16 15:09:37 +08:00
|
|
|
C->printAsOperand(OS);
|
|
|
|
OS << ", ";
|
2014-12-16 15:40:31 +08:00
|
|
|
S->printAsOperand(OS);
|
IR: Make MDNode::dump() useful by adding addresses
It's horrible to inspect `MDNode`s in a debugger. All of their operands
that are `MDNode`s get dumped as `<badref>`, since we can't assign
metadata slots in the context of a `Metadata::dump()`. (Why not? Why
not assign numbers lazily? Because then each time you called `dump()`,
a given `MDNode` could have a different lazily assigned number.)
Fortunately, the C memory model gives us perfectly good identifiers for
`MDNode`. Add pointer addresses to the dumps, transforming this:
(lldb) e N->dump()
!{i32 662302, i32 26, <badref>, null}
(lldb) e ((MDNode*)N->getOperand(2))->dump()
!{i32 4, !"foo"}
into:
(lldb) e N->dump()
!{i32 662302, i32 26, <0x100706ee0>, null}
(lldb) e ((MDNode*)0x100706ee0)->dump()
!{i32 4, !"foo"}
and this:
(lldb) e N->dump()
0x101200248 = !{<badref>, <badref>, <badref>, <badref>, <badref>}
(lldb) e N->getOperand(0)
(const llvm::MDOperand) $0 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(1)
(const llvm::MDOperand) $1 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(2)
(const llvm::MDOperand) $2 = {
MD = 0x0000000101200058
}
(lldb) e N->getOperand(3)
(const llvm::MDOperand) $3 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(4)
(const llvm::MDOperand) $4 = {
MD = 0x0000000101200058
}
(lldb) e ((MDNode*)0x00000001012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x0000000101200058)->dump()
!{null}
into:
(lldb) e N->dump()
!{<0x1012004e0>, <0x1012004e0>, <0x101200058>, <0x1012004e0>, <0x101200058>}
(lldb) e ((MDNode*)0x1012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x101200058)->dump()
!{null}
llvm-svn: 224325
2014-12-16 15:09:37 +08:00
|
|
|
OS << ", null";
|
|
|
|
MDNode *Nodes[] = {N0, N1, N2};
|
|
|
|
for (auto *Node : Nodes)
|
|
|
|
OS << ", <" << (void *)Node << ">";
|
2015-02-26 06:46:38 +08:00
|
|
|
OS << "}";
|
IR: Make MDNode::dump() useful by adding addresses
It's horrible to inspect `MDNode`s in a debugger. All of their operands
that are `MDNode`s get dumped as `<badref>`, since we can't assign
metadata slots in the context of a `Metadata::dump()`. (Why not? Why
not assign numbers lazily? Because then each time you called `dump()`,
a given `MDNode` could have a different lazily assigned number.)
Fortunately, the C memory model gives us perfectly good identifiers for
`MDNode`. Add pointer addresses to the dumps, transforming this:
(lldb) e N->dump()
!{i32 662302, i32 26, <badref>, null}
(lldb) e ((MDNode*)N->getOperand(2))->dump()
!{i32 4, !"foo"}
into:
(lldb) e N->dump()
!{i32 662302, i32 26, <0x100706ee0>, null}
(lldb) e ((MDNode*)0x100706ee0)->dump()
!{i32 4, !"foo"}
and this:
(lldb) e N->dump()
0x101200248 = !{<badref>, <badref>, <badref>, <badref>, <badref>}
(lldb) e N->getOperand(0)
(const llvm::MDOperand) $0 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(1)
(const llvm::MDOperand) $1 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(2)
(const llvm::MDOperand) $2 = {
MD = 0x0000000101200058
}
(lldb) e N->getOperand(3)
(const llvm::MDOperand) $3 = {
MD = 0x00000001012004e0
}
(lldb) e N->getOperand(4)
(const llvm::MDOperand) $4 = {
MD = 0x0000000101200058
}
(lldb) e ((MDNode*)0x00000001012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x0000000101200058)->dump()
!{null}
into:
(lldb) e N->dump()
!{<0x1012004e0>, <0x1012004e0>, <0x101200058>, <0x1012004e0>, <0x101200058>}
(lldb) e ((MDNode*)0x1012004e0)->dump()
!{}
(lldb) e ((MDNode*)0x101200058)->dump()
!{null}
llvm-svn: 224325
2014-12-16 15:09:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string Actual;
|
|
|
|
{
|
|
|
|
raw_string_ostream OS(Actual);
|
|
|
|
N->print(OS);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPECT_EQ(Expected, Actual);
|
|
|
|
}
|
|
|
|
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
llvm-svn: 232275
2015-03-15 04:19:36 +08:00
|
|
|
#define EXPECT_PRINTER_EQ(EXPECTED, PRINT) \
|
|
|
|
do { \
|
|
|
|
std::string Actual_; \
|
|
|
|
raw_string_ostream OS(Actual_); \
|
|
|
|
PRINT; \
|
|
|
|
OS.flush(); \
|
|
|
|
std::string Expected_(EXPECTED); \
|
|
|
|
EXPECT_EQ(Expected_, Actual_); \
|
|
|
|
} while (false)
|
|
|
|
|
2015-03-17 05:21:10 +08:00
|
|
|
TEST_F(MDNodeTest, PrintTemporary) {
|
|
|
|
MDNode *Arg = getNode();
|
|
|
|
TempMDNode Temp = MDNode::getTemporary(Context, Arg);
|
|
|
|
MDNode *N = getNode(Temp.get());
|
|
|
|
Module M("test", Context);
|
|
|
|
NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");
|
|
|
|
NMD->addOperand(N);
|
|
|
|
|
|
|
|
EXPECT_PRINTER_EQ("!0 = !{!1}", N->print(OS, &M));
|
|
|
|
EXPECT_PRINTER_EQ("!1 = <temporary!> !{!2}", Temp->print(OS, &M));
|
|
|
|
EXPECT_PRINTER_EQ("!2 = !{}", Arg->print(OS, &M));
|
|
|
|
|
|
|
|
// Cleanup.
|
|
|
|
Temp->replaceAllUsesWith(Arg);
|
|
|
|
}
|
|
|
|
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
llvm-svn: 232275
2015-03-15 04:19:36 +08:00
|
|
|
TEST_F(MDNodeTest, PrintFromModule) {
|
|
|
|
Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
|
|
|
|
MDString *S = MDString::get(Context, "foo");
|
|
|
|
MDNode *N0 = getNode();
|
|
|
|
MDNode *N1 = getNode(N0);
|
|
|
|
MDNode *N2 = getNode(N0, N1);
|
|
|
|
|
|
|
|
Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
|
|
|
|
MDNode *N = MDNode::get(Context, Args);
|
|
|
|
Module M("test", Context);
|
|
|
|
NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");
|
|
|
|
NMD->addOperand(N);
|
|
|
|
|
|
|
|
std::string Expected;
|
|
|
|
{
|
|
|
|
raw_string_ostream OS(Expected);
|
|
|
|
OS << "!0 = !{";
|
|
|
|
C->printAsOperand(OS);
|
|
|
|
OS << ", ";
|
|
|
|
S->printAsOperand(OS);
|
|
|
|
OS << ", null, !1, !2, !3}";
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPECT_PRINTER_EQ(Expected, N->print(OS, &M));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, PrintFromFunction) {
|
|
|
|
Module M("test", Context);
|
|
|
|
auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
|
|
|
|
auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
|
|
|
|
auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
|
|
|
|
auto *BB0 = BasicBlock::Create(Context, "entry", F0);
|
|
|
|
auto *BB1 = BasicBlock::Create(Context, "entry", F1);
|
|
|
|
auto *R0 = ReturnInst::Create(Context, BB0);
|
|
|
|
auto *R1 = ReturnInst::Create(Context, BB1);
|
|
|
|
auto *N0 = MDNode::getDistinct(Context, None);
|
|
|
|
auto *N1 = MDNode::getDistinct(Context, None);
|
|
|
|
R0->setMetadata("md", N0);
|
|
|
|
R1->setMetadata("md", N1);
|
|
|
|
|
|
|
|
EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, &M));
|
|
|
|
EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, &M));
|
2015-06-27 08:38:26 +08:00
|
|
|
|
|
|
|
ModuleSlotTracker MST(&M);
|
|
|
|
EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, MST));
|
|
|
|
EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, MST));
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
llvm-svn: 232275
2015-03-15 04:19:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, PrintFromMetadataAsValue) {
|
|
|
|
Module M("test", Context);
|
|
|
|
|
|
|
|
auto *Intrinsic =
|
|
|
|
Function::Create(FunctionType::get(Type::getVoidTy(Context),
|
|
|
|
Type::getMetadataTy(Context), false),
|
|
|
|
GlobalValue::ExternalLinkage, "llvm.intrinsic", &M);
|
|
|
|
|
|
|
|
auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
|
|
|
|
auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
|
|
|
|
auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
|
|
|
|
auto *BB0 = BasicBlock::Create(Context, "entry", F0);
|
|
|
|
auto *BB1 = BasicBlock::Create(Context, "entry", F1);
|
|
|
|
auto *N0 = MDNode::getDistinct(Context, None);
|
|
|
|
auto *N1 = MDNode::getDistinct(Context, None);
|
|
|
|
auto *MAV0 = MetadataAsValue::get(Context, N0);
|
|
|
|
auto *MAV1 = MetadataAsValue::get(Context, N1);
|
|
|
|
CallInst::Create(Intrinsic, MAV0, "", BB0);
|
|
|
|
CallInst::Create(Intrinsic, MAV1, "", BB1);
|
|
|
|
|
|
|
|
EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS));
|
|
|
|
EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS));
|
|
|
|
EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false));
|
|
|
|
EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false));
|
|
|
|
EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true));
|
|
|
|
EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true));
|
2015-06-27 08:38:26 +08:00
|
|
|
|
|
|
|
ModuleSlotTracker MST(&M);
|
|
|
|
EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS, MST));
|
|
|
|
EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS, MST));
|
|
|
|
EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false, MST));
|
|
|
|
EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false, MST));
|
|
|
|
EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true, MST));
|
|
|
|
EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true, MST));
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
llvm-svn: 232275
2015-03-15 04:19:36 +08:00
|
|
|
}
|
|
|
|
#undef EXPECT_PRINTER_EQ
|
|
|
|
|
2015-01-06 07:31:54 +08:00
|
|
|
TEST_F(MDNodeTest, NullOperand) {
|
|
|
|
// metadata !{}
|
|
|
|
MDNode *Empty = MDNode::get(Context, None);
|
|
|
|
|
|
|
|
// metadata !{metadata !{}}
|
|
|
|
Metadata *Ops[] = {Empty};
|
|
|
|
MDNode *N = MDNode::get(Context, Ops);
|
|
|
|
ASSERT_EQ(Empty, N->getOperand(0));
|
|
|
|
|
|
|
|
// metadata !{metadata !{}} => metadata !{null}
|
|
|
|
N->replaceOperandWith(0, nullptr);
|
|
|
|
ASSERT_EQ(nullptr, N->getOperand(0));
|
|
|
|
|
|
|
|
// metadata !{null}
|
|
|
|
Ops[0] = nullptr;
|
|
|
|
MDNode *NullOp = MDNode::get(Context, Ops);
|
|
|
|
ASSERT_EQ(nullptr, NullOp->getOperand(0));
|
|
|
|
EXPECT_EQ(N, NullOp);
|
|
|
|
}
|
|
|
|
|
2015-01-08 05:35:38 +08:00
|
|
|
TEST_F(MDNodeTest, DistinctOnUniquingCollision) {
|
|
|
|
// !{}
|
|
|
|
MDNode *Empty = MDNode::get(Context, None);
|
|
|
|
ASSERT_TRUE(Empty->isResolved());
|
|
|
|
EXPECT_FALSE(Empty->isDistinct());
|
|
|
|
|
|
|
|
// !{!{}}
|
|
|
|
Metadata *Wrapped1Ops[] = {Empty};
|
|
|
|
MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
|
|
|
|
ASSERT_EQ(Empty, Wrapped1->getOperand(0));
|
|
|
|
ASSERT_TRUE(Wrapped1->isResolved());
|
|
|
|
EXPECT_FALSE(Wrapped1->isDistinct());
|
|
|
|
|
|
|
|
// !{!{!{}}}
|
|
|
|
Metadata *Wrapped2Ops[] = {Wrapped1};
|
|
|
|
MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
|
|
|
|
ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));
|
|
|
|
ASSERT_TRUE(Wrapped2->isResolved());
|
|
|
|
EXPECT_FALSE(Wrapped2->isDistinct());
|
|
|
|
|
|
|
|
// !{!{!{}}} => !{!{}}
|
|
|
|
Wrapped2->replaceOperandWith(0, Empty);
|
|
|
|
ASSERT_EQ(Empty, Wrapped2->getOperand(0));
|
|
|
|
EXPECT_TRUE(Wrapped2->isDistinct());
|
|
|
|
EXPECT_FALSE(Wrapped1->isDistinct());
|
|
|
|
}
|
|
|
|
|
2015-01-08 06:24:46 +08:00
|
|
|
TEST_F(MDNodeTest, getDistinct) {
|
|
|
|
// !{}
|
|
|
|
MDNode *Empty = MDNode::get(Context, None);
|
|
|
|
ASSERT_TRUE(Empty->isResolved());
|
|
|
|
ASSERT_FALSE(Empty->isDistinct());
|
|
|
|
ASSERT_EQ(Empty, MDNode::get(Context, None));
|
|
|
|
|
|
|
|
// distinct !{}
|
|
|
|
MDNode *Distinct1 = MDNode::getDistinct(Context, None);
|
|
|
|
MDNode *Distinct2 = MDNode::getDistinct(Context, None);
|
|
|
|
EXPECT_TRUE(Distinct1->isResolved());
|
|
|
|
EXPECT_TRUE(Distinct2->isDistinct());
|
|
|
|
EXPECT_NE(Empty, Distinct1);
|
|
|
|
EXPECT_NE(Empty, Distinct2);
|
|
|
|
EXPECT_NE(Distinct1, Distinct2);
|
|
|
|
|
|
|
|
// !{}
|
|
|
|
ASSERT_EQ(Empty, MDNode::get(Context, None));
|
|
|
|
}
|
|
|
|
|
2015-01-20 02:45:35 +08:00
|
|
|
TEST_F(MDNodeTest, isUniqued) {
|
|
|
|
MDNode *U = MDTuple::get(Context, None);
|
|
|
|
MDNode *D = MDTuple::getDistinct(Context, None);
|
2015-01-20 05:30:18 +08:00
|
|
|
auto T = MDTuple::getTemporary(Context, None);
|
2015-01-20 02:45:35 +08:00
|
|
|
EXPECT_TRUE(U->isUniqued());
|
|
|
|
EXPECT_FALSE(D->isUniqued());
|
|
|
|
EXPECT_FALSE(T->isUniqued());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, isDistinct) {
|
|
|
|
MDNode *U = MDTuple::get(Context, None);
|
|
|
|
MDNode *D = MDTuple::getDistinct(Context, None);
|
2015-01-20 05:30:18 +08:00
|
|
|
auto T = MDTuple::getTemporary(Context, None);
|
2015-01-20 02:45:35 +08:00
|
|
|
EXPECT_FALSE(U->isDistinct());
|
|
|
|
EXPECT_TRUE(D->isDistinct());
|
|
|
|
EXPECT_FALSE(T->isDistinct());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, isTemporary) {
|
|
|
|
MDNode *U = MDTuple::get(Context, None);
|
|
|
|
MDNode *D = MDTuple::getDistinct(Context, None);
|
2015-01-20 05:30:18 +08:00
|
|
|
auto T = MDTuple::getTemporary(Context, None);
|
2015-01-20 02:45:35 +08:00
|
|
|
EXPECT_FALSE(U->isTemporary());
|
|
|
|
EXPECT_FALSE(D->isTemporary());
|
|
|
|
EXPECT_TRUE(T->isTemporary());
|
2015-01-13 02:41:26 +08:00
|
|
|
}
|
|
|
|
|
2015-01-08 06:24:46 +08:00
|
|
|
TEST_F(MDNodeTest, getDistinctWithUnresolvedOperands) {
|
|
|
|
// temporary !{}
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp = MDTuple::getTemporary(Context, None);
|
2015-01-08 06:24:46 +08:00
|
|
|
ASSERT_FALSE(Temp->isResolved());
|
|
|
|
|
|
|
|
// distinct !{temporary !{}}
|
2015-01-20 05:30:18 +08:00
|
|
|
Metadata *Ops[] = {Temp.get()};
|
2015-01-08 06:24:46 +08:00
|
|
|
MDNode *Distinct = MDNode::getDistinct(Context, Ops);
|
|
|
|
EXPECT_TRUE(Distinct->isResolved());
|
2015-01-20 05:30:18 +08:00
|
|
|
EXPECT_EQ(Temp.get(), Distinct->getOperand(0));
|
2015-01-08 06:24:46 +08:00
|
|
|
|
|
|
|
// temporary !{} => !{}
|
|
|
|
MDNode *Empty = MDNode::get(Context, None);
|
|
|
|
Temp->replaceAllUsesWith(Empty);
|
|
|
|
EXPECT_EQ(Empty, Distinct->getOperand(0));
|
|
|
|
}
|
|
|
|
|
2015-01-13 03:22:04 +08:00
|
|
|
TEST_F(MDNodeTest, handleChangedOperandRecursion) {
|
|
|
|
// !0 = !{}
|
|
|
|
MDNode *N0 = MDNode::get(Context, None);
|
|
|
|
|
|
|
|
// !1 = !{!3, null}
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp3 = MDTuple::getTemporary(Context, None);
|
|
|
|
Metadata *Ops1[] = {Temp3.get(), nullptr};
|
2015-01-13 03:22:04 +08:00
|
|
|
MDNode *N1 = MDNode::get(Context, Ops1);
|
|
|
|
|
|
|
|
// !2 = !{!3, !0}
|
2015-01-20 05:30:18 +08:00
|
|
|
Metadata *Ops2[] = {Temp3.get(), N0};
|
2015-01-13 03:22:04 +08:00
|
|
|
MDNode *N2 = MDNode::get(Context, Ops2);
|
|
|
|
|
|
|
|
// !3 = !{!2}
|
|
|
|
Metadata *Ops3[] = {N2};
|
|
|
|
MDNode *N3 = MDNode::get(Context, Ops3);
|
|
|
|
Temp3->replaceAllUsesWith(N3);
|
|
|
|
|
|
|
|
// !4 = !{!1}
|
|
|
|
Metadata *Ops4[] = {N1};
|
|
|
|
MDNode *N4 = MDNode::get(Context, Ops4);
|
|
|
|
|
|
|
|
// Confirm that the cycle prevented RAUW from getting dropped.
|
|
|
|
EXPECT_TRUE(N0->isResolved());
|
|
|
|
EXPECT_FALSE(N1->isResolved());
|
|
|
|
EXPECT_FALSE(N2->isResolved());
|
|
|
|
EXPECT_FALSE(N3->isResolved());
|
|
|
|
EXPECT_FALSE(N4->isResolved());
|
|
|
|
|
|
|
|
// Create a couple of distinct nodes to observe what's going on.
|
|
|
|
//
|
|
|
|
// !5 = distinct !{!2}
|
|
|
|
// !6 = distinct !{!3}
|
|
|
|
Metadata *Ops5[] = {N2};
|
|
|
|
MDNode *N5 = MDNode::getDistinct(Context, Ops5);
|
|
|
|
Metadata *Ops6[] = {N3};
|
|
|
|
MDNode *N6 = MDNode::getDistinct(Context, Ops6);
|
|
|
|
|
|
|
|
// Mutate !2 to look like !1, causing a uniquing collision (and an RAUW).
|
|
|
|
// This will ripple up, with !3 colliding with !4, and RAUWing. Since !2
|
|
|
|
// references !3, this can cause a re-entry of handleChangedOperand() when !3
|
|
|
|
// is not ready for it.
|
|
|
|
//
|
|
|
|
// !2->replaceOperandWith(1, nullptr)
|
|
|
|
// !2: !{!3, !0} => !{!3, null}
|
|
|
|
// !2->replaceAllUsesWith(!1)
|
|
|
|
// !3: !{!2] => !{!1}
|
|
|
|
// !3->replaceAllUsesWith(!4)
|
|
|
|
N2->replaceOperandWith(1, nullptr);
|
|
|
|
|
|
|
|
// If all has gone well, N2 and N3 will have been RAUW'ed and deleted from
|
|
|
|
// under us. Just check that the other nodes are sane.
|
|
|
|
//
|
|
|
|
// !1 = !{!4, null}
|
|
|
|
// !4 = !{!1}
|
|
|
|
// !5 = distinct !{!1}
|
|
|
|
// !6 = distinct !{!4}
|
|
|
|
EXPECT_EQ(N4, N1->getOperand(0));
|
|
|
|
EXPECT_EQ(N1, N4->getOperand(0));
|
|
|
|
EXPECT_EQ(N1, N5->getOperand(0));
|
|
|
|
EXPECT_EQ(N4, N6->getOperand(0));
|
|
|
|
}
|
|
|
|
|
2015-01-13 08:46:34 +08:00
|
|
|
TEST_F(MDNodeTest, replaceResolvedOperand) {
|
|
|
|
// Check code for replacing one resolved operand with another. If doing this
|
|
|
|
// directly (via replaceOperandWith()) becomes illegal, change the operand to
|
|
|
|
// a global value that gets RAUW'ed.
|
|
|
|
//
|
|
|
|
// Use a temporary node to keep N from being resolved.
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp = MDTuple::getTemporary(Context, None);
|
|
|
|
Metadata *Ops[] = {nullptr, Temp.get()};
|
2015-01-13 08:46:34 +08:00
|
|
|
|
2015-01-13 16:13:46 +08:00
|
|
|
MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());
|
2015-01-13 08:46:34 +08:00
|
|
|
MDNode *N = MDTuple::get(Context, Ops);
|
|
|
|
EXPECT_EQ(nullptr, N->getOperand(0));
|
|
|
|
ASSERT_FALSE(N->isResolved());
|
|
|
|
|
|
|
|
// Check code for replacing resolved nodes.
|
|
|
|
N->replaceOperandWith(0, Empty);
|
|
|
|
EXPECT_EQ(Empty, N->getOperand(0));
|
|
|
|
|
|
|
|
// Check code for adding another unresolved operand.
|
2015-01-20 05:30:18 +08:00
|
|
|
N->replaceOperandWith(0, Temp.get());
|
|
|
|
EXPECT_EQ(Temp.get(), N->getOperand(0));
|
2015-01-13 08:46:34 +08:00
|
|
|
|
|
|
|
// Remove the references to Temp; required for teardown.
|
|
|
|
Temp->replaceAllUsesWith(nullptr);
|
|
|
|
}
|
|
|
|
|
2015-01-20 06:24:52 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithUniqued) {
|
|
|
|
auto *Empty = MDTuple::get(Context, None);
|
|
|
|
MDTuple *FirstUniqued;
|
|
|
|
{
|
|
|
|
Metadata *Ops[] = {Empty};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
EXPECT_TRUE(Temp->isTemporary());
|
|
|
|
|
|
|
|
// Don't expect a collision.
|
|
|
|
auto *Current = Temp.get();
|
|
|
|
FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));
|
|
|
|
EXPECT_TRUE(FirstUniqued->isUniqued());
|
|
|
|
EXPECT_TRUE(FirstUniqued->isResolved());
|
|
|
|
EXPECT_EQ(Current, FirstUniqued);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
Metadata *Ops[] = {Empty};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
EXPECT_TRUE(Temp->isTemporary());
|
|
|
|
|
|
|
|
// Should collide with Uniqued above this time.
|
|
|
|
auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
|
|
|
|
EXPECT_TRUE(Uniqued->isUniqued());
|
|
|
|
EXPECT_TRUE(Uniqued->isResolved());
|
|
|
|
EXPECT_EQ(FirstUniqued, Uniqued);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
auto Unresolved = MDTuple::getTemporary(Context, None);
|
|
|
|
Metadata *Ops[] = {Unresolved.get()};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
EXPECT_TRUE(Temp->isTemporary());
|
|
|
|
|
|
|
|
// Shouldn't be resolved.
|
|
|
|
auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
|
|
|
|
EXPECT_TRUE(Uniqued->isUniqued());
|
|
|
|
EXPECT_FALSE(Uniqued->isResolved());
|
|
|
|
|
|
|
|
// Should be a different node.
|
|
|
|
EXPECT_NE(FirstUniqued, Uniqued);
|
|
|
|
|
|
|
|
// Should resolve when we update its node (note: be careful to avoid a
|
|
|
|
// collision with any other nodes above).
|
|
|
|
Uniqued->replaceOperandWith(0, nullptr);
|
|
|
|
EXPECT_TRUE(Uniqued->isResolved());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-01 05:05:06 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithUniquedResolvingOperand) {
|
2015-04-01 04:50:50 +08:00
|
|
|
// temp !{}
|
|
|
|
MDTuple *Op = MDTuple::getTemporary(Context, None).release();
|
|
|
|
EXPECT_FALSE(Op->isResolved());
|
|
|
|
|
|
|
|
// temp !{temp !{}}
|
|
|
|
Metadata *Ops[] = {Op};
|
|
|
|
MDTuple *N = MDTuple::getTemporary(Context, Ops).release();
|
|
|
|
EXPECT_FALSE(N->isResolved());
|
|
|
|
|
|
|
|
// temp !{temp !{}} => !{temp !{}}
|
|
|
|
ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
|
|
|
|
EXPECT_FALSE(N->isResolved());
|
|
|
|
|
|
|
|
// !{temp !{}} => !{!{}}
|
|
|
|
ASSERT_EQ(Op, MDNode::replaceWithUniqued(TempMDTuple(Op)));
|
|
|
|
EXPECT_TRUE(Op->isResolved());
|
|
|
|
EXPECT_TRUE(N->isResolved());
|
|
|
|
}
|
|
|
|
|
2015-04-01 05:05:06 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithUniquedChangingOperand) {
|
2015-04-01 04:50:50 +08:00
|
|
|
// i1* @GV
|
|
|
|
Type *Ty = Type::getInt1PtrTy(Context);
|
|
|
|
std::unique_ptr<GlobalVariable> GV(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());
|
|
|
|
|
|
|
|
// temp !{i1* @GV}
|
|
|
|
Metadata *Ops[] = {Op};
|
|
|
|
MDTuple *N = MDTuple::getTemporary(Context, Ops).release();
|
|
|
|
|
|
|
|
// temp !{i1* @GV} => !{i1* @GV}
|
|
|
|
ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
|
|
|
|
// !{i1* @GV} => !{null}
|
|
|
|
GV.reset();
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
Metadata *NullOps[] = {nullptr};
|
|
|
|
ASSERT_EQ(N, MDTuple::get(Context, NullOps));
|
|
|
|
}
|
|
|
|
|
2015-01-20 06:24:52 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithDistinct) {
|
|
|
|
{
|
|
|
|
auto *Empty = MDTuple::get(Context, None);
|
|
|
|
Metadata *Ops[] = {Empty};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
EXPECT_TRUE(Temp->isTemporary());
|
|
|
|
|
|
|
|
// Don't expect a collision.
|
|
|
|
auto *Current = Temp.get();
|
|
|
|
auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
|
|
|
|
EXPECT_TRUE(Distinct->isDistinct());
|
|
|
|
EXPECT_TRUE(Distinct->isResolved());
|
|
|
|
EXPECT_EQ(Current, Distinct);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
auto Unresolved = MDTuple::getTemporary(Context, None);
|
|
|
|
Metadata *Ops[] = {Unresolved.get()};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
EXPECT_TRUE(Temp->isTemporary());
|
|
|
|
|
|
|
|
// Don't expect a collision.
|
|
|
|
auto *Current = Temp.get();
|
|
|
|
auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
|
|
|
|
EXPECT_TRUE(Distinct->isDistinct());
|
|
|
|
EXPECT_TRUE(Distinct->isResolved());
|
|
|
|
EXPECT_EQ(Current, Distinct);
|
|
|
|
|
|
|
|
// Cleanup; required for teardown.
|
|
|
|
Unresolved->replaceAllUsesWith(nullptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-11 03:13:46 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithPermanent) {
|
|
|
|
Metadata *Ops[] = {nullptr};
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, Ops);
|
|
|
|
auto *T = Temp.get();
|
|
|
|
|
|
|
|
// U is a normal, uniqued node that references T.
|
|
|
|
auto *U = MDTuple::get(Context, T);
|
|
|
|
EXPECT_TRUE(U->isUniqued());
|
|
|
|
|
|
|
|
// Make Temp self-referencing.
|
|
|
|
Temp->replaceOperandWith(0, T);
|
|
|
|
|
|
|
|
// Try to uniquify Temp. This should, despite the name in the API, give a
|
|
|
|
// 'distinct' node, since self-references aren't allowed to be uniqued.
|
|
|
|
//
|
|
|
|
// Since it's distinct, N should have the same address as when it was a
|
|
|
|
// temporary (i.e., be equal to T not U).
|
|
|
|
auto *N = MDNode::replaceWithPermanent(std::move(Temp));
|
|
|
|
EXPECT_EQ(N, T);
|
|
|
|
EXPECT_TRUE(N->isDistinct());
|
|
|
|
|
|
|
|
// U should be the canonical unique node with N as the argument.
|
|
|
|
EXPECT_EQ(U, MDTuple::get(Context, N));
|
|
|
|
EXPECT_TRUE(U->isUniqued());
|
|
|
|
|
|
|
|
// This temporary should collide with U when replaced, but it should still be
|
|
|
|
// uniqued.
|
|
|
|
EXPECT_EQ(U, MDNode::replaceWithPermanent(MDTuple::getTemporary(Context, N)));
|
|
|
|
EXPECT_TRUE(U->isUniqued());
|
|
|
|
|
|
|
|
// This temporary should become a new uniqued node.
|
|
|
|
auto Temp2 = MDTuple::getTemporary(Context, U);
|
|
|
|
auto *V = Temp2.get();
|
|
|
|
EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));
|
|
|
|
EXPECT_TRUE(V->isUniqued());
|
|
|
|
EXPECT_EQ(U, V->getOperand(0));
|
|
|
|
}
|
|
|
|
|
2015-01-23 05:36:45 +08:00
|
|
|
TEST_F(MDNodeTest, deleteTemporaryWithTrackingRef) {
|
|
|
|
TrackingMDRef Ref;
|
|
|
|
EXPECT_EQ(nullptr, Ref.get());
|
|
|
|
{
|
|
|
|
auto Temp = MDTuple::getTemporary(Context, None);
|
|
|
|
Ref.reset(Temp.get());
|
|
|
|
EXPECT_EQ(Temp.get(), Ref.get());
|
|
|
|
}
|
|
|
|
EXPECT_EQ(nullptr, Ref.get());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DILocationTest;
|
2015-01-14 04:44:56 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILocationTest, Overflow) {
|
|
|
|
DISubprogram *N = getSubprogram();
|
2015-01-14 04:44:56 +08:00
|
|
|
{
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L = DILocation::get(Context, 2, 7, N);
|
2015-01-14 04:44:56 +08:00
|
|
|
EXPECT_EQ(2u, L->getLine());
|
|
|
|
EXPECT_EQ(7u, L->getColumn());
|
|
|
|
}
|
2015-01-17 01:33:08 +08:00
|
|
|
unsigned U16 = 1u << 16;
|
2015-01-14 04:44:56 +08:00
|
|
|
{
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L = DILocation::get(Context, UINT32_MAX, U16 - 1, N);
|
2015-02-07 06:50:13 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX, L->getLine());
|
2015-01-17 01:33:08 +08:00
|
|
|
EXPECT_EQ(U16 - 1, L->getColumn());
|
2015-01-14 04:44:56 +08:00
|
|
|
}
|
|
|
|
{
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L = DILocation::get(Context, UINT32_MAX, U16, N);
|
2015-02-07 06:50:13 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX, L->getLine());
|
2015-01-14 04:44:56 +08:00
|
|
|
EXPECT_EQ(0u, L->getColumn());
|
|
|
|
}
|
|
|
|
{
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L = DILocation::get(Context, UINT32_MAX, U16 + 1, N);
|
2015-02-07 06:50:13 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX, L->getLine());
|
2015-01-14 04:44:56 +08:00
|
|
|
EXPECT_EQ(0u, L->getColumn());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILocationTest, getDistinct) {
|
2015-03-27 06:05:04 +08:00
|
|
|
MDNode *N = getSubprogram();
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L0 = DILocation::getDistinct(Context, 2, 7, N);
|
2015-01-14 04:44:56 +08:00
|
|
|
EXPECT_TRUE(L0->isDistinct());
|
2015-04-30 00:38:44 +08:00
|
|
|
DILocation *L1 = DILocation::get(Context, 2, 7, N);
|
2015-01-14 04:44:56 +08:00
|
|
|
EXPECT_FALSE(L1->isDistinct());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(L1, DILocation::get(Context, 2, 7, N));
|
2015-01-14 04:44:56 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILocationTest, getTemporary) {
|
2015-01-20 04:37:44 +08:00
|
|
|
MDNode *N = MDNode::get(Context, None);
|
2015-04-30 00:38:44 +08:00
|
|
|
auto L = DILocation::getTemporary(Context, 2, 7, N);
|
2015-01-20 04:37:44 +08:00
|
|
|
EXPECT_TRUE(L->isTemporary());
|
|
|
|
EXPECT_FALSE(L->isResolved());
|
|
|
|
}
|
|
|
|
|
2015-12-07 23:05:44 +08:00
|
|
|
TEST_F(DILocationTest, cloneTemporary) {
|
|
|
|
MDNode *N = MDNode::get(Context, None);
|
|
|
|
auto L = DILocation::getTemporary(Context, 2, 7, N);
|
|
|
|
EXPECT_TRUE(L->isTemporary());
|
|
|
|
auto L2 = L->clone();
|
|
|
|
EXPECT_TRUE(L2->isTemporary());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest GenericDINodeTest;
|
2015-01-20 08:01:43 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(GenericDINodeTest, get) {
|
2015-01-23 07:10:55 +08:00
|
|
|
StringRef Header = "header";
|
2015-01-20 08:01:43 +08:00
|
|
|
auto *Empty = MDNode::get(Context, None);
|
|
|
|
Metadata *Ops1[] = {Empty};
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = GenericDINode::get(Context, 15, Header, Ops1);
|
2015-01-20 08:01:43 +08:00
|
|
|
EXPECT_EQ(15u, N->getTag());
|
|
|
|
EXPECT_EQ(2u, N->getNumOperands());
|
|
|
|
EXPECT_EQ(Header, N->getHeader());
|
2015-01-23 07:10:55 +08:00
|
|
|
EXPECT_EQ(MDString::get(Context, Header), N->getOperand(0));
|
2015-01-20 08:01:43 +08:00
|
|
|
EXPECT_EQ(1u, N->getNumDwarfOperands());
|
|
|
|
EXPECT_EQ(Empty, N->getDwarfOperand(0));
|
|
|
|
EXPECT_EQ(Empty, N->getOperand(1));
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
|
2015-01-20 08:01:43 +08:00
|
|
|
|
|
|
|
N->replaceOperandWith(1, nullptr);
|
|
|
|
EXPECT_EQ(15u, N->getTag());
|
|
|
|
EXPECT_EQ(Header, N->getHeader());
|
|
|
|
EXPECT_EQ(nullptr, N->getDwarfOperand(0));
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
|
|
|
|
Metadata *Ops2[] = {nullptr};
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops2));
|
2015-01-20 08:01:43 +08:00
|
|
|
|
|
|
|
N->replaceDwarfOperandWith(0, Empty);
|
|
|
|
EXPECT_EQ(15u, N->getTag());
|
|
|
|
EXPECT_EQ(Header, N->getHeader());
|
|
|
|
EXPECT_EQ(Empty, N->getDwarfOperand(0));
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempGenericDINode Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-01-20 08:01:43 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(GenericDINodeTest, getEmptyHeader) {
|
2015-01-20 08:58:46 +08:00
|
|
|
// Canonicalize !"" to null.
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = GenericDINode::get(Context, 15, StringRef(), None);
|
2015-01-23 07:10:55 +08:00
|
|
|
EXPECT_EQ(StringRef(), N->getHeader());
|
|
|
|
EXPECT_EQ(nullptr, N->getOperand(0));
|
2015-01-20 08:58:46 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DISubrangeTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DISubrangeTest, get) {
|
|
|
|
auto *N = DISubrange::get(Context, 5, 7);
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
|
|
|
|
EXPECT_EQ(5, N->getCount());
|
2015-04-07 08:39:59 +08:00
|
|
|
EXPECT_EQ(7, N->getLowerBound());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DISubrange::get(Context, 5, 7));
|
|
|
|
EXPECT_EQ(DISubrange::get(Context, 5, 0), DISubrange::get(Context, 5));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDISubrange Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DISubrangeTest, getEmptyArray) {
|
|
|
|
auto *N = DISubrange::get(Context, -1, 0);
|
2015-02-19 07:17:51 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
|
|
|
|
EXPECT_EQ(-1, N->getCount());
|
2015-04-07 08:39:59 +08:00
|
|
|
EXPECT_EQ(0, N->getLowerBound());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DISubrange::get(Context, -1, 0));
|
2015-02-19 07:17:51 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIEnumeratorTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIEnumeratorTest, get) {
|
|
|
|
auto *N = DIEnumerator::get(Context, 7, "name");
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
|
|
|
|
EXPECT_EQ(7, N->getValue());
|
|
|
|
EXPECT_EQ("name", N->getName());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIEnumerator::get(Context, 7, "name"));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIEnumerator::get(Context, 8, "name"));
|
|
|
|
EXPECT_NE(N, DIEnumerator::get(Context, 7, "nam"));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIEnumerator Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIBasicTypeTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIBasicTypeTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
auto *N =
|
2015-04-30 00:38:44 +08:00
|
|
|
DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
|
|
|
|
EXPECT_EQ("special", N->getName());
|
|
|
|
EXPECT_EQ(33u, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(26u, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(7u, N->getEncoding());
|
|
|
|
EXPECT_EQ(0u, N->getLine());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2015-02-10 08:52:32 +08:00
|
|
|
26, 7));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"special", 33, 26, 7));
|
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));
|
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
|
2015-02-10 08:52:32 +08:00
|
|
|
26, 7));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2015-02-10 08:52:32 +08:00
|
|
|
25, 7));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2015-02-10 08:52:32 +08:00
|
|
|
26, 6));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIBasicType Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIBasicTypeTest, getWithLargeValues) {
|
|
|
|
auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special",
|
2015-02-20 07:56:07 +08:00
|
|
|
UINT64_MAX, UINT64_MAX - 1, 7);
|
|
|
|
EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIBasicTypeTest, getUnspecified) {
|
2015-03-04 00:45:34 +08:00
|
|
|
auto *N =
|
2015-04-30 00:38:44 +08:00
|
|
|
DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, "unspecified");
|
2015-03-04 00:45:34 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());
|
|
|
|
EXPECT_EQ("unspecified", N->getName());
|
|
|
|
EXPECT_EQ(0u, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(0u, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(0u, N->getEncoding());
|
|
|
|
EXPECT_EQ(0u, N->getLine());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DITypeTest;
|
2015-03-04 00:45:34 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DITypeTest, clone) {
|
|
|
|
// Check that DIType has a specialized clone that returns TempDIType.
|
|
|
|
DIType *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
|
2015-03-04 00:45:34 +08:00
|
|
|
dwarf::DW_ATE_signed);
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIType Temp = N->clone();
|
2015-03-04 00:45:34 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DITypeTest, setFlags) {
|
2015-03-04 00:45:34 +08:00
|
|
|
// void (void)
|
|
|
|
Metadata *TypesOps[] = {nullptr};
|
|
|
|
Metadata *Types = MDTuple::get(Context, TypesOps);
|
|
|
|
|
2016-06-09 04:34:29 +08:00
|
|
|
DIType *D = DISubroutineType::getDistinct(Context, 0u, 0, Types);
|
2015-03-04 00:45:34 +08:00
|
|
|
EXPECT_EQ(0u, D->getFlags());
|
2015-04-30 00:38:44 +08:00
|
|
|
D->setFlags(DINode::FlagRValueReference);
|
|
|
|
EXPECT_EQ(DINode::FlagRValueReference, D->getFlags());
|
2015-03-04 00:45:34 +08:00
|
|
|
D->setFlags(0u);
|
|
|
|
EXPECT_EQ(0u, D->getFlags());
|
|
|
|
|
2016-06-09 04:34:29 +08:00
|
|
|
TempDIType T = DISubroutineType::getTemporary(Context, 0u, 0, Types);
|
2015-03-04 00:45:34 +08:00
|
|
|
EXPECT_EQ(0u, T->getFlags());
|
2015-04-30 00:38:44 +08:00
|
|
|
T->setFlags(DINode::FlagRValueReference);
|
|
|
|
EXPECT_EQ(DINode::FlagRValueReference, T->getFlags());
|
2015-03-04 00:45:34 +08:00
|
|
|
T->setFlags(0u);
|
|
|
|
EXPECT_EQ(0u, T->getFlags());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIDerivedTypeTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIDerivedTypeTest, get) {
|
|
|
|
DIFile *File = getFile();
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getBasicType("basic");
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *ExtraData = getTuple();
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
|
2015-02-10 08:52:32 +08:00
|
|
|
File, 1, Scope, BaseType, 2, 3, 4, 5, ExtraData);
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
|
|
|
|
EXPECT_EQ("something", N->getName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(1u, N->getLine());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(BaseType, N->getBaseType());
|
|
|
|
EXPECT_EQ(2u, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(3u, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(4u, N->getOffsetInBits());
|
|
|
|
EXPECT_EQ(5u, N->getFlags());
|
|
|
|
EXPECT_EQ(ExtraData, N->getExtraData());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
4, 5, ExtraData));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_reference_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
|
2015-02-10 08:52:32 +08:00
|
|
|
File, 1, Scope, BaseType, 2, 3, 4, 5,
|
|
|
|
ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-03-28 07:05:04 +08:00
|
|
|
"something", getFile(), 1, Scope, BaseType, 2,
|
|
|
|
3, 4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 2, Scope, BaseType, 2, 3,
|
|
|
|
4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2016-04-24 05:08:00 +08:00
|
|
|
"something", File, 1, getSubprogram(),
|
2015-03-28 07:05:04 +08:00
|
|
|
BaseType, 2, 3, 4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(
|
2015-03-28 07:05:04 +08:00
|
|
|
Context, dwarf::DW_TAG_pointer_type, "something", File, 1,
|
|
|
|
Scope, getBasicType("basic2"), 2, 3, 4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 3, 3,
|
|
|
|
4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 2,
|
|
|
|
4, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
5, 5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-02-10 08:52:32 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
4, 4, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
2015-03-28 07:05:04 +08:00
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
4, 5, getTuple()));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIDerivedType Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIDerivedTypeTest, getWithLargeValues) {
|
|
|
|
DIFile *File = getFile();
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getBasicType("basic");
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *ExtraData = getTuple();
|
2015-02-20 07:56:07 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
|
2015-02-20 07:56:07 +08:00
|
|
|
File, 1, Scope, BaseType, UINT64_MAX,
|
|
|
|
UINT64_MAX - 1, UINT64_MAX - 2, 5, ExtraData);
|
|
|
|
EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DICompositeTypeTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DICompositeTypeTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Tag = dwarf::DW_TAG_structure_type;
|
|
|
|
StringRef Name = "some name";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 1;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getCompositeType();
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t SizeInBits = 2;
|
|
|
|
uint64_t AlignInBits = 3;
|
|
|
|
uint64_t OffsetInBits = 4;
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Flags = 5;
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *Elements = getTuple();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned RuntimeLang = 6;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *VTableHolder = getCompositeType();
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *TemplateParams = getTuple();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Identifier = "some id";
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier);
|
|
|
|
EXPECT_EQ(Tag, N->getTag());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(BaseType, N->getBaseType());
|
|
|
|
EXPECT_EQ(SizeInBits, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(AlignInBits, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
|
|
|
|
EXPECT_EQ(Flags, N->getFlags());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(Elements, N->getElements().get());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
|
|
|
|
EXPECT_EQ(VTableHolder, N->getVTableHolder());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(Identifier, N->getIdentifier());
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag + 1, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, "abc", File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, getFile(), Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line + 1, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2016-04-24 05:08:00 +08:00
|
|
|
Context, Tag, Name, File, Line, getSubprogram(), BaseType,
|
2015-04-07 03:03:45 +08:00
|
|
|
SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
|
|
|
|
RuntimeLang, VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-04-07 03:03:45 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, getBasicType("other"),
|
2015-03-28 07:05:04 +08:00
|
|
|
SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
|
|
|
|
RuntimeLang, VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits + 1, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits + 1,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-02-10 08:52:32 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
|
|
AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-02-10 08:52:32 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
|
|
AlignInBits, OffsetInBits, Flags + 1, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-03-28 07:05:04 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
|
|
AlignInBits, OffsetInBits, Flags, getTuple(), RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-02-10 08:52:32 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
|
|
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,
|
|
|
|
VTableHolder, TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(
|
2015-03-28 07:05:04 +08:00
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
|
|
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
getCompositeType(), TemplateParams, Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
2015-03-28 07:05:04 +08:00
|
|
|
VTableHolder, getTuple(), Identifier));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-10 08:52:32 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, "other"));
|
|
|
|
|
|
|
|
// Be sure that missing identifiers get null pointers.
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, "")
|
|
|
|
->getRawIdentifier());
|
|
|
|
EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams)
|
|
|
|
->getRawIdentifier());
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDICompositeType Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DICompositeTypeTest, getWithLargeValues) {
|
2015-02-20 07:56:07 +08:00
|
|
|
unsigned Tag = dwarf::DW_TAG_structure_type;
|
|
|
|
StringRef Name = "some name";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-20 07:56:07 +08:00
|
|
|
unsigned Line = 1;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getCompositeType();
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t SizeInBits = UINT64_MAX;
|
|
|
|
uint64_t AlignInBits = UINT64_MAX - 1;
|
|
|
|
uint64_t OffsetInBits = UINT64_MAX - 2;
|
|
|
|
unsigned Flags = 5;
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *Elements = getTuple();
|
2015-02-20 07:56:07 +08:00
|
|
|
unsigned RuntimeLang = 6;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *VTableHolder = getCompositeType();
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *TemplateParams = getTuple();
|
2015-02-20 07:56:07 +08:00
|
|
|
StringRef Identifier = "some id";
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
|
2015-02-20 07:56:07 +08:00
|
|
|
BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, Elements, RuntimeLang,
|
|
|
|
VTableHolder, TemplateParams, Identifier);
|
|
|
|
EXPECT_EQ(SizeInBits, N->getSizeInBits());
|
|
|
|
EXPECT_EQ(AlignInBits, N->getAlignInBits());
|
|
|
|
EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DICompositeTypeTest, replaceOperands) {
|
2015-02-19 04:47:52 +08:00
|
|
|
unsigned Tag = dwarf::DW_TAG_structure_type;
|
|
|
|
StringRef Name = "some name";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-19 04:47:52 +08:00
|
|
|
unsigned Line = 1;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getCompositeType();
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t SizeInBits = 2;
|
|
|
|
uint64_t AlignInBits = 3;
|
|
|
|
uint64_t OffsetInBits = 4;
|
2015-02-19 04:47:52 +08:00
|
|
|
unsigned Flags = 5;
|
|
|
|
unsigned RuntimeLang = 6;
|
|
|
|
StringRef Identifier = "some id";
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DICompositeType::get(
|
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier);
|
2015-02-19 04:47:52 +08:00
|
|
|
|
|
|
|
auto *Elements = MDTuple::getDistinct(Context, None);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getElements().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
N->replaceElements(Elements);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(Elements, N->getElements().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
N->replaceElements(nullptr);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getElements().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *VTableHolder = getCompositeType();
|
2015-02-19 04:47:52 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getVTableHolder());
|
|
|
|
N->replaceVTableHolder(VTableHolder);
|
|
|
|
EXPECT_EQ(VTableHolder, N->getVTableHolder());
|
|
|
|
N->replaceVTableHolder(nullptr);
|
|
|
|
EXPECT_EQ(nullptr, N->getVTableHolder());
|
|
|
|
|
|
|
|
auto *TemplateParams = MDTuple::getDistinct(Context, None);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getTemplateParams().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
N->replaceTemplateParams(TemplateParams);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
N->replaceTemplateParams(nullptr);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getTemplateParams().get());
|
2015-02-19 04:47:52 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DISubroutineTypeTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DISubroutineTypeTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Flags = 1;
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *TypeArray = getTuple();
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2016-06-09 04:34:29 +08:00
|
|
|
auto *N = DISubroutineType::get(Context, Flags, 0, TypeArray);
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
|
|
|
|
EXPECT_EQ(Flags, N->getFlags());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(TypeArray, N->getTypeArray().get());
|
2016-06-09 04:34:29 +08:00
|
|
|
EXPECT_EQ(N, DISubroutineType::get(Context, Flags, 0, TypeArray));
|
|
|
|
|
|
|
|
EXPECT_NE(N, DISubroutineType::get(Context, Flags + 1, 0, TypeArray));
|
|
|
|
EXPECT_NE(N, DISubroutineType::get(Context, Flags, 0, getTuple()));
|
|
|
|
|
|
|
|
// Test the hashing of calling conventions.
|
|
|
|
auto *Fast = DISubroutineType::get(
|
|
|
|
Context, Flags, dwarf::DW_CC_BORLAND_msfastcall, TypeArray);
|
|
|
|
auto *Std = DISubroutineType::get(Context, Flags,
|
|
|
|
dwarf::DW_CC_BORLAND_stdcall, TypeArray);
|
|
|
|
EXPECT_EQ(Fast,
|
|
|
|
DISubroutineType::get(Context, Flags,
|
|
|
|
dwarf::DW_CC_BORLAND_msfastcall, TypeArray));
|
|
|
|
EXPECT_EQ(Std, DISubroutineType::get(
|
|
|
|
Context, Flags, dwarf::DW_CC_BORLAND_stdcall, TypeArray));
|
|
|
|
|
|
|
|
EXPECT_NE(N, Fast);
|
|
|
|
EXPECT_NE(N, Std);
|
|
|
|
EXPECT_NE(Fast, Std);
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDISubroutineType Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-20 07:25:21 +08:00
|
|
|
|
|
|
|
// Test always-empty operands.
|
|
|
|
EXPECT_EQ(nullptr, N->getScope());
|
|
|
|
EXPECT_EQ(nullptr, N->getFile());
|
|
|
|
EXPECT_EQ("", N->getName());
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIFileTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIFileTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Filename = "file";
|
|
|
|
StringRef Directory = "dir";
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIFile::get(Context, Filename, Directory);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
|
|
|
|
EXPECT_EQ(Filename, N->getFilename());
|
|
|
|
EXPECT_EQ(Directory, N->getDirectory());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIFile::get(Context, Filename, Directory));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIFile::get(Context, "other", Directory));
|
|
|
|
EXPECT_NE(N, DIFile::get(Context, Filename, "other"));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIFile Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIFileTest, ScopeGetFile) {
|
|
|
|
// Ensure that DIScope::getFile() returns itself.
|
|
|
|
DIScope *N = DIFile::get(Context, "file", "dir");
|
2015-03-01 05:47:02 +08:00
|
|
|
EXPECT_EQ(N, N->getFile());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DICompileUnitTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DICompileUnitTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned SourceLanguage = 1;
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Producer = "some producer";
|
|
|
|
bool IsOptimized = false;
|
|
|
|
StringRef Flags = "flag after flag";
|
|
|
|
unsigned RuntimeVersion = 2;
|
|
|
|
StringRef SplitDebugFilename = "another/file";
|
2016-04-01 07:56:58 +08:00
|
|
|
auto EmissionKind = DICompileUnit::FullDebug;
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *EnumTypes = getTuple();
|
|
|
|
MDTuple *RetainedTypes = getTuple();
|
|
|
|
MDTuple *GlobalVariables = getTuple();
|
|
|
|
MDTuple *ImportedEntities = getTuple();
|
2015-09-23 07:42:47 +08:00
|
|
|
uint64_t DWOId = 0x10000000c0ffee;
|
2015-12-10 20:56:35 +08:00
|
|
|
MDTuple *Macros = getTuple();
|
2015-08-04 01:26:41 +08:00
|
|
|
auto *N = DICompileUnit::getDistinct(
|
2015-02-10 08:52:32 +08:00
|
|
|
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
|
|
|
|
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
|
2016-04-15 23:57:41 +08:00
|
|
|
RetainedTypes, GlobalVariables, ImportedEntities, Macros,
|
2015-12-10 20:56:35 +08:00
|
|
|
DWOId);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
|
|
|
|
EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Producer, N->getProducer());
|
|
|
|
EXPECT_EQ(IsOptimized, N->isOptimized());
|
|
|
|
EXPECT_EQ(Flags, N->getFlags());
|
|
|
|
EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
|
|
|
|
EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
|
|
|
|
EXPECT_EQ(EmissionKind, N->getEmissionKind());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(EnumTypes, N->getEnumTypes().get());
|
|
|
|
EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());
|
|
|
|
EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
|
|
|
|
EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());
|
2015-12-10 20:56:35 +08:00
|
|
|
EXPECT_EQ(Macros, N->getMacros().get());
|
2015-05-22 04:37:30 +08:00
|
|
|
EXPECT_EQ(DWOId, N->getDWOId());
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDICompileUnit Temp = N->clone();
|
2015-08-04 01:26:41 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_compile_unit, Temp->getTag());
|
|
|
|
EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage());
|
|
|
|
EXPECT_EQ(File, Temp->getFile());
|
|
|
|
EXPECT_EQ(Producer, Temp->getProducer());
|
|
|
|
EXPECT_EQ(IsOptimized, Temp->isOptimized());
|
|
|
|
EXPECT_EQ(Flags, Temp->getFlags());
|
|
|
|
EXPECT_EQ(RuntimeVersion, Temp->getRuntimeVersion());
|
|
|
|
EXPECT_EQ(SplitDebugFilename, Temp->getSplitDebugFilename());
|
|
|
|
EXPECT_EQ(EmissionKind, Temp->getEmissionKind());
|
|
|
|
EXPECT_EQ(EnumTypes, Temp->getEnumTypes().get());
|
|
|
|
EXPECT_EQ(RetainedTypes, Temp->getRetainedTypes().get());
|
|
|
|
EXPECT_EQ(GlobalVariables, Temp->getGlobalVariables().get());
|
|
|
|
EXPECT_EQ(ImportedEntities, Temp->getImportedEntities().get());
|
2015-12-10 20:56:35 +08:00
|
|
|
EXPECT_EQ(Macros, Temp->getMacros().get());
|
2015-08-04 01:26:41 +08:00
|
|
|
EXPECT_EQ(DWOId, Temp->getDWOId());
|
|
|
|
|
|
|
|
auto *TempAddress = Temp.get();
|
|
|
|
auto *Clone = MDNode::replaceWithPermanent(std::move(Temp));
|
|
|
|
EXPECT_TRUE(Clone->isDistinct());
|
|
|
|
EXPECT_EQ(TempAddress, Clone);
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DICompileUnitTest, replaceArrays) {
|
2015-02-19 04:36:09 +08:00
|
|
|
unsigned SourceLanguage = 1;
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-19 04:36:09 +08:00
|
|
|
StringRef Producer = "some producer";
|
|
|
|
bool IsOptimized = false;
|
|
|
|
StringRef Flags = "flag after flag";
|
|
|
|
unsigned RuntimeVersion = 2;
|
|
|
|
StringRef SplitDebugFilename = "another/file";
|
2016-04-01 07:56:58 +08:00
|
|
|
auto EmissionKind = DICompileUnit::FullDebug;
|
2015-03-28 07:05:04 +08:00
|
|
|
MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
|
|
|
|
MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
|
|
|
|
MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
|
2015-05-22 04:37:30 +08:00
|
|
|
uint64_t DWOId = 0xc0ffee;
|
2015-08-04 01:26:41 +08:00
|
|
|
auto *N = DICompileUnit::getDistinct(
|
2015-02-19 04:36:09 +08:00
|
|
|
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
|
|
|
|
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
|
2016-04-15 23:57:41 +08:00
|
|
|
RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId);
|
2015-02-19 04:36:09 +08:00
|
|
|
|
|
|
|
auto *GlobalVariables = MDTuple::getDistinct(Context, None);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getGlobalVariables().get());
|
2015-02-19 04:36:09 +08:00
|
|
|
N->replaceGlobalVariables(GlobalVariables);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
|
2015-02-19 04:36:09 +08:00
|
|
|
N->replaceGlobalVariables(nullptr);
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(nullptr, N->getGlobalVariables().get());
|
2015-12-10 20:56:35 +08:00
|
|
|
|
|
|
|
auto *Macros = MDTuple::getDistinct(Context, None);
|
|
|
|
EXPECT_EQ(nullptr, N->getMacros().get());
|
|
|
|
N->replaceMacros(Macros);
|
|
|
|
EXPECT_EQ(Macros, N->getMacros().get());
|
|
|
|
N->replaceMacros(nullptr);
|
|
|
|
EXPECT_EQ(nullptr, N->getMacros().get());
|
2015-02-19 04:36:09 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DISubprogramTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DISubprogramTest, get) {
|
2016-04-24 05:08:00 +08:00
|
|
|
DIScope *Scope = getCompositeType();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "name";
|
|
|
|
StringRef LinkageName = "linkage";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 2;
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubroutineType *Type = getSubroutineType();
|
2015-02-10 08:52:32 +08:00
|
|
|
bool IsLocalToUnit = false;
|
|
|
|
bool IsDefinition = true;
|
|
|
|
unsigned ScopeLine = 3;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *ContainingType = getCompositeType();
|
2016-04-14 04:17:42 +08:00
|
|
|
unsigned Virtuality = 2;
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned VirtualIndex = 5;
|
|
|
|
unsigned Flags = 6;
|
2016-04-14 04:17:42 +08:00
|
|
|
unsigned NotFlags = (~Flags) & ((1 << 27) - 1);
|
2015-02-10 08:52:32 +08:00
|
|
|
bool IsOptimized = false;
|
2015-03-31 00:19:15 +08:00
|
|
|
MDTuple *TemplateParams = getTuple();
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubprogram *Declaration = getSubprogram();
|
2015-03-31 00:19:15 +08:00
|
|
|
MDTuple *Variables = getTuple();
|
2016-04-15 23:57:41 +08:00
|
|
|
DICompileUnit *Unit = getUnit();
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DISubprogram::get(
|
2015-02-10 08:52:32 +08:00
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
|
2016-04-15 23:57:41 +08:00
|
|
|
IsOptimized, Unit, TemplateParams, Declaration, Variables);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(LinkageName, N->getLinkageName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
|
|
|
EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
|
|
|
|
EXPECT_EQ(IsDefinition, N->isDefinition());
|
|
|
|
EXPECT_EQ(ScopeLine, N->getScopeLine());
|
|
|
|
EXPECT_EQ(ContainingType, N->getContainingType());
|
|
|
|
EXPECT_EQ(Virtuality, N->getVirtuality());
|
|
|
|
EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
|
|
|
|
EXPECT_EQ(Flags, N->getFlags());
|
|
|
|
EXPECT_EQ(IsOptimized, N->isOptimized());
|
2016-04-15 23:57:41 +08:00
|
|
|
EXPECT_EQ(Unit, N->getUnit());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(Declaration, N->getDeclaration());
|
2015-04-08 00:50:39 +08:00
|
|
|
EXPECT_EQ(Variables, N->getVariables().get());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,
|
2015-03-31 00:19:15 +08:00
|
|
|
File, Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
ScopeLine, ContainingType, Virtuality,
|
2016-04-15 23:57:41 +08:00
|
|
|
VirtualIndex, Flags, IsOptimized, Unit,
|
2015-03-31 00:19:15 +08:00
|
|
|
TemplateParams, Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
ScopeLine, ContainingType, Virtuality,
|
2016-04-15 23:57:41 +08:00
|
|
|
VirtualIndex, Flags, IsOptimized, Unit,
|
2015-02-10 08:52:32 +08:00
|
|
|
TemplateParams, Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
|
2015-03-31 00:19:15 +08:00
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
ScopeLine, ContainingType, Virtuality,
|
2016-04-15 23:57:41 +08:00
|
|
|
VirtualIndex, Flags, IsOptimized, Unit,
|
2015-03-31 00:19:15 +08:00
|
|
|
TemplateParams, Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line + 1, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
ScopeLine, ContainingType, Virtuality,
|
2016-04-15 23:57:41 +08:00
|
|
|
VirtualIndex, Flags, IsOptimized, Unit,
|
2015-11-06 06:03:56 +08:00
|
|
|
TemplateParams, Declaration, Variables));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
getSubroutineType(), IsLocalToUnit,
|
|
|
|
IsDefinition, ScopeLine, ContainingType,
|
|
|
|
Virtuality, VirtualIndex, Flags, IsOptimized,
|
2016-04-15 23:57:41 +08:00
|
|
|
Unit, TemplateParams, Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, !IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, !IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition,
|
|
|
|
ScopeLine + 1, ContainingType, Virtuality,
|
2016-04-15 23:57:41 +08:00
|
|
|
VirtualIndex, Flags, IsOptimized, Unit,
|
2015-02-10 08:52:32 +08:00
|
|
|
TemplateParams, Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
2015-03-31 00:19:15 +08:00
|
|
|
getCompositeType(), Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality + 1, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex + 1,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
NotFlags, IsOptimized, Unit, TemplateParams,
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-04-12 04:27:40 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, !IsOptimized, Unit, TemplateParams,
|
|
|
|
Declaration, Variables));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
|
|
|
Flags, IsOptimized, nullptr, TemplateParams,
|
|
|
|
Declaration, Variables));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
|
|
|
Flags, IsOptimized, Unit, getTuple(),
|
2015-02-10 08:52:32 +08:00
|
|
|
Declaration, Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-03-31 00:19:15 +08:00
|
|
|
getSubprogram(), Variables));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, ScopeLine,
|
|
|
|
ContainingType, Virtuality, VirtualIndex,
|
2016-04-15 23:57:41 +08:00
|
|
|
Flags, IsOptimized, Unit, TemplateParams,
|
2015-03-31 00:19:15 +08:00
|
|
|
Declaration, getTuple()));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDISubprogram Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DILexicalBlockTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILexicalBlockTest, get) {
|
|
|
|
DILocalScope *Scope = getSubprogram();
|
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
|
|
|
unsigned Column = 8;
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DILexicalBlock::get(Context, Scope, File, Line, Column);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Column, N->getColumn());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DILexicalBlock::get(Context, Scope, File, Line, Column));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-03-31 00:37:48 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DILexicalBlock::get(Context, getSubprogram(), File, Line, Column));
|
|
|
|
EXPECT_NE(N, DILexicalBlock::get(Context, Scope, getFile(), Line, Column));
|
|
|
|
EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line + 1, Column));
|
|
|
|
EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line, Column + 1));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDILexicalBlock Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-08-29 06:58:50 +08:00
|
|
|
TEST_F(DILexicalBlockTest, Overflow) {
|
|
|
|
DISubprogram *SP = getSubprogram();
|
|
|
|
DIFile *F = getFile();
|
|
|
|
{
|
|
|
|
auto *LB = DILexicalBlock::get(Context, SP, F, 2, 7);
|
|
|
|
EXPECT_EQ(2u, LB->getLine());
|
|
|
|
EXPECT_EQ(7u, LB->getColumn());
|
|
|
|
}
|
|
|
|
unsigned U16 = 1u << 16;
|
|
|
|
{
|
|
|
|
auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16 - 1);
|
|
|
|
EXPECT_EQ(UINT32_MAX, LB->getLine());
|
|
|
|
EXPECT_EQ(U16 - 1, LB->getColumn());
|
|
|
|
}
|
|
|
|
{
|
|
|
|
auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16);
|
|
|
|
EXPECT_EQ(UINT32_MAX, LB->getLine());
|
|
|
|
EXPECT_EQ(0u, LB->getColumn());
|
|
|
|
}
|
|
|
|
{
|
|
|
|
auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16 + 1);
|
|
|
|
EXPECT_EQ(UINT32_MAX, LB->getLine());
|
|
|
|
EXPECT_EQ(0u, LB->getColumn());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DILexicalBlockFileTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILexicalBlockFileTest, get) {
|
|
|
|
DILocalScope *Scope = getSubprogram();
|
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Discriminator = 5;
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DILexicalBlockFile::get(Context, Scope, File, Discriminator);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Discriminator, N->getDiscriminator());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DILexicalBlockFile::get(Context, Scope, File, Discriminator));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DILexicalBlockFile::get(Context, getSubprogram(), File,
|
2015-03-31 00:37:48 +08:00
|
|
|
Discriminator));
|
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DILexicalBlockFile::get(Context, Scope, getFile(), Discriminator));
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DILexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDILexicalBlockFile Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DINamespaceTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DINamespaceTest, get) {
|
|
|
|
DIScope *Scope = getFile();
|
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "namespace";
|
|
|
|
unsigned Line = 5;
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DINamespace::get(Context, Scope, File, Name, Line);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DINamespace::get(Context, Scope, File, Name, Line));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DINamespace::get(Context, getFile(), File, Name, Line));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, Scope, getFile(), Name, Line));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, Scope, File, "other", Line));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, Scope, File, Name, Line + 1));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDINamespace Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-06-30 07:03:47 +08:00
|
|
|
typedef MetadataTest DIModuleTest;
|
|
|
|
|
|
|
|
TEST_F(DIModuleTest, get) {
|
|
|
|
DIScope *Scope = getFile();
|
|
|
|
StringRef Name = "module";
|
|
|
|
StringRef ConfigMacro = "-DNDEBUG";
|
|
|
|
StringRef Includes = "-I.";
|
|
|
|
StringRef Sysroot = "/";
|
|
|
|
|
|
|
|
auto *N = DIModule::get(Context, Scope, Name, ConfigMacro, Includes, Sysroot);
|
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_module, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(ConfigMacro, N->getConfigurationMacros());
|
|
|
|
EXPECT_EQ(Includes, N->getIncludePath());
|
|
|
|
EXPECT_EQ(Sysroot, N->getISysRoot());
|
|
|
|
EXPECT_EQ(N, DIModule::get(Context, Scope, Name,
|
|
|
|
ConfigMacro, Includes, Sysroot));
|
|
|
|
EXPECT_NE(N, DIModule::get(Context, getFile(), Name,
|
|
|
|
ConfigMacro, Includes, Sysroot));
|
|
|
|
EXPECT_NE(N, DIModule::get(Context, Scope, "other",
|
|
|
|
ConfigMacro, Includes, Sysroot));
|
|
|
|
EXPECT_NE(N, DIModule::get(Context, Scope, Name,
|
|
|
|
"other", Includes, Sysroot));
|
|
|
|
EXPECT_NE(N, DIModule::get(Context, Scope, Name,
|
|
|
|
ConfigMacro, "other", Sysroot));
|
|
|
|
EXPECT_NE(N, DIModule::get(Context, Scope, Name,
|
|
|
|
ConfigMacro, Includes, "other"));
|
|
|
|
|
|
|
|
TempDIModule Temp = N->clone();
|
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DITemplateTypeParameterTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DITemplateTypeParameterTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "template";
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *Type = getBasicType("basic");
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DITemplateTypeParameter::get(Context, Name, Type);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DITemplateTypeParameter::get(Context, Name, Type));
|
2015-02-10 09:59:57 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DITemplateTypeParameter::get(Context, "other", Type));
|
2015-03-31 01:21:38 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DITemplateTypeParameter::get(Context, Name, getBasicType("other")));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDITemplateTypeParameter Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DITemplateValueParameterTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DITemplateValueParameterTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Tag = dwarf::DW_TAG_template_value_parameter;
|
|
|
|
StringRef Name = "template";
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *Type = getBasicType("basic");
|
2015-03-31 01:21:38 +08:00
|
|
|
Metadata *Value = getConstantAsMetadata();
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DITemplateValueParameter::get(Context, Tag, Name, Type, Value);
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(Tag, N->getTag());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
|
|
|
EXPECT_EQ(Value, N->getValue());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DITemplateValueParameter::get(Context, Tag, Name, Type, Value));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DITemplateValueParameter::get(
|
2015-02-19 08:37:21 +08:00
|
|
|
Context, dwarf::DW_TAG_GNU_template_template_param, Name,
|
|
|
|
Type, Value));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N,
|
|
|
|
DITemplateValueParameter::get(Context, Tag, "other", Type, Value));
|
|
|
|
EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name,
|
2015-03-31 01:21:38 +08:00
|
|
|
getBasicType("other"), Value));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name, Type,
|
2015-03-31 01:21:38 +08:00
|
|
|
getConstantAsMetadata()));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDITemplateValueParameter Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIGlobalVariableTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIGlobalVariableTest, get) {
|
|
|
|
DIScope *Scope = getSubprogram();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "name";
|
|
|
|
StringRef LinkageName = "linkage";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *Type = getDerivedType();
|
2015-02-10 08:52:32 +08:00
|
|
|
bool IsLocalToUnit = false;
|
|
|
|
bool IsDefinition = true;
|
2015-04-12 04:27:40 +08:00
|
|
|
Constant *Variable = getConstant();
|
2015-04-30 00:38:44 +08:00
|
|
|
DIDerivedType *StaticDataMemberDeclaration =
|
|
|
|
cast<DIDerivedType>(getDerivedType());
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, Variable,
|
|
|
|
StaticDataMemberDeclaration);
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(LinkageName, N->getLinkageName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
|
|
|
EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
|
|
|
|
EXPECT_EQ(IsDefinition, N->isDefinition());
|
|
|
|
EXPECT_EQ(Variable, N->getVariable());
|
|
|
|
EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
|
|
|
|
2015-03-28 01:29:58 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, getSubprogram(), Name, LinkageName,
|
2015-03-28 01:29:58 +08:00
|
|
|
File, Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,
|
2015-02-10 08:52:32 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-03-28 01:29:58 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, Scope, Name, LinkageName, getFile(),
|
2015-03-28 01:29:58 +08:00
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line + 1, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-07 03:03:45 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-04-07 03:03:45 +08:00
|
|
|
getDerivedType(), IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line, Type, !IsLocalToUnit, IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
2015-02-10 08:52:32 +08:00
|
|
|
Line, Type, IsLocalToUnit, !IsDefinition,
|
|
|
|
Variable, StaticDataMemberDeclaration));
|
2015-04-12 04:27:40 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-04-12 04:27:40 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition,
|
|
|
|
getConstant(), StaticDataMemberDeclaration));
|
2015-04-07 03:03:45 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
|
2015-04-07 03:03:45 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition, Variable,
|
2015-04-30 00:38:44 +08:00
|
|
|
cast<DIDerivedType>(getDerivedType())));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIGlobalVariable Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DILocalVariableTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILocalVariableTest, get) {
|
|
|
|
DILocalScope *Scope = getSubprogram();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "name";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *Type = getDerivedType();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Arg = 6;
|
|
|
|
unsigned Flags = 7;
|
2016-04-16 11:23:48 +08:00
|
|
|
unsigned NotFlags = (~Flags) & ((1 << 16) - 1);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-08-01 02:58:39 +08:00
|
|
|
auto *N =
|
|
|
|
DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg, Flags);
|
|
|
|
EXPECT_TRUE(N->isParameter());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
|
|
|
EXPECT_EQ(Arg, N->getArg());
|
|
|
|
EXPECT_EQ(Flags, N->getFlags());
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg,
|
|
|
|
Flags));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_FALSE(
|
|
|
|
DILocalVariable::get(Context, Scope, Name, File, Line, Type, 0, Flags)
|
|
|
|
->isParameter());
|
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, getSubprogram(), Name, File, Line,
|
2015-04-16 06:29:27 +08:00
|
|
|
Type, Arg, Flags));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, "other", File, Line, Type,
|
|
|
|
Arg, Flags));
|
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, getFile(), Line, Type,
|
|
|
|
Arg, Flags));
|
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line + 1, Type,
|
|
|
|
Arg, Flags));
|
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line,
|
2015-04-16 06:29:27 +08:00
|
|
|
getDerivedType(), Arg, Flags));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type,
|
2015-04-16 06:29:27 +08:00
|
|
|
Arg + 1, Flags));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg,
|
2016-04-16 11:23:48 +08:00
|
|
|
NotFlags));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDILocalVariable Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DILocalVariableTest, getArg256) {
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(255u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
|
|
|
|
0, nullptr, 255, 0)
|
2015-04-28 09:07:33 +08:00
|
|
|
->getArg());
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(256u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
|
|
|
|
0, nullptr, 256, 0)
|
2015-04-28 09:07:33 +08:00
|
|
|
->getArg());
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(257u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
|
|
|
|
0, nullptr, 257, 0)
|
2015-04-28 09:07:33 +08:00
|
|
|
->getArg());
|
|
|
|
unsigned Max = UINT16_MAX;
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(Max, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
|
|
|
|
0, nullptr, Max, 0)
|
2015-04-28 09:07:33 +08:00
|
|
|
->getArg());
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIExpressionTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIExpressionTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
uint64_t Elements[] = {2, 6, 9, 78, 0};
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIExpression::get(Context, Elements);
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(makeArrayRef(Elements), N->getElements());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIExpression::get(Context, Elements));
|
2015-02-10 09:36:46 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(5u, N->getNumElements());
|
|
|
|
EXPECT_EQ(2u, N->getElement(0));
|
|
|
|
EXPECT_EQ(6u, N->getElement(1));
|
|
|
|
EXPECT_EQ(9u, N->getElement(2));
|
|
|
|
EXPECT_EQ(78u, N->getElement(3));
|
|
|
|
EXPECT_EQ(0u, N->getElement(4));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIExpression Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIExpressionTest, isValid) {
|
2015-02-13 09:07:46 +08:00
|
|
|
#define EXPECT_VALID(...) \
|
|
|
|
do { \
|
|
|
|
uint64_t Elements[] = {__VA_ARGS__}; \
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_TRUE(DIExpression::get(Context, Elements)->isValid()); \
|
2015-02-13 09:07:46 +08:00
|
|
|
} while (false)
|
|
|
|
#define EXPECT_INVALID(...) \
|
|
|
|
do { \
|
|
|
|
uint64_t Elements[] = {__VA_ARGS__}; \
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_FALSE(DIExpression::get(Context, Elements)->isValid()); \
|
2015-02-13 09:07:46 +08:00
|
|
|
} while (false)
|
|
|
|
|
|
|
|
// Empty expression should be valid.
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_TRUE(DIExpression::get(Context, None));
|
2015-02-13 09:07:46 +08:00
|
|
|
|
|
|
|
// Valid constructions.
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_plus, 6);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_bit_piece, 3, 7);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_plus, 6, dwarf::DW_OP_deref);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_bit_piece, 3, 7);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6, dwarf::DW_OP_bit_piece, 3, 7);
|
|
|
|
|
|
|
|
// Invalid constructions.
|
|
|
|
EXPECT_INVALID(~0u);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_plus);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_bit_piece);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_plus, 3);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_deref);
|
|
|
|
|
|
|
|
#undef EXPECT_VALID
|
|
|
|
#undef EXPECT_INVALID
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIObjCPropertyTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIObjCPropertyTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "name";
|
2015-04-30 00:38:44 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
|
|
|
StringRef GetterName = "getter";
|
|
|
|
StringRef SetterName = "setter";
|
|
|
|
unsigned Attributes = 7;
|
2016-04-24 05:08:00 +08:00
|
|
|
DIType *Type = getBasicType("basic");
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIObjCProperty::get(Context, Name, File, Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type);
|
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
|
|
|
EXPECT_EQ(File, N->getFile());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(GetterName, N->getGetterName());
|
|
|
|
EXPECT_EQ(SetterName, N->getSetterName());
|
|
|
|
EXPECT_EQ(Attributes, N->getAttributes());
|
|
|
|
EXPECT_EQ(Type, N->getType());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, "other", File, Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, getFile(), Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line + 1, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, "other",
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
"other", Attributes, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
|
2015-02-10 08:52:32 +08:00
|
|
|
SetterName, Attributes + 1, Type));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
|
2015-04-07 03:03:45 +08:00
|
|
|
SetterName, Attributes,
|
2015-06-16 07:18:03 +08:00
|
|
|
getBasicType("other")));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIObjCProperty Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
typedef MetadataTest DIImportedEntityTest;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TEST_F(DIImportedEntityTest, get) {
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Tag = dwarf::DW_TAG_imported_module;
|
2015-04-30 00:38:44 +08:00
|
|
|
DIScope *Scope = getSubprogram();
|
2016-04-24 05:08:00 +08:00
|
|
|
DINode *Entity = getCompositeType();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
|
|
|
StringRef Name = "name";
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
auto *N = DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(Tag, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Entity, N->getEntity());
|
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
|
2015-02-10 08:52:32 +08:00
|
|
|
Scope, Entity, Line, Name));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, getSubprogram(), Entity,
|
2015-03-31 01:21:38 +08:00
|
|
|
Line, Name));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, getCompositeType(),
|
2015-03-31 01:21:38 +08:00
|
|
|
Line, Name));
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_NE(N,
|
2015-04-30 00:38:44 +08:00
|
|
|
DIImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));
|
2015-02-18 07:10:13 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
TempDIImportedEntity Temp = N->clone();
|
2015-02-18 07:10:13 +08:00
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
typedef MetadataTest MetadataAsValueTest;
|
|
|
|
|
|
|
|
TEST_F(MetadataAsValueTest, MDNode) {
|
|
|
|
MDNode *N = MDNode::get(Context, None);
|
|
|
|
auto *V = MetadataAsValue::get(Context, N);
|
|
|
|
EXPECT_TRUE(V->getType()->isMetadataTy());
|
|
|
|
EXPECT_EQ(N, V->getMetadata());
|
|
|
|
|
|
|
|
auto *V2 = MetadataAsValue::get(Context, N);
|
|
|
|
EXPECT_EQ(V, V2);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MetadataAsValueTest, MDNodeMDNode) {
|
|
|
|
MDNode *N = MDNode::get(Context, None);
|
|
|
|
Metadata *Ops[] = {N};
|
|
|
|
MDNode *N2 = MDNode::get(Context, Ops);
|
|
|
|
auto *V = MetadataAsValue::get(Context, N2);
|
|
|
|
EXPECT_TRUE(V->getType()->isMetadataTy());
|
|
|
|
EXPECT_EQ(N2, V->getMetadata());
|
|
|
|
|
|
|
|
auto *V2 = MetadataAsValue::get(Context, N2);
|
|
|
|
EXPECT_EQ(V, V2);
|
|
|
|
|
|
|
|
auto *V3 = MetadataAsValue::get(Context, N);
|
|
|
|
EXPECT_TRUE(V3->getType()->isMetadataTy());
|
|
|
|
EXPECT_NE(V, V3);
|
|
|
|
EXPECT_EQ(N, V3->getMetadata());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MetadataAsValueTest, MDNodeConstant) {
|
|
|
|
auto *C = ConstantInt::getTrue(Context);
|
|
|
|
auto *MD = ConstantAsMetadata::get(C);
|
|
|
|
Metadata *Ops[] = {MD};
|
|
|
|
auto *N = MDNode::get(Context, Ops);
|
|
|
|
|
|
|
|
auto *V = MetadataAsValue::get(Context, MD);
|
|
|
|
EXPECT_TRUE(V->getType()->isMetadataTy());
|
|
|
|
EXPECT_EQ(MD, V->getMetadata());
|
|
|
|
|
|
|
|
auto *V2 = MetadataAsValue::get(Context, N);
|
|
|
|
EXPECT_EQ(MD, V2->getMetadata());
|
|
|
|
EXPECT_EQ(V, V2);
|
|
|
|
}
|
|
|
|
|
2014-12-13 03:24:33 +08:00
|
|
|
typedef MetadataTest ValueAsMetadataTest;
|
|
|
|
|
|
|
|
TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
|
|
|
|
Type *Ty = Type::getInt1PtrTy(Context);
|
|
|
|
std::unique_ptr<GlobalVariable> GV0(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
auto *MD = ValueAsMetadata::get(GV0.get());
|
|
|
|
EXPECT_TRUE(MD->getValue() == GV0.get());
|
|
|
|
ASSERT_TRUE(GV0->use_empty());
|
|
|
|
|
|
|
|
std::unique_ptr<GlobalVariable> GV1(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
GV0->replaceAllUsesWith(GV1.get());
|
|
|
|
EXPECT_TRUE(MD->getValue() == GV1.get());
|
|
|
|
}
|
|
|
|
|
2016-02-09 01:02:34 +08:00
|
|
|
TEST_F(ValueAsMetadataTest, TempTempReplacement) {
|
|
|
|
// Create a constant.
|
2016-04-15 05:59:01 +08:00
|
|
|
ConstantAsMetadata *CI =
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
|
2016-02-09 01:02:34 +08:00
|
|
|
|
|
|
|
auto Temp1 = MDTuple::getTemporary(Context, None);
|
2016-02-09 03:13:15 +08:00
|
|
|
auto Temp2 = MDTuple::getTemporary(Context, {CI});
|
|
|
|
auto *N = MDTuple::get(Context, {Temp1.get()});
|
2016-02-09 01:02:34 +08:00
|
|
|
|
|
|
|
// Test replacing a temporary node with another temporary node.
|
|
|
|
Temp1->replaceAllUsesWith(Temp2.get());
|
|
|
|
EXPECT_EQ(N->getOperand(0), Temp2.get());
|
|
|
|
|
|
|
|
// Clean up Temp2 for teardown.
|
|
|
|
Temp2->replaceAllUsesWith(nullptr);
|
|
|
|
}
|
|
|
|
|
2015-01-15 03:56:10 +08:00
|
|
|
TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
|
|
|
|
// Create a constant.
|
2016-04-15 05:59:01 +08:00
|
|
|
ConstantAsMetadata *CI =
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
|
2015-01-15 03:56:10 +08:00
|
|
|
|
|
|
|
// Create a temporary to prevent nodes from resolving.
|
2015-01-20 05:30:18 +08:00
|
|
|
auto Temp = MDTuple::getTemporary(Context, None);
|
2015-01-15 03:56:10 +08:00
|
|
|
|
|
|
|
// When the first operand of N1 gets reset to nullptr, it'll collide with N2.
|
2015-01-20 05:30:18 +08:00
|
|
|
Metadata *Ops1[] = {CI, CI, Temp.get()};
|
|
|
|
Metadata *Ops2[] = {nullptr, CI, Temp.get()};
|
2015-01-15 03:56:10 +08:00
|
|
|
|
|
|
|
auto *N1 = MDTuple::get(Context, Ops1);
|
|
|
|
auto *N2 = MDTuple::get(Context, Ops2);
|
|
|
|
ASSERT_NE(N1, N2);
|
|
|
|
|
|
|
|
// Tell metadata that the constant is getting deleted.
|
|
|
|
//
|
|
|
|
// After this, N1 will be invalid, so don't touch it.
|
|
|
|
ValueAsMetadata::handleDeletion(CI->getValue());
|
|
|
|
EXPECT_EQ(nullptr, N2->getOperand(0));
|
|
|
|
EXPECT_EQ(nullptr, N2->getOperand(1));
|
2015-01-20 05:30:18 +08:00
|
|
|
EXPECT_EQ(Temp.get(), N2->getOperand(2));
|
2015-01-15 03:56:10 +08:00
|
|
|
|
|
|
|
// Clean up Temp for teardown.
|
|
|
|
Temp->replaceAllUsesWith(nullptr);
|
|
|
|
}
|
|
|
|
|
2014-12-13 03:24:33 +08:00
|
|
|
typedef MetadataTest TrackingMDRefTest;
|
|
|
|
|
|
|
|
TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
|
|
|
|
Type *Ty = Type::getInt1PtrTy(Context);
|
|
|
|
std::unique_ptr<GlobalVariable> GV0(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
|
|
|
|
EXPECT_TRUE(MD->getValue() == GV0.get());
|
|
|
|
ASSERT_TRUE(GV0->use_empty());
|
|
|
|
|
|
|
|
std::unique_ptr<GlobalVariable> GV1(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
GV0->replaceAllUsesWith(GV1.get());
|
|
|
|
EXPECT_TRUE(MD->getValue() == GV1.get());
|
|
|
|
|
|
|
|
// Reset it, so we don't inadvertently test deletion.
|
|
|
|
MD.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
|
|
|
|
Type *Ty = Type::getInt1PtrTy(Context);
|
|
|
|
std::unique_ptr<GlobalVariable> GV(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
|
|
|
|
EXPECT_TRUE(MD->getValue() == GV.get());
|
|
|
|
ASSERT_TRUE(GV->use_empty());
|
|
|
|
|
|
|
|
GV.reset();
|
|
|
|
EXPECT_TRUE(!MD);
|
|
|
|
}
|
|
|
|
|
2009-07-30 08:03:41 +08:00
|
|
|
TEST(NamedMDNodeTest, Search) {
|
2010-03-05 07:24:19 +08:00
|
|
|
LLVMContext Context;
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
ConstantAsMetadata *C =
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
|
|
|
|
ConstantAsMetadata *C2 =
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
|
2009-07-30 08:03:41 +08:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
Metadata *const V = C;
|
|
|
|
Metadata *const V2 = C2;
|
2011-04-22 03:59:31 +08:00
|
|
|
MDNode *n = MDNode::get(Context, V);
|
|
|
|
MDNode *n2 = MDNode::get(Context, V2);
|
2009-07-30 08:03:41 +08:00
|
|
|
|
2010-03-13 09:39:20 +08:00
|
|
|
Module M("MyModule", Context);
|
2009-07-30 08:03:41 +08:00
|
|
|
const char *Name = "llvm.NMD1";
|
2010-07-22 07:38:33 +08:00
|
|
|
NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
|
|
|
|
NMD->addOperand(n);
|
|
|
|
NMD->addOperand(n2);
|
|
|
|
|
2009-08-23 12:47:35 +08:00
|
|
|
std::string Str;
|
|
|
|
raw_string_ostream oss(Str);
|
2009-07-30 08:03:41 +08:00
|
|
|
NMD->print(oss);
|
2009-12-31 10:12:13 +08:00
|
|
|
EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
|
2009-07-30 08:03:41 +08:00
|
|
|
oss.str().c_str());
|
|
|
|
}
|
2015-04-25 05:51:02 +08:00
|
|
|
|
|
|
|
typedef MetadataTest FunctionAttachmentTest;
|
|
|
|
TEST_F(FunctionAttachmentTest, setMetadata) {
|
|
|
|
Function *F = getFunction("foo");
|
|
|
|
ASSERT_FALSE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("dbg"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other"));
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubprogram *SP1 = getSubprogram();
|
|
|
|
DISubprogram *SP2 = getSubprogram();
|
2015-04-25 05:51:02 +08:00
|
|
|
ASSERT_NE(SP1, SP2);
|
|
|
|
|
|
|
|
F->setMetadata("dbg", SP1);
|
|
|
|
EXPECT_TRUE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(SP1, F->getMetadata(LLVMContext::MD_dbg));
|
|
|
|
EXPECT_EQ(SP1, F->getMetadata("dbg"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other"));
|
|
|
|
|
|
|
|
F->setMetadata(LLVMContext::MD_dbg, SP2);
|
|
|
|
EXPECT_TRUE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(SP2, F->getMetadata(LLVMContext::MD_dbg));
|
|
|
|
EXPECT_EQ(SP2, F->getMetadata("dbg"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other"));
|
|
|
|
|
|
|
|
F->setMetadata("dbg", nullptr);
|
|
|
|
EXPECT_FALSE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("dbg"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other"));
|
|
|
|
|
|
|
|
MDTuple *T1 = getTuple();
|
|
|
|
MDTuple *T2 = getTuple();
|
|
|
|
ASSERT_NE(T1, T2);
|
|
|
|
|
|
|
|
F->setMetadata("other1", T1);
|
|
|
|
F->setMetadata("other2", T2);
|
|
|
|
EXPECT_TRUE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(T1, F->getMetadata("other1"));
|
|
|
|
EXPECT_EQ(T2, F->getMetadata("other2"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("dbg"));
|
|
|
|
|
|
|
|
F->setMetadata("other1", T2);
|
|
|
|
F->setMetadata("other2", T1);
|
|
|
|
EXPECT_EQ(T2, F->getMetadata("other1"));
|
|
|
|
EXPECT_EQ(T1, F->getMetadata("other2"));
|
|
|
|
|
|
|
|
F->setMetadata("other1", nullptr);
|
|
|
|
F->setMetadata("other2", nullptr);
|
|
|
|
EXPECT_FALSE(F->hasMetadata());
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other1"));
|
|
|
|
EXPECT_EQ(nullptr, F->getMetadata("other2"));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(FunctionAttachmentTest, getAll) {
|
|
|
|
Function *F = getFunction("foo");
|
|
|
|
|
|
|
|
MDTuple *T1 = getTuple();
|
|
|
|
MDTuple *T2 = getTuple();
|
|
|
|
MDTuple *P = getTuple();
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubprogram *SP = getSubprogram();
|
2015-04-25 05:51:02 +08:00
|
|
|
|
|
|
|
F->setMetadata("other1", T2);
|
|
|
|
F->setMetadata(LLVMContext::MD_dbg, SP);
|
|
|
|
F->setMetadata("other2", T1);
|
|
|
|
F->setMetadata(LLVMContext::MD_prof, P);
|
|
|
|
F->setMetadata("other2", T2);
|
|
|
|
F->setMetadata("other1", T1);
|
|
|
|
|
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
|
|
|
F->getAllMetadata(MDs);
|
|
|
|
ASSERT_EQ(4u, MDs.size());
|
|
|
|
EXPECT_EQ(LLVMContext::MD_dbg, MDs[0].first);
|
|
|
|
EXPECT_EQ(LLVMContext::MD_prof, MDs[1].first);
|
|
|
|
EXPECT_EQ(Context.getMDKindID("other1"), MDs[2].first);
|
|
|
|
EXPECT_EQ(Context.getMDKindID("other2"), MDs[3].first);
|
|
|
|
EXPECT_EQ(SP, MDs[0].second);
|
|
|
|
EXPECT_EQ(P, MDs[1].second);
|
|
|
|
EXPECT_EQ(T1, MDs[2].second);
|
|
|
|
EXPECT_EQ(T2, MDs[3].second);
|
|
|
|
}
|
|
|
|
|
2015-04-25 05:53:27 +08:00
|
|
|
TEST_F(FunctionAttachmentTest, Verifier) {
|
|
|
|
Function *F = getFunction("foo");
|
|
|
|
F->setMetadata("attach", getTuple());
|
2016-06-22 07:42:48 +08:00
|
|
|
F->setIsMaterializable(true);
|
2015-04-25 05:53:27 +08:00
|
|
|
|
2016-06-22 07:42:48 +08:00
|
|
|
// Confirm this is materializable.
|
|
|
|
ASSERT_TRUE(F->isMaterializable());
|
2015-04-25 05:53:27 +08:00
|
|
|
|
2016-06-22 07:42:48 +08:00
|
|
|
// Materializable functions cannot have metadata attachments.
|
|
|
|
EXPECT_TRUE(verifyFunction(*F));
|
2016-06-07 07:21:27 +08:00
|
|
|
|
2016-06-22 07:42:48 +08:00
|
|
|
// Function declarations can.
|
2016-06-07 07:21:27 +08:00
|
|
|
F->setIsMaterializable(false);
|
2016-06-22 07:42:48 +08:00
|
|
|
EXPECT_FALSE(verifyModule(*F->getParent()));
|
|
|
|
EXPECT_FALSE(verifyFunction(*F));
|
|
|
|
|
|
|
|
// So can definitions.
|
2015-04-25 05:53:27 +08:00
|
|
|
(void)new UnreachableInst(Context, BasicBlock::Create(Context, "bb", F));
|
|
|
|
EXPECT_FALSE(verifyModule(*F->getParent()));
|
|
|
|
EXPECT_FALSE(verifyFunction(*F));
|
|
|
|
}
|
|
|
|
|
2015-05-13 23:13:45 +08:00
|
|
|
TEST_F(FunctionAttachmentTest, EntryCount) {
|
|
|
|
Function *F = getFunction("foo");
|
|
|
|
EXPECT_FALSE(F->getEntryCount().hasValue());
|
|
|
|
F->setEntryCount(12304);
|
|
|
|
EXPECT_TRUE(F->getEntryCount().hasValue());
|
|
|
|
EXPECT_EQ(12304u, *F->getEntryCount());
|
|
|
|
}
|
|
|
|
|
2015-08-29 05:55:35 +08:00
|
|
|
TEST_F(FunctionAttachmentTest, SubprogramAttachment) {
|
|
|
|
Function *F = getFunction("foo");
|
|
|
|
DISubprogram *SP = getSubprogram();
|
|
|
|
F->setSubprogram(SP);
|
|
|
|
|
|
|
|
// Note that the static_cast confirms that F->getSubprogram() actually
|
|
|
|
// returns an DISubprogram.
|
|
|
|
EXPECT_EQ(SP, static_cast<DISubprogram *>(F->getSubprogram()));
|
|
|
|
EXPECT_EQ(SP, F->getMetadata("dbg"));
|
|
|
|
EXPECT_EQ(SP, F->getMetadata(LLVMContext::MD_dbg));
|
|
|
|
}
|
|
|
|
|
2016-04-23 12:15:56 +08:00
|
|
|
typedef MetadataTest DistinctMDOperandPlaceholderTest;
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, getID) {
|
|
|
|
EXPECT_EQ(7u, DistinctMDOperandPlaceholder(7).getID());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, replaceUseWith) {
|
|
|
|
// Set up some placeholders.
|
|
|
|
DistinctMDOperandPlaceholder PH0(7);
|
|
|
|
DistinctMDOperandPlaceholder PH1(3);
|
|
|
|
DistinctMDOperandPlaceholder PH2(0);
|
|
|
|
Metadata *Ops[] = {&PH0, &PH1, &PH2};
|
|
|
|
auto *D = MDTuple::getDistinct(Context, Ops);
|
|
|
|
ASSERT_EQ(&PH0, D->getOperand(0));
|
|
|
|
ASSERT_EQ(&PH1, D->getOperand(1));
|
|
|
|
ASSERT_EQ(&PH2, D->getOperand(2));
|
|
|
|
|
|
|
|
// Replace them.
|
|
|
|
auto *N0 = MDTuple::get(Context, None);
|
|
|
|
auto *N1 = MDTuple::get(Context, N0);
|
|
|
|
PH0.replaceUseWith(N0);
|
|
|
|
PH1.replaceUseWith(N1);
|
|
|
|
PH2.replaceUseWith(nullptr);
|
|
|
|
EXPECT_EQ(N0, D->getOperand(0));
|
|
|
|
EXPECT_EQ(N1, D->getOperand(1));
|
|
|
|
EXPECT_EQ(nullptr, D->getOperand(2));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, replaceUseWithNoUser) {
|
|
|
|
// There is no user, but we can still call replace.
|
|
|
|
DistinctMDOperandPlaceholder(7).replaceUseWith(MDTuple::get(Context, None));
|
|
|
|
}
|
|
|
|
|
2016-04-23 12:34:11 +08:00
|
|
|
#ifndef NDEBUG
|
2016-04-23 12:15:56 +08:00
|
|
|
#ifdef GTEST_HAS_DEATH_TEST
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, MetadataAsValue) {
|
|
|
|
// This shouldn't crash.
|
|
|
|
DistinctMDOperandPlaceholder PH(7);
|
|
|
|
EXPECT_DEATH(MetadataAsValue::get(Context, &PH),
|
|
|
|
"Unexpected callback to owner");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, UniquedMDNode) {
|
|
|
|
// This shouldn't crash.
|
|
|
|
DistinctMDOperandPlaceholder PH(7);
|
|
|
|
EXPECT_DEATH(MDTuple::get(Context, &PH), "Unexpected callback to owner");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, SecondDistinctMDNode) {
|
|
|
|
// This shouldn't crash.
|
|
|
|
DistinctMDOperandPlaceholder PH(7);
|
|
|
|
MDTuple::getDistinct(Context, &PH);
|
|
|
|
EXPECT_DEATH(MDTuple::getDistinct(Context, &PH),
|
|
|
|
"Placeholders can only be used once");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DistinctMDOperandPlaceholderTest, TrackingMDRefAndDistinctMDNode) {
|
|
|
|
// TrackingMDRef doesn't install an owner callback, so it can't be detected
|
|
|
|
// as an invalid use. However, using a placeholder in a TrackingMDRef *and*
|
|
|
|
// a distinct node isn't possible and we should assert.
|
|
|
|
//
|
|
|
|
// (There's no positive test for using TrackingMDRef because it's not a
|
|
|
|
// useful thing to do.)
|
|
|
|
{
|
|
|
|
DistinctMDOperandPlaceholder PH(7);
|
|
|
|
MDTuple::getDistinct(Context, &PH);
|
|
|
|
EXPECT_DEATH(TrackingMDRef Ref(&PH), "Placeholders can only be used once");
|
|
|
|
}
|
|
|
|
{
|
|
|
|
DistinctMDOperandPlaceholder PH(7);
|
|
|
|
TrackingMDRef Ref(&PH);
|
|
|
|
EXPECT_DEATH(MDTuple::getDistinct(Context, &PH),
|
|
|
|
"Placeholders can only be used once");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2016-04-23 12:34:11 +08:00
|
|
|
#endif
|
2016-04-23 12:15:56 +08:00
|
|
|
|
2016-04-23 12:02:39 +08:00
|
|
|
} // end namespace
|