2015-02-03 02:20:15 +08:00
|
|
|
//===- unittests/IR/MetadataTest.cpp - Metadata unit tests ----------------===//
|
2009-04-04 15:22:01 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2009-04-04 15:22:01 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-06 19:06:56 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
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"
|
|
|
|
#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-09-07 01:03:02 +08:00
|
|
|
return DISubroutineType::getDistinct(Context, DINode::FlagZero, 0,
|
|
|
|
getNode(nullptr));
|
2015-03-31 00:19:15 +08:00
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
DISubprogram *getSubprogram() {
|
2018-11-20 02:29:28 +08:00
|
|
|
return DISubprogram::getDistinct(
|
|
|
|
Context, nullptr, "", "", nullptr, 0, nullptr, 0, nullptr, 0, 0,
|
|
|
|
DINode::FlagZero, DISubprogram::SPFlagZero, 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() {
|
2017-09-13 05:50:41 +08:00
|
|
|
return DICompileUnit::getDistinct(
|
|
|
|
Context, 1, getFile(), "clang", false, "-g", 2, "",
|
|
|
|
DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
|
2018-08-17 05:29:55 +08:00
|
|
|
getTuple(), getTuple(), 0, true, false,
|
2018-11-14 04:08:10 +08:00
|
|
|
DICompileUnit::DebugNameTableKind::Default, false);
|
2016-04-15 23:57:41 +08:00
|
|
|
}
|
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() {
|
2016-09-07 01:03:02 +08:00
|
|
|
return DIDerivedType::getDistinct(
|
|
|
|
Context, dwarf::DW_TAG_pointer_type, "", nullptr, 0, nullptr,
|
2017-03-09 07:55:44 +08:00
|
|
|
getBasicType("basictype"), 1, 2, 0, None, DINode::FlagZero);
|
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,
|
2016-09-06 18:46:28 +08:00
|
|
|
32, 32, 0, DINode::FlagZero, nullptr, 0, nullptr, nullptr, "");
|
2015-03-28 07:05:04 +08:00
|
|
|
}
|
2015-04-12 04:27:40 +08:00
|
|
|
Function *getFunction(StringRef Name) {
|
[opaque pointer types] Add a FunctionCallee wrapper type, and use it.
Recommit r352791 after tweaking DerivedTypes.h slightly, so that gcc
doesn't choke on it, hopefully.
Original Message:
The FunctionCallee type is effectively a {FunctionType*,Value*} pair,
and is a useful convenience to enable code to continue passing the
result of getOrInsertFunction() through to EmitCall, even once pointer
types lose their pointee-type.
Then:
- update the CallInst/InvokeInst instruction creation functions to
take a Callee,
- modify getOrInsertFunction to return FunctionCallee, and
- update all callers appropriately.
One area of particular note is the change to the sanitizer
code. Previously, they had been casting the result of
`getOrInsertFunction` to a `Function*` via
`checkSanitizerInterfaceFunction`, and storing that. That would report
an error if someone had already inserted a function declaraction with
a mismatching signature.
However, in general, LLVM allows for such mismatches, as
`getOrInsertFunction` will automatically insert a bitcast if
needed. As part of this cleanup, cause the sanitizer code to do the
same. (It will call its functions using the expected signature,
however they may have been declared.)
Finally, in a small number of locations, callers of
`getOrInsertFunction` actually were expecting/requiring that a brand
new function was being created. In such cases, I've switched them to
Function::Create instead.
Differential Revision: https://reviews.llvm.org/D57315
llvm-svn: 352827
2019-02-01 10:28:03 +08:00
|
|
|
return Function::Create(
|
|
|
|
FunctionType::get(Type::getVoidTy(Context), None, false),
|
|
|
|
Function::ExternalLinkage, Name, M);
|
2015-03-31 00:19:15 +08:00
|
|
|
}
|
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) {
|
2018-11-26 03:38:02 +08:00
|
|
|
char str[14] = "testing 1 2 3";
|
|
|
|
MDString *s = MDString::get(Context, StringRef(&str[0], 13));
|
|
|
|
strncpy(str, "aaaaaaaaaaaaa", 14);
|
2009-04-04 15:22:01 +08:00
|
|
|
|
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);
|
|
|
|
|
[IR] De-virtualize ~Value to save a vptr
Summary:
Implements PR889
Removing the virtual table pointer from Value saves 1% of RSS when doing
LTO of llc on Linux. The impact on time was positive, but too noisy to
conclusively say that performance improved. Here is a link to the
spreadsheet with the original data:
https://docs.google.com/spreadsheets/d/1F4FHir0qYnV0MEp2sYYp_BuvnJgWlWPhWOwZ6LbW7W4/edit?usp=sharing
This change makes it invalid to directly delete a Value, User, or
Instruction pointer. Instead, such code can be rewritten to a null check
and a call Value::deleteValue(). Value objects tend to have their
lifetimes managed through iplist, so for the most part, this isn't a big
deal. However, there are some places where LLVM deletes values, and
those places had to be migrated to deleteValue. I have also created
llvm::unique_value, which has a custom deleter, so it can be used in
place of std::unique_ptr<Value>.
I had to add the "DerivedUser" Deleter escape hatch for MemorySSA, which
derives from User outside of lib/IR. Code in IR cannot include MemorySSA
headers or call the MemoryAccess object destructors without introducing
a circular dependency, so we need some level of indirection.
Unfortunately, no class derived from User may have any virtual methods,
because adding a virtual method would break User::getHungOffOperands(),
which assumes that it can find the use list immediately prior to the
User object. I've added a static_assert to the appropriate OperandTraits
templates to help people avoid this trap.
Reviewers: chandlerc, mehdi_amini, pete, dberlin, george.burgess.iv
Reviewed By: chandlerc
Subscribers: krytarowski, eraman, george.burgess.iv, mzolotukhin, Prazek, nlewycky, hans, inglorion, pcc, tejohnson, dberlin, llvm-commits
Differential Revision: https://reviews.llvm.org/D31261
llvm-svn: 303362
2017-05-19 01:24:10 +08:00
|
|
|
I->deleteValue();
|
2009-05-11 04:57:05 +08:00
|
|
|
}
|
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
|
|
|
}
|
2018-11-02 19:46:24 +08:00
|
|
|
|
|
|
|
TEST_F(MDNodeTest, PrintWithDroppedCallOperand) {
|
|
|
|
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);
|
|
|
|
|
|
|
|
CallInst *CI0 = CallInst::Create(F1, "", BB0);
|
|
|
|
CI0->dropAllReferences();
|
|
|
|
|
|
|
|
auto *R0 = ReturnInst::Create(Context, BB0);
|
|
|
|
auto *N0 = MDNode::getDistinct(Context, None);
|
|
|
|
R0->setMetadata("md", N0);
|
|
|
|
|
|
|
|
// Printing the metadata node would previously result in a failed assertion
|
|
|
|
// due to the call instruction's dropped function operand.
|
|
|
|
ModuleSlotTracker MST(&M);
|
|
|
|
EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->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
|
|
|
#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());
|
|
|
|
}
|
|
|
|
|
IR: Drop uniquing when an MDNode Value operand is deleted
This is a fix for PR28697.
An MDNode can indirectly refer to a GlobalValue, through a
ConstantAsMetadata. When the GlobalValue is deleted, the MDNode operand
is reset to `nullptr`. If the node is uniqued, this can lead to a
hard-to-detect cache invalidation in a Metadata map that's shared across
an LLVMContext.
Consider:
1. A map from Metadata* to `T` called RemappedMDs.
2. A node that references a global variable, `!{i1* @GV}`.
3. Insert `!{i1* @GV} -> SomeT` in the map.
4. Delete `@GV`, leaving behind `!{null} -> SomeT`.
Looking up the generic and uninteresting `!{null}` gives you `SomeT`,
which is likely related to `@GV`. Worse, `SomeT`'s lifetime may be tied
to the deleted `@GV`.
This occurs in practice in the shared ValueMap used since r266579 in the
IRMover. Other code that handles more than one Module (with different
lifetimes) in the same LLVMContext could hit it too.
The fix here is a partial revert of r225223: in the rare case that an
MDNode operand is a ConstantAsMetadata (i.e., wrapping a node from the
Value hierarchy), drop uniquing if it gets replaced with `nullptr`.
This changes step #4 above to leave behind `distinct !{null} -> SomeT`,
which can't be confused with the generic `!{null}`.
In theory, this can cause some churn in the LLVMContext's MDNode
uniquing map when Values are being deleted. However:
- The number of GlobalValues referenced from uniqued MDNodes is
expected to be quite small. E.g., the debug info metadata schema
only references GlobalValues from distinct nodes.
- Other Constants have the lifetime of the LLVMContext, whose teardown
is careful to drop references before deleting the constants.
As a result, I don't expect a compile time regression from this change.
llvm-svn: 277625
2016-08-04 02:19:43 +08:00
|
|
|
TEST_F(MDNodeTest, UniquedOnDeletedOperand) {
|
|
|
|
// temp !{}
|
|
|
|
TempMDTuple T = MDTuple::getTemporary(Context, None);
|
|
|
|
|
|
|
|
// !{temp !{}}
|
|
|
|
Metadata *Ops[] = {T.get()};
|
|
|
|
MDTuple *N = MDTuple::get(Context, Ops);
|
|
|
|
|
|
|
|
// !{temp !{}} => !{null}
|
|
|
|
T.reset();
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
Metadata *NullOps[] = {nullptr};
|
|
|
|
ASSERT_EQ(N, MDTuple::get(Context, NullOps));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, DistinctOnDeletedValueOperand) {
|
|
|
|
// i1* @GV
|
|
|
|
Type *Ty = Type::getInt1PtrTy(Context);
|
|
|
|
std::unique_ptr<GlobalVariable> GV(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());
|
|
|
|
|
|
|
|
// !{i1* @GV}
|
|
|
|
Metadata *Ops[] = {Op};
|
|
|
|
MDTuple *N = MDTuple::get(Context, Ops);
|
|
|
|
|
|
|
|
// !{i1* @GV} => !{null}
|
|
|
|
GV.reset();
|
|
|
|
ASSERT_TRUE(N->isDistinct());
|
|
|
|
ASSERT_EQ(nullptr, N->getOperand(0));
|
|
|
|
Metadata *NullOps[] = {nullptr};
|
|
|
|
ASSERT_NE(N, MDTuple::get(Context, NullOps));
|
|
|
|
}
|
|
|
|
|
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());
|
|
|
|
}
|
|
|
|
|
IR: Drop uniquing when an MDNode Value operand is deleted
This is a fix for PR28697.
An MDNode can indirectly refer to a GlobalValue, through a
ConstantAsMetadata. When the GlobalValue is deleted, the MDNode operand
is reset to `nullptr`. If the node is uniqued, this can lead to a
hard-to-detect cache invalidation in a Metadata map that's shared across
an LLVMContext.
Consider:
1. A map from Metadata* to `T` called RemappedMDs.
2. A node that references a global variable, `!{i1* @GV}`.
3. Insert `!{i1* @GV} -> SomeT` in the map.
4. Delete `@GV`, leaving behind `!{null} -> SomeT`.
Looking up the generic and uninteresting `!{null}` gives you `SomeT`,
which is likely related to `@GV`. Worse, `SomeT`'s lifetime may be tied
to the deleted `@GV`.
This occurs in practice in the shared ValueMap used since r266579 in the
IRMover. Other code that handles more than one Module (with different
lifetimes) in the same LLVMContext could hit it too.
The fix here is a partial revert of r225223: in the rare case that an
MDNode operand is a ConstantAsMetadata (i.e., wrapping a node from the
Value hierarchy), drop uniquing if it gets replaced with `nullptr`.
This changes step #4 above to leave behind `distinct !{null} -> SomeT`,
which can't be confused with the generic `!{null}`.
In theory, this can cause some churn in the LLVMContext's MDNode
uniquing map when Values are being deleted. However:
- The number of GlobalValues referenced from uniqued MDNodes is
expected to be quite small. E.g., the debug info metadata schema
only references GlobalValues from distinct nodes.
- Other Constants have the lifetime of the LLVMContext, whose teardown
is careful to drop references before deleting the constants.
As a result, I don't expect a compile time regression from this change.
llvm-svn: 277625
2016-08-04 02:19:43 +08:00
|
|
|
TEST_F(MDNodeTest, replaceWithUniquedDeletedOperand) {
|
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();
|
IR: Drop uniquing when an MDNode Value operand is deleted
This is a fix for PR28697.
An MDNode can indirectly refer to a GlobalValue, through a
ConstantAsMetadata. When the GlobalValue is deleted, the MDNode operand
is reset to `nullptr`. If the node is uniqued, this can lead to a
hard-to-detect cache invalidation in a Metadata map that's shared across
an LLVMContext.
Consider:
1. A map from Metadata* to `T` called RemappedMDs.
2. A node that references a global variable, `!{i1* @GV}`.
3. Insert `!{i1* @GV} -> SomeT` in the map.
4. Delete `@GV`, leaving behind `!{null} -> SomeT`.
Looking up the generic and uninteresting `!{null}` gives you `SomeT`,
which is likely related to `@GV`. Worse, `SomeT`'s lifetime may be tied
to the deleted `@GV`.
This occurs in practice in the shared ValueMap used since r266579 in the
IRMover. Other code that handles more than one Module (with different
lifetimes) in the same LLVMContext could hit it too.
The fix here is a partial revert of r225223: in the rare case that an
MDNode operand is a ConstantAsMetadata (i.e., wrapping a node from the
Value hierarchy), drop uniquing if it gets replaced with `nullptr`.
This changes step #4 above to leave behind `distinct !{null} -> SomeT`,
which can't be confused with the generic `!{null}`.
In theory, this can cause some churn in the LLVMContext's MDNode
uniquing map when Values are being deleted. However:
- The number of GlobalValues referenced from uniqued MDNodes is
expected to be quite small. E.g., the debug info metadata schema
only references GlobalValues from distinct nodes.
- Other Constants have the lifetime of the LLVMContext, whose teardown
is careful to drop references before deleting the constants.
As a result, I don't expect a compile time regression from this change.
llvm-svn: 277625
2016-08-04 02:19:43 +08:00
|
|
|
ASSERT_TRUE(N->isDistinct());
|
|
|
|
ASSERT_EQ(nullptr, N->getOperand(0));
|
2015-04-01 04:50:50 +08:00
|
|
|
Metadata *NullOps[] = {nullptr};
|
IR: Drop uniquing when an MDNode Value operand is deleted
This is a fix for PR28697.
An MDNode can indirectly refer to a GlobalValue, through a
ConstantAsMetadata. When the GlobalValue is deleted, the MDNode operand
is reset to `nullptr`. If the node is uniqued, this can lead to a
hard-to-detect cache invalidation in a Metadata map that's shared across
an LLVMContext.
Consider:
1. A map from Metadata* to `T` called RemappedMDs.
2. A node that references a global variable, `!{i1* @GV}`.
3. Insert `!{i1* @GV} -> SomeT` in the map.
4. Delete `@GV`, leaving behind `!{null} -> SomeT`.
Looking up the generic and uninteresting `!{null}` gives you `SomeT`,
which is likely related to `@GV`. Worse, `SomeT`'s lifetime may be tied
to the deleted `@GV`.
This occurs in practice in the shared ValueMap used since r266579 in the
IRMover. Other code that handles more than one Module (with different
lifetimes) in the same LLVMContext could hit it too.
The fix here is a partial revert of r225223: in the rare case that an
MDNode operand is a ConstantAsMetadata (i.e., wrapping a node from the
Value hierarchy), drop uniquing if it gets replaced with `nullptr`.
This changes step #4 above to leave behind `distinct !{null} -> SomeT`,
which can't be confused with the generic `!{null}`.
In theory, this can cause some churn in the LLVMContext's MDNode
uniquing map when Values are being deleted. However:
- The number of GlobalValues referenced from uniqued MDNodes is
expected to be quite small. E.g., the debug info metadata schema
only references GlobalValues from distinct nodes.
- Other Constants have the lifetime of the LLVMContext, whose teardown
is careful to drop references before deleting the constants.
As a result, I don't expect a compile time regression from this change.
llvm-svn: 277625
2016-08-04 02:19:43 +08:00
|
|
|
ASSERT_NE(N, MDTuple::get(Context, NullOps));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(MDNodeTest, replaceWithUniquedChangedOperand) {
|
|
|
|
// 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} => !{i1* @GV2}
|
|
|
|
std::unique_ptr<GlobalVariable> GV2(
|
|
|
|
new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
|
|
|
|
GV->replaceAllUsesWith(GV2.get());
|
|
|
|
ASSERT_TRUE(N->isUniqued());
|
|
|
|
Metadata *NullOps[] = {ConstantAsMetadata::get(GV2.get())};
|
2015-04-01 04:50:50 +08:00
|
|
|
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());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-25 07:30:57 +08:00
|
|
|
TEST_F(DILocationTest, Merge) {
|
|
|
|
DISubprogram *N = getSubprogram();
|
|
|
|
DIScope *S = DILexicalBlock::get(Context, N, getFile(), 3, 4);
|
|
|
|
|
|
|
|
{
|
|
|
|
// Identical.
|
|
|
|
auto *A = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(2u, M->getLine());
|
|
|
|
EXPECT_EQ(7u, M->getColumn());
|
|
|
|
EXPECT_EQ(N, M->getScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Identical, different scopes.
|
|
|
|
auto *A = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, S);
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(0u, M->getLine()); // FIXME: Should this be 2?
|
|
|
|
EXPECT_EQ(0u, M->getColumn()); // FIXME: Should this be 7?
|
|
|
|
EXPECT_EQ(N, M->getScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Different lines, same scopes.
|
|
|
|
auto *A = DILocation::get(Context, 1, 6, N);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(0u, M->getLine());
|
|
|
|
EXPECT_EQ(0u, M->getColumn());
|
|
|
|
EXPECT_EQ(N, M->getScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Twisty locations, all different, same function.
|
|
|
|
auto *A = DILocation::get(Context, 1, 6, N);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, S);
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(0u, M->getLine());
|
|
|
|
EXPECT_EQ(0u, M->getColumn());
|
|
|
|
EXPECT_EQ(N, M->getScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Different function, same inlined-at.
|
|
|
|
auto *F = getFile();
|
|
|
|
auto *SP1 = DISubprogram::getDistinct(Context, F, "a", "a", F, 0, nullptr,
|
2018-11-20 02:29:28 +08:00
|
|
|
0, nullptr, 0, 0, DINode::FlagZero,
|
|
|
|
DISubprogram::SPFlagZero, nullptr);
|
2018-08-25 07:30:57 +08:00
|
|
|
auto *SP2 = DISubprogram::getDistinct(Context, F, "b", "b", F, 0, nullptr,
|
2018-11-20 02:29:28 +08:00
|
|
|
0, nullptr, 0, 0, DINode::FlagZero,
|
|
|
|
DISubprogram::SPFlagZero, nullptr);
|
2018-08-25 07:30:57 +08:00
|
|
|
|
|
|
|
auto *I = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *A = DILocation::get(Context, 1, 6, SP1, I);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, SP2, I);
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(0u, M->getLine());
|
|
|
|
EXPECT_EQ(0u, M->getColumn());
|
|
|
|
EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
|
|
|
|
EXPECT_EQ(I, M->getInlinedAt());
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Completely different.
|
|
|
|
auto *I = DILocation::get(Context, 2, 7, N);
|
|
|
|
auto *A = DILocation::get(Context, 1, 6, S, I);
|
|
|
|
auto *B = DILocation::get(Context, 2, 7, getSubprogram());
|
|
|
|
auto *M = DILocation::getMergedLocation(A, B);
|
|
|
|
EXPECT_EQ(0u, M->getLine());
|
|
|
|
EXPECT_EQ(0u, M->getColumn());
|
|
|
|
EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
|
|
|
|
EXPECT_EQ(S, M->getScope());
|
|
|
|
EXPECT_EQ(nullptr, M->getInlinedAt());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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());
|
|
|
|
}
|
|
|
|
|
2018-12-22 06:48:50 +08:00
|
|
|
TEST_F(DILocationTest, discriminatorEncoding) {
|
|
|
|
EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).getValue());
|
|
|
|
|
|
|
|
// Encode base discriminator as a component: lsb is 0, then the value.
|
|
|
|
// The other components are all absent, so we leave all the other bits 0.
|
|
|
|
EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).getValue());
|
|
|
|
|
|
|
|
// Base discriminator component is empty, so lsb is 1. Next component is not
|
|
|
|
// empty, so its lsb is 0, then its value (1). Next component is empty.
|
|
|
|
// So the bit pattern is 101.
|
|
|
|
EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).getValue());
|
|
|
|
|
|
|
|
// First 2 components are empty, so the bit pattern is 11. Then the
|
|
|
|
// next component - ending up with 1011.
|
|
|
|
EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).getValue());
|
|
|
|
|
|
|
|
// The bit pattern for the first 2 components is 11. The next bit is 0,
|
|
|
|
// because the last component is not empty. We have 29 bits usable for
|
|
|
|
// encoding, but we cap it at 12 bits uniformously for all components. We
|
|
|
|
// encode the last component over 14 bits.
|
|
|
|
EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x3ff3eU,
|
|
|
|
DILocation::encodeDiscriminator(0x1f, 0x1ff, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0x1ff87feU,
|
|
|
|
DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0xfff9f3eU,
|
|
|
|
DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0xffc3ff3eU,
|
|
|
|
DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0xffcf87feU,
|
|
|
|
DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff).getValue());
|
|
|
|
|
|
|
|
EXPECT_EQ(0xe1ff87feU,
|
|
|
|
DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7).getValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DILocationTest, discriminatorEncodingNegativeTests) {
|
|
|
|
EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0, 0x1000));
|
|
|
|
EXPECT_EQ(None, DILocation::encodeDiscriminator(0x1000, 0, 0));
|
|
|
|
EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0x1000, 0));
|
|
|
|
EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0, 0x1000));
|
|
|
|
EXPECT_EQ(None, DILocation::encodeDiscriminator(0x1ff, 0x1ff, 8));
|
|
|
|
EXPECT_EQ(None,
|
|
|
|
DILocation::encodeDiscriminator(std::numeric_limits<uint32_t>::max(),
|
|
|
|
std::numeric_limits<uint32_t>::max(),
|
|
|
|
0));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(DILocationTest, discriminatorSpecialCases) {
|
|
|
|
// We don't test getCopyIdentifier here because the only way
|
|
|
|
// to set it is by constructing an encoded discriminator using
|
|
|
|
// encodeDiscriminator, which is already tested.
|
|
|
|
auto L1 = DILocation::get(Context, 1, 2, getSubprogram());
|
|
|
|
EXPECT_EQ(0U, L1->getBaseDiscriminator());
|
|
|
|
EXPECT_EQ(1U, L1->getDuplicationFactor());
|
|
|
|
|
2019-01-24 08:10:25 +08:00
|
|
|
EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).getValue());
|
|
|
|
EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).getValue());
|
|
|
|
EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).getValue());
|
|
|
|
|
|
|
|
auto L2 = L1->cloneWithBaseDiscriminator(1).getValue();
|
2018-12-22 06:48:50 +08:00
|
|
|
EXPECT_EQ(0U, L1->getBaseDiscriminator());
|
|
|
|
EXPECT_EQ(1U, L1->getDuplicationFactor());
|
|
|
|
|
|
|
|
EXPECT_EQ(1U, L2->getBaseDiscriminator());
|
|
|
|
EXPECT_EQ(1U, L2->getDuplicationFactor());
|
|
|
|
|
2019-01-24 08:10:25 +08:00
|
|
|
auto L3 = L2->cloneByMultiplyingDuplicationFactor(2).getValue();
|
2018-12-22 06:48:50 +08:00
|
|
|
EXPECT_EQ(1U, L3->getBaseDiscriminator());
|
|
|
|
EXPECT_EQ(2U, L3->getDuplicationFactor());
|
|
|
|
|
2019-01-24 08:10:25 +08:00
|
|
|
EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).getValue());
|
|
|
|
|
|
|
|
auto L4 = L3->cloneByMultiplyingDuplicationFactor(4).getValue();
|
2018-12-22 06:48:50 +08:00
|
|
|
EXPECT_EQ(1U, L4->getBaseDiscriminator());
|
|
|
|
EXPECT_EQ(8U, L4->getDuplicationFactor());
|
|
|
|
|
2019-01-24 08:10:25 +08:00
|
|
|
auto L5 = L4->cloneWithBaseDiscriminator(2).getValue();
|
2018-12-22 06:48:50 +08:00
|
|
|
EXPECT_EQ(2U, L5->getBaseDiscriminator());
|
2019-01-24 08:10:25 +08:00
|
|
|
EXPECT_EQ(8U, L5->getDuplicationFactor());
|
2018-12-22 06:48:50 +08:00
|
|
|
|
|
|
|
// Check extreme cases
|
2019-01-24 08:10:25 +08:00
|
|
|
auto L6 = L1->cloneWithBaseDiscriminator(0xfff).getValue();
|
2018-12-22 06:48:50 +08:00
|
|
|
EXPECT_EQ(0xfffU, L6->getBaseDiscriminator());
|
2019-01-24 08:10:25 +08:00
|
|
|
EXPECT_EQ(0xfffU, L6->cloneByMultiplyingDuplicationFactor(0xfff)
|
|
|
|
.getValue()
|
|
|
|
->getDuplicationFactor());
|
2018-12-22 06:48:50 +08:00
|
|
|
|
|
|
|
// Check we return None for unencodable cases.
|
2019-01-24 08:10:25 +08:00
|
|
|
EXPECT_EQ(None, L4->cloneWithBaseDiscriminator(0x1000));
|
|
|
|
EXPECT_EQ(None, L4->cloneByMultiplyingDuplicationFactor(0x1000));
|
2018-12-22 06:48:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
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);
|
[Metadata] Extend 'count' field of DISubrange to take a metadata node
Summary:
This patch extends the DISubrange 'count' field to take either a
(signed) constant integer value or a reference to a DILocalVariable
or DIGlobalVariable.
This is patch [1/3] in a series to extend LLVM's DISubrange Metadata
node to support debugging of C99 variable length arrays and vectors with
runtime length like the Scalable Vector Extension for AArch64. It is
also a first step towards representing more complex cases like arrays
in Fortran.
Reviewers: echristo, pcc, aprantl, dexonsmith, clayborg, kristof.beyls, dblaikie
Reviewed By: aprantl
Subscribers: rnk, probinson, fhahn, aemerson, rengolin, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D41695
llvm-svn: 323313
2018-01-24 17:56:07 +08:00
|
|
|
auto Count = N->getCount();
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
|
[Metadata] Extend 'count' field of DISubrange to take a metadata node
Summary:
This patch extends the DISubrange 'count' field to take either a
(signed) constant integer value or a reference to a DILocalVariable
or DIGlobalVariable.
This is patch [1/3] in a series to extend LLVM's DISubrange Metadata
node to support debugging of C99 variable length arrays and vectors with
runtime length like the Scalable Vector Extension for AArch64. It is
also a first step towards representing more complex cases like arrays
in Fortran.
Reviewers: echristo, pcc, aprantl, dexonsmith, clayborg, kristof.beyls, dblaikie
Reviewed By: aprantl
Subscribers: rnk, probinson, fhahn, aemerson, rengolin, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D41695
llvm-svn: 323313
2018-01-24 17:56:07 +08:00
|
|
|
ASSERT_TRUE(Count);
|
|
|
|
ASSERT_TRUE(Count.is<ConstantInt*>());
|
|
|
|
EXPECT_EQ(5, Count.get<ConstantInt*>()->getSExtValue());
|
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);
|
[Metadata] Extend 'count' field of DISubrange to take a metadata node
Summary:
This patch extends the DISubrange 'count' field to take either a
(signed) constant integer value or a reference to a DILocalVariable
or DIGlobalVariable.
This is patch [1/3] in a series to extend LLVM's DISubrange Metadata
node to support debugging of C99 variable length arrays and vectors with
runtime length like the Scalable Vector Extension for AArch64. It is
also a first step towards representing more complex cases like arrays
in Fortran.
Reviewers: echristo, pcc, aprantl, dexonsmith, clayborg, kristof.beyls, dblaikie
Reviewed By: aprantl
Subscribers: rnk, probinson, fhahn, aemerson, rengolin, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D41695
llvm-svn: 323313
2018-01-24 17:56:07 +08:00
|
|
|
auto Count = N->getCount();
|
2015-02-19 07:17:51 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
|
[Metadata] Extend 'count' field of DISubrange to take a metadata node
Summary:
This patch extends the DISubrange 'count' field to take either a
(signed) constant integer value or a reference to a DILocalVariable
or DIGlobalVariable.
This is patch [1/3] in a series to extend LLVM's DISubrange Metadata
node to support debugging of C99 variable length arrays and vectors with
runtime length like the Scalable Vector Extension for AArch64. It is
also a first step towards representing more complex cases like arrays
in Fortran.
Reviewers: echristo, pcc, aprantl, dexonsmith, clayborg, kristof.beyls, dblaikie
Reviewed By: aprantl
Subscribers: rnk, probinson, fhahn, aemerson, rengolin, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D41695
llvm-svn: 323313
2018-01-24 17:56:07 +08:00
|
|
|
ASSERT_TRUE(Count);
|
|
|
|
ASSERT_TRUE(Count.is<ConstantInt*>());
|
|
|
|
EXPECT_EQ(-1, Count.get<ConstantInt*>()->getSExtValue());
|
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
|
|
|
}
|
|
|
|
|
[Metadata] Extend 'count' field of DISubrange to take a metadata node
Summary:
This patch extends the DISubrange 'count' field to take either a
(signed) constant integer value or a reference to a DILocalVariable
or DIGlobalVariable.
This is patch [1/3] in a series to extend LLVM's DISubrange Metadata
node to support debugging of C99 variable length arrays and vectors with
runtime length like the Scalable Vector Extension for AArch64. It is
also a first step towards representing more complex cases like arrays
in Fortran.
Reviewers: echristo, pcc, aprantl, dexonsmith, clayborg, kristof.beyls, dblaikie
Reviewed By: aprantl
Subscribers: rnk, probinson, fhahn, aemerson, rengolin, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D41695
llvm-svn: 323313
2018-01-24 17:56:07 +08:00
|
|
|
TEST_F(DISubrangeTest, getVariableCount) {
|
|
|
|
DILocalScope *Scope = getSubprogram();
|
|
|
|
DIFile *File = getFile();
|
|
|
|
DIType *Type = getDerivedType();
|
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
|
|
|
|
auto *VlaExpr = DILocalVariable::get(Context, Scope, "vla_expr", File, 8,
|
|
|
|
Type, 2, Flags, 8);
|
|
|
|
|
|
|
|
auto *N = DISubrange::get(Context, VlaExpr, 0);
|
|
|
|
auto Count = N->getCount();
|
|
|
|
ASSERT_TRUE(Count);
|
|
|
|
ASSERT_TRUE(Count.is<DIVariable*>());
|
|
|
|
EXPECT_EQ(VlaExpr, Count.get<DIVariable*>());
|
|
|
|
ASSERT_TRUE(isa<DIVariable>(N->getRawCountNode()));
|
|
|
|
EXPECT_EQ(0, N->getLowerBound());
|
|
|
|
EXPECT_EQ("vla_expr", Count.get<DIVariable*>()->getName());
|
|
|
|
EXPECT_EQ(N, DISubrange::get(Context, VlaExpr, 0));
|
|
|
|
}
|
|
|
|
|
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) {
|
2018-02-13 00:10:09 +08:00
|
|
|
auto *N = DIEnumerator::get(Context, 7, false, "name");
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
|
|
|
|
EXPECT_EQ(7, N->getValue());
|
2018-02-14 21:11:56 +08:00
|
|
|
EXPECT_FALSE(N->isUnsigned());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ("name", N->getName());
|
2018-02-13 00:10:09 +08:00
|
|
|
EXPECT_EQ(N, DIEnumerator::get(Context, 7, false, "name"));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2018-02-13 00:10:09 +08:00
|
|
|
EXPECT_NE(N, DIEnumerator::get(Context, 7, true, "name"));
|
|
|
|
EXPECT_NE(N, DIEnumerator::get(Context, 8, false, "name"));
|
|
|
|
EXPECT_NE(N, DIEnumerator::get(Context, 7, false, "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 =
|
2018-08-15 03:35:34 +08:00
|
|
|
DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7,
|
|
|
|
DINode::FlagZero);
|
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());
|
2018-08-15 03:35:34 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, N->getFlags());
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2018-08-15 03:35:34 +08:00
|
|
|
26, 7, DINode::FlagZero));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
|
2018-08-15 03:35:34 +08:00
|
|
|
"special", 33, 26, 7, DINode::FlagZero));
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_NE(N,
|
2018-08-15 03:35:34 +08:00
|
|
|
DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7,
|
|
|
|
DINode::FlagZero));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
|
2018-08-15 03:35:34 +08:00
|
|
|
26, 7, DINode::FlagZero));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2018-08-15 03:35:34 +08:00
|
|
|
25, 7, DINode::FlagZero));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
2018-08-15 03:35:34 +08:00
|
|
|
26, 6, DINode::FlagZero));
|
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
|
|
|
26, 7, DINode::FlagBigEndian));
|
|
|
|
EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
|
|
|
|
26, 7, DINode::FlagLittleEndian));
|
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",
|
2018-08-15 03:35:34 +08:00
|
|
|
UINT64_MAX, UINT32_MAX - 1, 7, DINode::FlagZero);
|
2015-02-20 07:56:07 +08:00
|
|
|
EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
|
2016-10-18 22:31:22 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
|
2015-02-20 07:56:07 +08:00
|
|
|
}
|
|
|
|
|
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());
|
2018-08-15 03:35:34 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, N->getFlags());
|
2015-03-04 00:45:34 +08:00
|
|
|
}
|
|
|
|
|
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,
|
2018-08-15 03:35:34 +08:00
|
|
|
dwarf::DW_ATE_signed, DINode::FlagZero);
|
2015-03-04 00:45:34 +08:00
|
|
|
|
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)));
|
|
|
|
}
|
|
|
|
|
2018-06-02 07:15:09 +08:00
|
|
|
TEST_F(DITypeTest, cloneWithFlags) {
|
2015-03-04 00:45:34 +08:00
|
|
|
// void (void)
|
|
|
|
Metadata *TypesOps[] = {nullptr};
|
|
|
|
Metadata *Types = MDTuple::get(Context, TypesOps);
|
|
|
|
|
2016-09-07 01:03:02 +08:00
|
|
|
DIType *D =
|
|
|
|
DISubroutineType::getDistinct(Context, DINode::FlagZero, 0, Types);
|
2016-09-06 18:46:28 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, D->getFlags());
|
2018-06-02 07:15:09 +08:00
|
|
|
TempDIType D2 = D->cloneWithFlags(DINode::FlagRValueReference);
|
|
|
|
EXPECT_EQ(DINode::FlagRValueReference, D2->getFlags());
|
2016-09-06 18:46:28 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, D->getFlags());
|
2015-03-04 00:45:34 +08:00
|
|
|
|
2016-09-07 01:03:02 +08:00
|
|
|
TempDIType T =
|
|
|
|
DISubroutineType::getTemporary(Context, DINode::FlagZero, 0, Types);
|
2016-09-06 18:46:28 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, T->getFlags());
|
2018-06-02 07:15:09 +08:00
|
|
|
TempDIType T2 = T->cloneWithFlags(DINode::FlagRValueReference);
|
|
|
|
EXPECT_EQ(DINode::FlagRValueReference, T2->getFlags());
|
2016-09-06 18:46:28 +08:00
|
|
|
EXPECT_EQ(DINode::FlagZero, T->getFlags());
|
2015-03-04 00:45:34 +08:00
|
|
|
}
|
|
|
|
|
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();
|
2017-03-09 07:55:44 +08:00
|
|
|
unsigned DWARFAddressSpace = 8;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags5 = static_cast<DINode::DIFlags>(5);
|
|
|
|
DINode::DIFlags Flags4 = static_cast<DINode::DIFlags>(4);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2016-09-07 01:03:02 +08:00
|
|
|
auto *N =
|
|
|
|
DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something", File,
|
2017-03-09 07:55:44 +08:00
|
|
|
1, Scope, BaseType, 2, 3, 4, DWARFAddressSpace, Flags5,
|
|
|
|
ExtraData);
|
2015-02-10 08:52:32 +08:00
|
|
|
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());
|
2017-03-09 07:55:44 +08:00
|
|
|
EXPECT_EQ(DWARFAddressSpace, N->getDWARFAddressSpace().getValue());
|
2015-02-10 08:52:32 +08:00
|
|
|
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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, ExtraData));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, ExtraData));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
|
2017-03-09 07:55:44 +08:00
|
|
|
File, 1, Scope, BaseType, 2, 3,
|
|
|
|
4, DWARFAddressSpace, Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
3, 4, DWARFAddressSpace, Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, 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(),
|
2017-03-09 07:55:44 +08:00
|
|
|
BaseType, 2, 3, 4, DWARFAddressSpace, Flags5,
|
|
|
|
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,
|
2017-03-09 07:55:44 +08:00
|
|
|
Scope, getBasicType("basic2"), 2, 3, 4, DWARFAddressSpace,
|
|
|
|
Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, ExtraData));
|
|
|
|
EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
|
|
|
|
"something", File, 1, Scope, BaseType, 2, 3,
|
|
|
|
5, DWARFAddressSpace, Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace + 1, Flags5, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags4, 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,
|
2017-03-09 07:55:44 +08:00
|
|
|
4, DWARFAddressSpace, Flags5, 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();
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
|
2015-02-20 07:56:07 +08:00
|
|
|
|
2016-09-07 01:03:02 +08:00
|
|
|
auto *N = DIDerivedType::get(
|
|
|
|
Context, dwarf::DW_TAG_pointer_type, "something", File, 1, Scope,
|
2017-03-09 07:55:44 +08:00
|
|
|
BaseType, UINT64_MAX, UINT32_MAX - 1, UINT64_MAX - 2, UINT32_MAX - 3,
|
|
|
|
Flags, ExtraData);
|
2015-02-20 07:56:07 +08:00
|
|
|
EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
|
2016-10-18 22:31:22 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
|
2015-02-20 07:56:07 +08:00
|
|
|
EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());
|
2017-03-09 07:55:44 +08:00
|
|
|
EXPECT_EQ(UINT32_MAX - 3, N->getDWARFAddressSpace().getValue());
|
2015-02-20 07:56:07 +08:00
|
|
|
}
|
|
|
|
|
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;
|
2016-10-18 22:31:22 +08:00
|
|
|
uint32_t AlignInBits = 3;
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t OffsetInBits = 4;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(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));
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(Flags + 1);
|
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,
|
2016-09-06 18:46:28 +08:00
|
|
|
AlignInBits, OffsetInBits, FlagsPOne, Elements, RuntimeLang,
|
2015-02-10 08:52:32 +08:00
|
|
|
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;
|
2016-10-18 22:31:22 +08:00
|
|
|
uint32_t AlignInBits = UINT32_MAX - 1;
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t OffsetInBits = UINT64_MAX - 2;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(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;
|
2016-10-18 22:31:22 +08:00
|
|
|
uint32_t AlignInBits = 3;
|
2015-02-20 07:56:07 +08:00
|
|
|
uint64_t OffsetInBits = 4;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
|
2015-02-19 04:47:52 +08:00
|
|
|
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());
|
2017-11-09 06:04:43 +08:00
|
|
|
// As an extension, the containing type can be anything. This is
|
|
|
|
// used by Rust to associate vtables with their concrete type.
|
|
|
|
DIType *BasicType = getBasicType("basic");
|
|
|
|
N->replaceVTableHolder(BasicType);
|
|
|
|
EXPECT_EQ(BasicType, N->getVTableHolder());
|
2015-02-19 04:47:52 +08:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2018-02-07 07:45:59 +08:00
|
|
|
TEST_F(DICompositeTypeTest, variant_part) {
|
|
|
|
unsigned Tag = dwarf::DW_TAG_variant_part;
|
|
|
|
StringRef Name = "some name";
|
|
|
|
DIFile *File = getFile();
|
|
|
|
unsigned Line = 1;
|
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
DIType *BaseType = getCompositeType();
|
|
|
|
uint64_t SizeInBits = 2;
|
|
|
|
uint32_t AlignInBits = 3;
|
|
|
|
uint64_t OffsetInBits = 4;
|
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
|
|
|
|
unsigned RuntimeLang = 6;
|
|
|
|
StringRef Identifier = "some id";
|
|
|
|
DIDerivedType *Discriminator = cast<DIDerivedType>(getDerivedType());
|
|
|
|
DIDerivedType *Discriminator2 = cast<DIDerivedType>(getDerivedType());
|
|
|
|
|
|
|
|
EXPECT_NE(Discriminator, Discriminator2);
|
|
|
|
|
|
|
|
auto *N = DICompositeType::get(
|
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
|
|
|
|
Discriminator);
|
|
|
|
|
|
|
|
// Test the hashing.
|
|
|
|
auto *Same = DICompositeType::get(
|
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
|
|
|
|
Discriminator);
|
|
|
|
auto *Other = DICompositeType::get(
|
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
|
|
|
|
Discriminator2);
|
|
|
|
auto *NoDisc = DICompositeType::get(
|
|
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
|
|
|
|
OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
|
|
|
|
nullptr);
|
|
|
|
|
|
|
|
EXPECT_EQ(N, Same);
|
|
|
|
EXPECT_NE(Same, Other);
|
|
|
|
EXPECT_NE(Same, NoDisc);
|
|
|
|
EXPECT_NE(Other, NoDisc);
|
|
|
|
|
|
|
|
EXPECT_EQ(N->getDiscriminator(), Discriminator);
|
|
|
|
}
|
|
|
|
|
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) {
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(1);
|
|
|
|
DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(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));
|
|
|
|
|
2016-09-06 18:46:28 +08:00
|
|
|
EXPECT_NE(N, DISubroutineType::get(Context, FlagsPOne, 0, TypeArray));
|
2016-06-09 04:34:29 +08:00
|
|
|
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";
|
2018-02-13 03:45:54 +08:00
|
|
|
DIFile::ChecksumKind CSKind = DIFile::ChecksumKind::CSK_MD5;
|
|
|
|
StringRef ChecksumString = "000102030405060708090a0b0c0d0e0f";
|
|
|
|
DIFile::ChecksumInfo<StringRef> Checksum(CSKind, ChecksumString);
|
2018-02-24 07:01:06 +08:00
|
|
|
StringRef Source = "source";
|
|
|
|
auto *N = DIFile::get(Context, Filename, Directory, Checksum, Source);
|
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());
|
2016-12-25 18:12:09 +08:00
|
|
|
EXPECT_EQ(Checksum, N->getChecksum());
|
2018-02-24 07:01:06 +08:00
|
|
|
EXPECT_EQ(Source, N->getSource());
|
|
|
|
EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, Checksum, Source));
|
2016-12-25 18:12:09 +08:00
|
|
|
|
2018-02-24 07:01:06 +08:00
|
|
|
EXPECT_NE(N, DIFile::get(Context, "other", Directory, Checksum, Source));
|
|
|
|
EXPECT_NE(N, DIFile::get(Context, Filename, "other", Checksum, Source));
|
2018-02-13 03:45:54 +08:00
|
|
|
DIFile::ChecksumInfo<StringRef> OtherChecksum(DIFile::ChecksumKind::CSK_SHA1, ChecksumString);
|
2017-09-20 02:14:45 +08:00
|
|
|
EXPECT_NE(
|
2018-02-13 03:45:54 +08:00
|
|
|
N, DIFile::get(Context, Filename, Directory, OtherChecksum));
|
2018-02-24 07:01:06 +08:00
|
|
|
StringRef OtherSource = "other";
|
|
|
|
EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum, OtherSource));
|
|
|
|
EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum));
|
2016-12-25 18:12:09 +08:00
|
|
|
EXPECT_NE(N, DIFile::get(Context, Filename, Directory));
|
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,
|
Change debug-info-for-profiling from a TargetOption to a function attribute.
Summary: LTO requires the debug-info-for-profiling to be a function attribute.
Reviewers: echristo, mehdi_amini, dblaikie, probinson, aprantl
Reviewed By: mehdi_amini, dblaikie, aprantl
Subscribers: aprantl, probinson, ahatanak, llvm-commits, mehdi_amini
Differential Revision: https://reviews.llvm.org/D29203
llvm-svn: 293833
2017-02-02 06:45:09 +08:00
|
|
|
RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
|
2018-11-14 04:08:10 +08:00
|
|
|
false, DICompileUnit::DebugNameTableKind::Default, false);
|
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,
|
2017-09-13 05:50:41 +08:00
|
|
|
RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false,
|
2018-11-14 04:08:10 +08:00
|
|
|
DICompileUnit::DebugNameTableKind::Default, false);
|
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;
|
2016-07-01 10:41:21 +08:00
|
|
|
int ThisAdjustment = -3;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(6);
|
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();
|
[DebugInfo] Add DILabel metadata and intrinsic llvm.dbg.label.
In order to set breakpoints on labels and list source code around
labels, we need collect debug information for labels, i.e., label
name, the function label belong, line number in the file, and the
address label located. In order to keep these information in LLVM
IR and to allow backend to generate debug information correctly.
We create a new kind of metadata for labels, DILabel. The format
of DILabel is
!DILabel(scope: !1, name: "foo", file: !2, line: 3)
We hope to keep debug information as much as possible even the
code is optimized. So, we create a new kind of intrinsic for label
metadata to avoid the metadata is eliminated with basic block.
The intrinsic will keep existing if we keep it from optimized out.
The format of the intrinsic is
llvm.dbg.label(metadata !1)
It has only one argument, that is the DILabel metadata. The
intrinsic will follow the label immediately. Backend could get the
label metadata through the intrinsic's parameter.
We also create DIBuilder API for labels to be used by Frontend.
Frontend could use createLabel() to allocate DILabel objects, and use
insertLabel() to insert llvm.dbg.label intrinsic in LLVM IR.
Differential Revision: https://reviews.llvm.org/D45024
Patch by Hsiangkai Wang.
llvm-svn: 331841
2018-05-09 10:40:45 +08:00
|
|
|
MDTuple *RetainedNodes = getTuple();
|
2017-04-27 06:56:44 +08:00
|
|
|
MDTuple *ThrownTypes = getTuple();
|
2016-04-15 23:57:41 +08:00
|
|
|
DICompileUnit *Unit = getUnit();
|
2018-11-20 02:29:28 +08:00
|
|
|
DISubprogram::DISPFlags SPFlags =
|
|
|
|
static_cast<DISubprogram::DISPFlags>(Virtuality);
|
|
|
|
assert(!IsLocalToUnit && IsDefinition && !IsOptimized &&
|
|
|
|
"bools and SPFlags have to match");
|
|
|
|
SPFlags |= DISubprogram::SPFlagDefinition;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2017-04-27 06:56:44 +08:00
|
|
|
auto *N = DISubprogram::get(
|
2018-11-20 02:29:28 +08:00
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type, ScopeLine,
|
|
|
|
ContainingType, VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes, ThrownTypes);
|
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());
|
2016-07-01 10:41:21 +08:00
|
|
|
EXPECT_EQ(ThisAdjustment, N->getThisAdjustment());
|
2015-02-10 08:52:32 +08:00
|
|
|
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());
|
[DebugInfo] Add DILabel metadata and intrinsic llvm.dbg.label.
In order to set breakpoints on labels and list source code around
labels, we need collect debug information for labels, i.e., label
name, the function label belong, line number in the file, and the
address label located. In order to keep these information in LLVM
IR and to allow backend to generate debug information correctly.
We create a new kind of metadata for labels, DILabel. The format
of DILabel is
!DILabel(scope: !1, name: "foo", file: !2, line: 3)
We hope to keep debug information as much as possible even the
code is optimized. So, we create a new kind of intrinsic for label
metadata to avoid the metadata is eliminated with basic block.
The intrinsic will keep existing if we keep it from optimized out.
The format of the intrinsic is
llvm.dbg.label(metadata !1)
It has only one argument, that is the DILabel metadata. The
intrinsic will follow the label immediately. Backend could get the
label metadata through the intrinsic's parameter.
We also create DIBuilder API for labels to be used by Frontend.
Frontend could use createLabel() to allocate DILabel objects, and use
insertLabel() to insert llvm.dbg.label intrinsic in LLVM IR.
Differential Revision: https://reviews.llvm.org/D45024
Patch by Hsiangkai Wang.
llvm-svn: 331841
2018-05-09 10:40:45 +08:00
|
|
|
EXPECT_EQ(RetainedNodes, N->getRetainedNodes().get());
|
2017-04-27 06:56:44 +08:00
|
|
|
EXPECT_EQ(ThrownTypes, N->getThrownTypes().get());
|
2018-11-20 02:29:28 +08:00
|
|
|
EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes,
|
|
|
|
ThrownTypes));
|
2016-07-01 10:41:21 +08:00
|
|
|
|
2018-11-20 02:29:28 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,
|
|
|
|
File, Line, Type, ScopeLine, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,
|
|
|
|
Line, Type, ScopeLine, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,
|
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes,
|
|
|
|
ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
|
|
|
|
Line, Type, ScopeLine, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line + 1, Type, ScopeLine, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2018-11-20 02:29:28 +08:00
|
|
|
getSubroutineType(), ScopeLine, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
2017-04-27 06:56:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type,
|
2018-11-20 02:29:28 +08:00
|
|
|
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
|
|
|
|
Flags, SPFlags ^ DISubprogram::SPFlagLocalToUnit, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes, ThrownTypes));
|
2017-04-27 06:56:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type,
|
2018-11-20 02:29:28 +08:00
|
|
|
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
|
|
|
|
Flags, SPFlags ^ DISubprogram::SPFlagDefinition, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine + 1, ContainingType,
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine, getCompositeType(),
|
|
|
|
VirtualIndex, ThisAdjustment, Flags, SPFlags,
|
|
|
|
Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
2016-07-01 10:41:21 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type,
|
2018-11-20 02:29:28 +08:00
|
|
|
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
|
|
|
|
Flags, SPFlags ^ DISubprogram::SPFlagVirtual, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes, ThrownTypes));
|
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine, ContainingType,
|
|
|
|
VirtualIndex + 1, ThisAdjustment, Flags,
|
|
|
|
SPFlags, Unit, TemplateParams, Declaration,
|
|
|
|
RetainedNodes, ThrownTypes));
|
2017-04-27 06:56:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type,
|
2018-11-20 02:29:28 +08:00
|
|
|
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
|
|
|
|
Flags, SPFlags ^ DISubprogram::SPFlagOptimized, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes, ThrownTypes));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2018-11-20 02:29:28 +08:00
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, nullptr,
|
[DebugInfo] Add DILabel metadata and intrinsic llvm.dbg.label.
In order to set breakpoints on labels and list source code around
labels, we need collect debug information for labels, i.e., label
name, the function label belong, line number in the file, and the
address label located. In order to keep these information in LLVM
IR and to allow backend to generate debug information correctly.
We create a new kind of metadata for labels, DILabel. The format
of DILabel is
!DILabel(scope: !1, name: "foo", file: !2, line: 3)
We hope to keep debug information as much as possible even the
code is optimized. So, we create a new kind of intrinsic for label
metadata to avoid the metadata is eliminated with basic block.
The intrinsic will keep existing if we keep it from optimized out.
The format of the intrinsic is
llvm.dbg.label(metadata !1)
It has only one argument, that is the DILabel metadata. The
intrinsic will follow the label immediately. Backend could get the
label metadata through the intrinsic's parameter.
We also create DIBuilder API for labels to be used by Frontend.
Frontend could use createLabel() to allocate DILabel objects, and use
insertLabel() to insert llvm.dbg.label intrinsic in LLVM IR.
Differential Revision: https://reviews.llvm.org/D45024
Patch by Hsiangkai Wang.
llvm-svn: 331841
2018-05-09 10:40:45 +08:00
|
|
|
TemplateParams, Declaration, RetainedNodes,
|
2017-04-27 06:56:44 +08:00
|
|
|
ThrownTypes));
|
2018-11-20 02:29:28 +08:00
|
|
|
EXPECT_NE(N,
|
|
|
|
DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit, getTuple(),
|
|
|
|
Declaration, RetainedNodes, ThrownTypes));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2018-11-20 02:29:28 +08:00
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit,
|
[DebugInfo] Add DILabel metadata and intrinsic llvm.dbg.label.
In order to set breakpoints on labels and list source code around
labels, we need collect debug information for labels, i.e., label
name, the function label belong, line number in the file, and the
address label located. In order to keep these information in LLVM
IR and to allow backend to generate debug information correctly.
We create a new kind of metadata for labels, DILabel. The format
of DILabel is
!DILabel(scope: !1, name: "foo", file: !2, line: 3)
We hope to keep debug information as much as possible even the
code is optimized. So, we create a new kind of intrinsic for label
metadata to avoid the metadata is eliminated with basic block.
The intrinsic will keep existing if we keep it from optimized out.
The format of the intrinsic is
llvm.dbg.label(metadata !1)
It has only one argument, that is the DILabel metadata. The
intrinsic will follow the label immediately. Backend could get the
label metadata through the intrinsic's parameter.
We also create DIBuilder API for labels to be used by Frontend.
Frontend could use createLabel() to allocate DILabel objects, and use
insertLabel() to insert llvm.dbg.label intrinsic in LLVM IR.
Differential Revision: https://reviews.llvm.org/D45024
Patch by Hsiangkai Wang.
llvm-svn: 331841
2018-05-09 10:40:45 +08:00
|
|
|
TemplateParams, getSubprogram(), RetainedNodes,
|
2017-04-27 06:56:44 +08:00
|
|
|
ThrownTypes));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
2018-11-20 02:29:28 +08:00
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit,
|
2016-07-01 10:41:21 +08:00
|
|
|
TemplateParams, Declaration, getTuple()));
|
2018-11-20 02:29:28 +08:00
|
|
|
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
|
|
|
|
Type, ScopeLine, ContainingType, VirtualIndex,
|
|
|
|
ThisAdjustment, Flags, SPFlags, Unit,
|
|
|
|
TemplateParams, Declaration, RetainedNodes,
|
|
|
|
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();
|
2015-02-10 08:52:32 +08:00
|
|
|
StringRef Name = "namespace";
|
2016-11-04 03:42:02 +08:00
|
|
|
bool ExportSymbols = true;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2017-04-29 06:25:46 +08:00
|
|
|
auto *N = DINamespace::get(Context, Scope, Name, ExportSymbols);
|
2015-02-10 08:52:32 +08:00
|
|
|
|
|
|
|
EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
|
|
|
|
EXPECT_EQ(Scope, N->getScope());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
2017-04-29 06:25:46 +08:00
|
|
|
EXPECT_EQ(N, DINamespace::get(Context, Scope, Name, ExportSymbols));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, getFile(), Name, ExportSymbols));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, Scope, "other", ExportSymbols));
|
|
|
|
EXPECT_NE(N, DINamespace::get(Context, Scope, Name, !ExportSymbols));
|
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;
|
2018-10-04 02:44:53 +08:00
|
|
|
MDTuple *templateParams = getTuple();
|
2015-04-30 00:38:44 +08:00
|
|
|
DIDerivedType *StaticDataMemberDeclaration =
|
|
|
|
cast<DIDerivedType>(getDerivedType());
|
2018-10-04 02:44:53 +08:00
|
|
|
|
2016-10-27 05:32:29 +08:00
|
|
|
uint32_t AlignInBits = 8;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2018-10-04 02:44:53 +08:00
|
|
|
auto *N = DIGlobalVariable::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
|
|
|
|
|
2015-02-10 08:52:32 +08:00
|
|
|
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(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
|
2018-10-04 02:44:53 +08:00
|
|
|
EXPECT_EQ(templateParams, N->getTemplateParams());
|
2016-10-20 08:13:12 +08:00
|
|
|
EXPECT_EQ(AlignInBits, N->getAlignInBits());
|
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,
|
2018-10-04 02:44:53 +08:00
|
|
|
StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2018-10-04 02:44:53 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(
|
|
|
|
Context, getSubprogram(), Name, LinkageName, File, Line,
|
|
|
|
Type, IsLocalToUnit, IsDefinition,
|
|
|
|
StaticDataMemberDeclaration, templateParams, AlignInBits));
|
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,
|
2018-10-04 02:44:53 +08:00
|
|
|
StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,
|
2016-12-20 10:09:43 +08:00
|
|
|
Type, IsLocalToUnit, IsDefinition,
|
2018-10-04 02:44:53 +08:00
|
|
|
StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName,
|
|
|
|
getFile(), Line, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line + 1, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line, getDerivedType(), IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
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,
|
2018-10-04 02:44:53 +08:00
|
|
|
StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
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,
|
2018-10-04 02:44:53 +08:00
|
|
|
StaticDataMemberDeclaration,
|
|
|
|
templateParams, AlignInBits));
|
2016-09-13 09:12:59 +08:00
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
2016-12-20 10:09:43 +08:00
|
|
|
cast<DIDerivedType>(getDerivedType()),
|
2018-10-04 02:44:53 +08:00
|
|
|
templateParams, AlignInBits));
|
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
|
|
|
StaticDataMemberDeclaration, nullptr,
|
2016-10-20 08:13:12 +08:00
|
|
|
AlignInBits));
|
|
|
|
EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
|
|
|
|
Line, Type, IsLocalToUnit, IsDefinition,
|
2016-12-20 10:09:43 +08:00
|
|
|
StaticDataMemberDeclaration,
|
2018-10-04 02:44:53 +08:00
|
|
|
templateParams, (AlignInBits << 1)));
|
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
|
|
|
}
|
|
|
|
|
2016-12-20 10:09:43 +08:00
|
|
|
typedef MetadataTest DIGlobalVariableExpressionTest;
|
|
|
|
|
|
|
|
TEST_F(DIGlobalVariableExpressionTest, get) {
|
|
|
|
DIScope *Scope = getSubprogram();
|
|
|
|
StringRef Name = "name";
|
|
|
|
StringRef LinkageName = "linkage";
|
|
|
|
DIFile *File = getFile();
|
|
|
|
unsigned Line = 5;
|
|
|
|
DIType *Type = getDerivedType();
|
|
|
|
bool IsLocalToUnit = false;
|
|
|
|
bool IsDefinition = true;
|
2018-10-04 02:44:53 +08:00
|
|
|
MDTuple *templateParams = getTuple();
|
2016-12-20 10:09:43 +08:00
|
|
|
auto *Expr = DIExpression::get(Context, {1, 2});
|
|
|
|
auto *Expr2 = DIExpression::get(Context, {1, 2, 3});
|
|
|
|
DIDerivedType *StaticDataMemberDeclaration =
|
|
|
|
cast<DIDerivedType>(getDerivedType());
|
|
|
|
uint32_t AlignInBits = 8;
|
|
|
|
|
2018-10-04 02:44:53 +08:00
|
|
|
auto *Var = DIGlobalVariable::get(
|
|
|
|
Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
|
|
|
|
auto *Var2 = DIGlobalVariable::get(
|
|
|
|
Context, Scope, "other", LinkageName, File, Line, Type, IsLocalToUnit,
|
|
|
|
IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
|
2016-12-20 10:09:43 +08:00
|
|
|
auto *N = DIGlobalVariableExpression::get(Context, Var, Expr);
|
|
|
|
|
|
|
|
EXPECT_EQ(Var, N->getVariable());
|
|
|
|
EXPECT_EQ(Expr, N->getExpression());
|
|
|
|
EXPECT_EQ(N, DIGlobalVariableExpression::get(Context, Var, Expr));
|
|
|
|
EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var2, Expr));
|
|
|
|
EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var, Expr2));
|
|
|
|
|
|
|
|
TempDIGlobalVariableExpression Temp = N->clone();
|
|
|
|
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
|
|
|
|
}
|
|
|
|
|
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;
|
2016-09-06 18:46:28 +08:00
|
|
|
DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
|
2016-10-27 05:32:29 +08:00
|
|
|
uint32_t AlignInBits = 8;
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-08-01 02:58:39 +08:00
|
|
|
auto *N =
|
2016-10-20 08:13:12 +08:00
|
|
|
DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg, Flags,
|
|
|
|
AlignInBits);
|
2015-08-01 02:58:39 +08:00
|
|
|
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());
|
2016-10-20 08:13:12 +08:00
|
|
|
EXPECT_EQ(AlignInBits, N->getAlignInBits());
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_EQ(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg,
|
2016-10-20 08:13:12 +08:00
|
|
|
Flags, AlignInBits));
|
2015-02-10 08:52:32 +08:00
|
|
|
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_FALSE(
|
2016-10-20 08:13:12 +08:00
|
|
|
DILocalVariable::get(Context, Scope, Name, File, Line, Type, 0, Flags,
|
|
|
|
AlignInBits)->isParameter());
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, getSubprogram(), Name, File, Line,
|
2016-10-20 08:13:12 +08:00
|
|
|
Type, Arg, Flags, AlignInBits));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, "other", File, Line, Type,
|
2016-10-20 08:13:12 +08:00
|
|
|
Arg, Flags, AlignInBits));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, getFile(), Line, Type,
|
2016-10-20 08:13:12 +08:00
|
|
|
Arg, Flags, AlignInBits));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line + 1, Type,
|
2016-10-20 08:13:12 +08:00
|
|
|
Arg, Flags, AlignInBits));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line,
|
2016-10-20 08:13:12 +08:00
|
|
|
getDerivedType(), Arg, Flags, AlignInBits));
|
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type,
|
|
|
|
Arg + 1, Flags, AlignInBits));
|
2015-08-01 02:58:39 +08:00
|
|
|
EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type,
|
2016-10-20 08:13:12 +08:00
|
|
|
Arg, Flags, (AlignInBits << 1)));
|
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(),
|
2016-10-20 08:13:12 +08:00
|
|
|
0, nullptr, 255, DINode::FlagZero, 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(),
|
2016-10-20 08:13:12 +08:00
|
|
|
0, nullptr, 256, DINode::FlagZero, 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(),
|
2016-10-20 08:13:12 +08:00
|
|
|
0, nullptr, 257, DINode::FlagZero, 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(),
|
2016-10-20 08:13:12 +08:00
|
|
|
0, nullptr, Max, DINode::FlagZero, 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)));
|
2017-12-09 05:58:18 +08:00
|
|
|
|
|
|
|
// Test DIExpression::prepend().
|
|
|
|
uint64_t Elts0[] = {dwarf::DW_OP_LLVM_fragment, 0, 32};
|
|
|
|
auto *N0 = DIExpression::get(Context, Elts0);
|
2018-07-27 04:56:53 +08:00
|
|
|
auto *N0WithPrependedOps = DIExpression::prepend(N0, true, 64, true, true);
|
2017-12-09 05:58:18 +08:00
|
|
|
uint64_t Elts1[] = {dwarf::DW_OP_deref,
|
|
|
|
dwarf::DW_OP_plus_uconst, 64,
|
|
|
|
dwarf::DW_OP_deref,
|
|
|
|
dwarf::DW_OP_stack_value,
|
|
|
|
dwarf::DW_OP_LLVM_fragment, 0, 32};
|
|
|
|
auto *N1 = DIExpression::get(Context, Elts1);
|
2018-07-27 04:56:53 +08:00
|
|
|
EXPECT_EQ(N0WithPrependedOps, N1);
|
|
|
|
|
|
|
|
// Test DIExpression::append().
|
|
|
|
uint64_t Elts2[] = {dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 64,
|
|
|
|
dwarf::DW_OP_deref, dwarf::DW_OP_stack_value};
|
|
|
|
auto *N2 = DIExpression::append(N0, Elts2);
|
|
|
|
EXPECT_EQ(N0WithPrependedOps, N2);
|
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.
|
2017-06-14 00:54:44 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_plus_uconst, 6);
|
2017-06-14 21:14:38 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_constu, 6, dwarf::DW_OP_plus);
|
2015-02-13 09:07:46 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref);
|
2016-12-06 02:04:47 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_LLVM_fragment, 3, 7);
|
2017-06-14 21:14:38 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_plus_uconst, 6, dwarf::DW_OP_deref);
|
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 6);
|
2016-12-06 02:04:47 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_LLVM_fragment, 3, 7);
|
2017-06-14 21:14:38 +08:00
|
|
|
EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 6,
|
2016-12-06 02:04:47 +08:00
|
|
|
dwarf::DW_OP_LLVM_fragment, 3, 7);
|
2015-02-13 09:07:46 +08:00
|
|
|
|
|
|
|
// Invalid constructions.
|
|
|
|
EXPECT_INVALID(~0u);
|
2017-06-14 21:14:38 +08:00
|
|
|
EXPECT_INVALID(dwarf::DW_OP_plus, 0);
|
2017-06-14 00:54:44 +08:00
|
|
|
EXPECT_INVALID(dwarf::DW_OP_plus_uconst);
|
2016-12-06 02:04:47 +08:00
|
|
|
EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment);
|
|
|
|
EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3);
|
2017-06-14 21:14:38 +08:00
|
|
|
EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3, 7, dwarf::DW_OP_plus_uconst, 3);
|
2016-12-06 02:04:47 +08:00
|
|
|
EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3, 7, dwarf::DW_OP_deref);
|
2015-02-13 09:07:46 +08:00
|
|
|
|
|
|
|
#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();
|
2017-07-19 08:09:54 +08:00
|
|
|
DIFile *File = getFile();
|
2015-02-10 08:52:32 +08:00
|
|
|
unsigned Line = 5;
|
|
|
|
StringRef Name = "name";
|
|
|
|
|
2017-07-19 08:09:54 +08:00
|
|
|
auto *N =
|
|
|
|
DIImportedEntity::get(Context, Tag, Scope, Entity, File, 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());
|
2017-07-19 08:09:54 +08:00
|
|
|
EXPECT_EQ(File, N->getFile());
|
2015-02-10 08:52:32 +08:00
|
|
|
EXPECT_EQ(Line, N->getLine());
|
|
|
|
EXPECT_EQ(Name, N->getName());
|
2017-07-19 08:09:54 +08:00
|
|
|
EXPECT_EQ(
|
|
|
|
N, DIImportedEntity::get(Context, Tag, Scope, Entity, File, 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,
|
2017-07-19 08:09:54 +08:00
|
|
|
Scope, Entity, File, Line, Name));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, getSubprogram(), Entity,
|
2017-07-19 08:09:54 +08:00
|
|
|
File, Line, Name));
|
2015-04-30 00:38:44 +08:00
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, getCompositeType(),
|
2017-07-19 08:09:54 +08:00
|
|
|
File, Line, Name));
|
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, nullptr, Line,
|
|
|
|
Name));
|
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File,
|
|
|
|
Line + 1, Name));
|
|
|
|
EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File, 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());
|
2018-01-18 06:24:23 +08:00
|
|
|
F->setEntryCount(12304, Function::PCT_Real);
|
|
|
|
auto Count = F->getEntryCount();
|
|
|
|
EXPECT_TRUE(Count.hasValue());
|
|
|
|
EXPECT_EQ(12304u, Count.getCount());
|
|
|
|
EXPECT_EQ(Function::PCT_Real, Count.getType());
|
|
|
|
|
|
|
|
// Repeat the same for synthetic counts.
|
|
|
|
F = getFunction("bar");
|
|
|
|
EXPECT_FALSE(F->getEntryCount().hasValue());
|
|
|
|
F->setEntryCount(123, Function::PCT_Synthetic);
|
2019-04-25 03:51:16 +08:00
|
|
|
Count = F->getEntryCount(true /*allow synthetic*/);
|
2018-01-18 06:24:23 +08:00
|
|
|
EXPECT_TRUE(Count.hasValue());
|
|
|
|
EXPECT_EQ(123u, Count.getCount());
|
|
|
|
EXPECT_EQ(Function::PCT_Synthetic, Count.getType());
|
2015-05-13 23:13:45 +08:00
|
|
|
}
|
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:14:07 +08:00
|
|
|
// Test various assertions in metadata tracking. Don't run these tests if gtest
|
|
|
|
// will use SEH to recover from them. Two of these tests get halfway through
|
|
|
|
// inserting metadata into DenseMaps for tracking purposes, and then they
|
|
|
|
// assert, and we attempt to destroy an LLVMContext with broken invariants,
|
|
|
|
// leading to infinite loops.
|
|
|
|
#if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG) && !defined(GTEST_HAS_SEH)
|
2016-04-23 12:15:56 +08:00
|
|
|
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:02:39 +08:00
|
|
|
} // end namespace
|