2002-04-08 06:31:46 +08:00
|
|
|
//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
2014-01-07 20:34:26 +08:00
|
|
|
// This library implements the functionality defined in llvm/IR/Writer.h
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
2002-04-13 02:21:53 +08:00
|
|
|
// Note that these routines must be extremely tolerant of various errors in the
|
2003-05-08 10:44:12 +08:00
|
|
|
// LLVM code, because it can be used for debugging transformations.
|
2002-04-13 02:21:53 +08:00
|
|
|
//
|
2001-06-07 04:29:01 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2015-03-18 03:53:41 +08:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2014-01-07 20:34:26 +08:00
|
|
|
#include "llvm/IR/AssemblyAnnotationWriter.h"
|
2014-03-04 19:45:46 +08:00
|
|
|
#include "llvm/IR/CFG.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/CallingConv.h"
|
|
|
|
#include "llvm/IR/Constants.h"
|
2014-03-06 08:46:21 +08:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-01-12 19:10:32 +08:00
|
|
|
#include "llvm/IR/IRPrintingPasses.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/Operator.h"
|
2015-05-05 21:20:42 +08:00
|
|
|
#include "llvm/IR/Statepoint.h"
|
2013-01-07 23:43:51 +08:00
|
|
|
#include "llvm/IR/TypeFinder.h"
|
2015-03-18 03:53:41 +08:00
|
|
|
#include "llvm/IR/UseListOrder.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/ValueSymbolTable.h"
|
2010-01-05 09:29:26 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-10-01 04:16:54 +08:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2009-07-09 02:01:40 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-08-13 01:23:50 +08:00
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2015-03-24 03:32:43 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2001-09-08 00:36:04 +08:00
|
|
|
#include <algorithm>
|
2007-05-23 03:27:35 +08:00
|
|
|
#include <cctype>
|
2003-11-22 04:23:48 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2005-05-16 00:13:11 +08:00
|
|
|
// Make virtual table appear in this compilation unit.
|
|
|
|
AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helper Functions
|
|
|
|
//===----------------------------------------------------------------------===//
|
2004-07-04 19:50:43 +08:00
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
namespace {
|
|
|
|
struct OrderMap {
|
|
|
|
DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
|
|
|
|
|
|
|
|
unsigned size() const { return IDs.size(); }
|
|
|
|
std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
|
|
|
|
std::pair<unsigned, bool> lookup(const Value *V) const {
|
|
|
|
return IDs.lookup(V);
|
|
|
|
}
|
|
|
|
void index(const Value *V) {
|
|
|
|
// Explicitly sequence get-size and insert-value operations to avoid UB.
|
|
|
|
unsigned ID = IDs.size() + 1;
|
|
|
|
IDs[V].first = ID;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
static void orderValue(const Value *V, OrderMap &OM) {
|
|
|
|
if (OM.lookup(V).first)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (const Constant *C = dyn_cast<Constant>(V))
|
|
|
|
if (C->getNumOperands() && !isa<GlobalValue>(C))
|
|
|
|
for (const Value *Op : C->operands())
|
|
|
|
if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
|
|
|
|
orderValue(Op, OM);
|
|
|
|
|
|
|
|
// Note: we cannot cache this lookup above, since inserting into the map
|
|
|
|
// changes the map's size, and thus affects the other IDs.
|
|
|
|
OM.index(V);
|
|
|
|
}
|
|
|
|
|
|
|
|
static OrderMap orderModule(const Module *M) {
|
|
|
|
// This needs to match the order used by ValueEnumerator::ValueEnumerator()
|
|
|
|
// and ValueEnumerator::incorporateFunction().
|
|
|
|
OrderMap OM;
|
|
|
|
|
|
|
|
for (const GlobalVariable &G : M->globals()) {
|
|
|
|
if (G.hasInitializer())
|
|
|
|
if (!isa<GlobalValue>(G.getInitializer()))
|
|
|
|
orderValue(G.getInitializer(), OM);
|
|
|
|
orderValue(&G, OM);
|
|
|
|
}
|
|
|
|
for (const GlobalAlias &A : M->aliases()) {
|
|
|
|
if (!isa<GlobalValue>(A.getAliasee()))
|
|
|
|
orderValue(A.getAliasee(), OM);
|
|
|
|
orderValue(&A, OM);
|
|
|
|
}
|
|
|
|
for (const Function &F : *M) {
|
|
|
|
if (F.hasPrefixData())
|
|
|
|
if (!isa<GlobalValue>(F.getPrefixData()))
|
|
|
|
orderValue(F.getPrefixData(), OM);
|
2014-12-03 10:08:38 +08:00
|
|
|
|
|
|
|
if (F.hasPrologueData())
|
|
|
|
if (!isa<GlobalValue>(F.getPrologueData()))
|
|
|
|
orderValue(F.getPrologueData(), OM);
|
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
orderValue(&F, OM);
|
|
|
|
|
|
|
|
if (F.isDeclaration())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (const Argument &A : F.args())
|
|
|
|
orderValue(&A, OM);
|
|
|
|
for (const BasicBlock &BB : F) {
|
|
|
|
orderValue(&BB, OM);
|
|
|
|
for (const Instruction &I : BB) {
|
|
|
|
for (const Value *Op : I.operands())
|
|
|
|
if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
|
|
|
|
isa<InlineAsm>(*Op))
|
|
|
|
orderValue(Op, OM);
|
|
|
|
orderValue(&I, OM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return OM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void predictValueUseListOrderImpl(const Value *V, const Function *F,
|
|
|
|
unsigned ID, const OrderMap &OM,
|
|
|
|
UseListOrderStack &Stack) {
|
|
|
|
// Predict use-list order for this one.
|
|
|
|
typedef std::pair<const Use *, unsigned> Entry;
|
|
|
|
SmallVector<Entry, 64> List;
|
|
|
|
for (const Use &U : V->uses())
|
|
|
|
// Check if this user will be serialized.
|
|
|
|
if (OM.lookup(U.getUser()).first)
|
|
|
|
List.push_back(std::make_pair(&U, List.size()));
|
|
|
|
|
|
|
|
if (List.size() < 2)
|
|
|
|
// We may have lost some users.
|
|
|
|
return;
|
|
|
|
|
|
|
|
bool GetsReversed =
|
|
|
|
!isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
|
|
|
|
if (auto *BA = dyn_cast<BlockAddress>(V))
|
|
|
|
ID = OM.lookup(BA->getBasicBlock()).first;
|
|
|
|
std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) {
|
|
|
|
const Use *LU = L.first;
|
|
|
|
const Use *RU = R.first;
|
|
|
|
if (LU == RU)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto LID = OM.lookup(LU->getUser()).first;
|
|
|
|
auto RID = OM.lookup(RU->getUser()).first;
|
|
|
|
|
|
|
|
// If ID is 4, then expect: 7 6 5 1 2 3.
|
|
|
|
if (LID < RID) {
|
|
|
|
if (GetsReversed)
|
|
|
|
if (RID <= ID)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (RID < LID) {
|
|
|
|
if (GetsReversed)
|
|
|
|
if (LID <= ID)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// LID and RID are equal, so we have different operands of the same user.
|
|
|
|
// Assume operands are added in order for all instructions.
|
|
|
|
if (GetsReversed)
|
|
|
|
if (LID <= ID)
|
|
|
|
return LU->getOperandNo() < RU->getOperandNo();
|
|
|
|
return LU->getOperandNo() > RU->getOperandNo();
|
|
|
|
});
|
|
|
|
|
|
|
|
if (std::is_sorted(
|
|
|
|
List.begin(), List.end(),
|
|
|
|
[](const Entry &L, const Entry &R) { return L.second < R.second; }))
|
|
|
|
// Order is already correct.
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Store the shuffle.
|
|
|
|
Stack.emplace_back(V, F, List.size());
|
|
|
|
assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
|
|
|
|
for (size_t I = 0, E = List.size(); I != E; ++I)
|
|
|
|
Stack.back().Shuffle[I] = List[I].second;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void predictValueUseListOrder(const Value *V, const Function *F,
|
|
|
|
OrderMap &OM, UseListOrderStack &Stack) {
|
|
|
|
auto &IDPair = OM[V];
|
|
|
|
assert(IDPair.first && "Unmapped value");
|
|
|
|
if (IDPair.second)
|
|
|
|
// Already predicted.
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Do the actual prediction.
|
|
|
|
IDPair.second = true;
|
|
|
|
if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())
|
|
|
|
predictValueUseListOrderImpl(V, F, IDPair.first, OM, Stack);
|
|
|
|
|
|
|
|
// Recursive descent into constants.
|
|
|
|
if (const Constant *C = dyn_cast<Constant>(V))
|
|
|
|
if (C->getNumOperands()) // Visit GlobalValues.
|
|
|
|
for (const Value *Op : C->operands())
|
|
|
|
if (isa<Constant>(Op)) // Visit GlobalValues.
|
|
|
|
predictValueUseListOrder(Op, F, OM, Stack);
|
|
|
|
}
|
|
|
|
|
|
|
|
static UseListOrderStack predictUseListOrder(const Module *M) {
|
|
|
|
OrderMap OM = orderModule(M);
|
|
|
|
|
|
|
|
// Use-list orders need to be serialized after all the users have been added
|
|
|
|
// to a value, or else the shuffles will be incomplete. Store them per
|
|
|
|
// function in a stack.
|
|
|
|
//
|
|
|
|
// Aside from function order, the order of values doesn't matter much here.
|
|
|
|
UseListOrderStack Stack;
|
|
|
|
|
|
|
|
// We want to visit the functions backward now so we can list function-local
|
|
|
|
// constants in the last Function they're used in. Module-level constants
|
|
|
|
// have already been visited above.
|
|
|
|
for (auto I = M->rbegin(), E = M->rend(); I != E; ++I) {
|
|
|
|
const Function &F = *I;
|
|
|
|
if (F.isDeclaration())
|
|
|
|
continue;
|
|
|
|
for (const BasicBlock &BB : F)
|
|
|
|
predictValueUseListOrder(&BB, &F, OM, Stack);
|
|
|
|
for (const Argument &A : F.args())
|
|
|
|
predictValueUseListOrder(&A, &F, OM, Stack);
|
|
|
|
for (const BasicBlock &BB : F)
|
|
|
|
for (const Instruction &I : BB)
|
|
|
|
for (const Value *Op : I.operands())
|
|
|
|
if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
|
|
|
|
predictValueUseListOrder(Op, &F, OM, Stack);
|
|
|
|
for (const BasicBlock &BB : F)
|
|
|
|
for (const Instruction &I : BB)
|
|
|
|
predictValueUseListOrder(&I, &F, OM, Stack);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Visit globals last.
|
|
|
|
for (const GlobalVariable &G : M->globals())
|
|
|
|
predictValueUseListOrder(&G, nullptr, OM, Stack);
|
|
|
|
for (const Function &F : *M)
|
|
|
|
predictValueUseListOrder(&F, nullptr, OM, Stack);
|
|
|
|
for (const GlobalAlias &A : M->aliases())
|
|
|
|
predictValueUseListOrder(&A, nullptr, OM, Stack);
|
|
|
|
for (const GlobalVariable &G : M->globals())
|
|
|
|
if (G.hasInitializer())
|
|
|
|
predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
|
|
|
|
for (const GlobalAlias &A : M->aliases())
|
|
|
|
predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
|
|
|
|
for (const Function &F : *M)
|
|
|
|
if (F.hasPrefixData())
|
|
|
|
predictValueUseListOrder(F.getPrefixData(), nullptr, OM, Stack);
|
|
|
|
|
|
|
|
return Stack;
|
|
|
|
}
|
|
|
|
|
2001-10-30 00:37:48 +08:00
|
|
|
static const Module *getModuleFromVal(const Value *V) {
|
2003-07-23 23:30:06 +08:00
|
|
|
if (const Argument *MA = dyn_cast<Argument>(V))
|
2014-04-09 14:08:46 +08:00
|
|
|
return MA->getParent() ? MA->getParent()->getParent() : nullptr;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
|
2014-04-09 14:08:46 +08:00
|
|
|
return BB->getParent() ? BB->getParent()->getParent() : nullptr;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(V)) {
|
2014-04-09 14:08:46 +08:00
|
|
|
const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
|
|
|
|
return M ? M->getParent() : nullptr;
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
|
2001-10-30 00:37:48 +08:00
|
|
|
return GV->getParent();
|
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
|
|
|
|
|
|
|
if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
|
|
|
|
for (const User *U : MAV->users())
|
|
|
|
if (isa<Instruction>(U))
|
|
|
|
if (const Module *M = getModuleFromVal(U))
|
|
|
|
return M;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-04-09 14:08:46 +08:00
|
|
|
return nullptr;
|
2001-10-30 00:37:48 +08:00
|
|
|
}
|
|
|
|
|
2013-02-20 15:21:42 +08:00
|
|
|
static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
|
2012-09-13 23:11:12 +08:00
|
|
|
switch (cc) {
|
2013-02-20 15:21:42 +08:00
|
|
|
default: Out << "cc" << cc; break;
|
|
|
|
case CallingConv::Fast: Out << "fastcc"; break;
|
|
|
|
case CallingConv::Cold: Out << "coldcc"; break;
|
2013-11-12 06:40:22 +08:00
|
|
|
case CallingConv::WebKit_JS: Out << "webkit_jscc"; break;
|
|
|
|
case CallingConv::AnyReg: Out << "anyregcc"; break;
|
2014-01-18 03:47:03 +08:00
|
|
|
case CallingConv::PreserveMost: Out << "preserve_mostcc"; break;
|
|
|
|
case CallingConv::PreserveAll: Out << "preserve_allcc"; break;
|
2014-12-02 05:04:44 +08:00
|
|
|
case CallingConv::GHC: Out << "ghccc"; break;
|
2013-02-20 15:21:42 +08:00
|
|
|
case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break;
|
|
|
|
case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break;
|
|
|
|
case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break;
|
2014-10-28 09:29:26 +08:00
|
|
|
case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
|
2013-02-20 15:21:42 +08:00
|
|
|
case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break;
|
|
|
|
case CallingConv::ARM_APCS: Out << "arm_apcscc"; break;
|
|
|
|
case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break;
|
|
|
|
case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
|
|
|
|
case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break;
|
|
|
|
case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break;
|
|
|
|
case CallingConv::PTX_Device: Out << "ptx_device"; break;
|
2013-07-12 14:02:35 +08:00
|
|
|
case CallingConv::X86_64_SysV: Out << "x86_64_sysvcc"; break;
|
|
|
|
case CallingConv::X86_64_Win64: Out << "x86_64_win64cc"; break;
|
2013-12-15 18:01:20 +08:00
|
|
|
case CallingConv::SPIR_FUNC: Out << "spir_func"; break;
|
|
|
|
case CallingConv::SPIR_KERNEL: Out << "spir_kernel"; break;
|
2012-09-13 23:11:12 +08:00
|
|
|
}
|
|
|
|
}
|
2012-11-16 06:34:00 +08:00
|
|
|
|
2008-10-29 03:33:02 +08:00
|
|
|
// PrintEscapedString - Print each character of the specified string, escaping
|
|
|
|
// it if it is not printable or if it is an escape char.
|
2010-07-08 07:16:37 +08:00
|
|
|
static void PrintEscapedString(StringRef Name, raw_ostream &Out) {
|
2009-07-26 07:55:21 +08:00
|
|
|
for (unsigned i = 0, e = Name.size(); i != e; ++i) {
|
|
|
|
unsigned char C = Name[i];
|
2009-03-15 14:39:52 +08:00
|
|
|
if (isprint(C) && C != '\\' && C != '"')
|
2008-10-29 03:33:02 +08:00
|
|
|
Out << C;
|
|
|
|
else
|
|
|
|
Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-18 01:28:37 +08:00
|
|
|
enum PrefixType {
|
|
|
|
GlobalPrefix,
|
2014-06-28 02:19:56 +08:00
|
|
|
ComdatPrefix,
|
2008-08-18 01:28:37 +08:00
|
|
|
LabelPrefix,
|
2008-10-15 07:28:09 +08:00
|
|
|
LocalPrefix,
|
|
|
|
NoPrefix
|
2008-08-18 01:28:37 +08:00
|
|
|
};
|
|
|
|
|
2008-08-17 12:40:13 +08:00
|
|
|
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
|
|
|
|
/// prefixed with % (if the string only contains simple characters) or is
|
|
|
|
/// surrounded with ""'s (if it has special chars in it). Print it out.
|
2010-07-15 06:38:02 +08:00
|
|
|
static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
|
2011-04-24 22:30:00 +08:00
|
|
|
assert(!Name.empty() && "Cannot get empty name!");
|
2008-08-17 12:40:13 +08:00
|
|
|
switch (Prefix) {
|
2008-10-15 07:28:09 +08:00
|
|
|
case NoPrefix: break;
|
2008-08-19 13:16:28 +08:00
|
|
|
case GlobalPrefix: OS << '@'; break;
|
2014-06-28 02:19:56 +08:00
|
|
|
case ComdatPrefix: OS << '$'; break;
|
2008-08-19 13:16:28 +08:00
|
|
|
case LabelPrefix: break;
|
|
|
|
case LocalPrefix: OS << '%'; break;
|
2009-03-19 14:31:22 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-17 12:40:13 +08:00
|
|
|
// Scan the name to see if it needs quotes first.
|
2013-02-13 05:21:59 +08:00
|
|
|
bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
|
2008-08-17 12:40:13 +08:00
|
|
|
if (!NeedsQuotes) {
|
2009-07-26 07:55:21 +08:00
|
|
|
for (unsigned i = 0, e = Name.size(); i != e; ++i) {
|
2012-07-17 00:18:18 +08:00
|
|
|
// By making this unsigned, the value passed in to isalnum will always be
|
|
|
|
// in the range 0-255. This is important when building with MSVC because
|
|
|
|
// its implementation will assert. This situation can arise when dealing
|
|
|
|
// with UTF-8 multibyte characters.
|
|
|
|
unsigned char C = Name[i];
|
2013-02-13 05:21:59 +08:00
|
|
|
if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
|
|
|
|
C != '_') {
|
2008-08-17 12:40:13 +08:00
|
|
|
NeedsQuotes = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-17 12:40:13 +08:00
|
|
|
// If we didn't need any quotes, just write out the name in one blast.
|
|
|
|
if (!NeedsQuotes) {
|
2009-07-26 07:55:21 +08:00
|
|
|
OS << Name;
|
2008-08-17 12:40:13 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-17 12:40:13 +08:00
|
|
|
// Okay, we need quotes. Output the quotes and escape any scary characters as
|
|
|
|
// needed.
|
|
|
|
OS << '"';
|
2009-07-26 07:55:21 +08:00
|
|
|
PrintEscapedString(Name, OS);
|
2008-08-17 12:40:13 +08:00
|
|
|
OS << '"';
|
|
|
|
}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
|
|
|
|
/// prefixed with % (if the string only contains simple characters) or is
|
|
|
|
/// surrounded with ""'s (if it has special chars in it). Print it out.
|
2009-08-13 04:56:03 +08:00
|
|
|
static void PrintLLVMName(raw_ostream &OS, const Value *V) {
|
2009-09-20 10:20:51 +08:00
|
|
|
PrintLLVMName(OS, V->getName(),
|
2008-08-17 12:40:13 +08:00
|
|
|
isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
|
|
|
|
}
|
|
|
|
|
2009-03-01 06:34:45 +08:00
|
|
|
|
2015-03-18 03:53:41 +08:00
|
|
|
namespace {
|
|
|
|
class TypePrinting {
|
|
|
|
TypePrinting(const TypePrinting &) = delete;
|
|
|
|
void operator=(const TypePrinting&) = delete;
|
|
|
|
public:
|
|
|
|
|
|
|
|
/// NamedTypes - The named types that are used by the current module.
|
|
|
|
TypeFinder NamedTypes;
|
|
|
|
|
|
|
|
/// NumberedTypes - The numbered types, along with their value.
|
|
|
|
DenseMap<StructType*, unsigned> NumberedTypes;
|
|
|
|
|
2015-04-11 23:32:26 +08:00
|
|
|
TypePrinting() = default;
|
2015-03-18 03:53:41 +08:00
|
|
|
|
|
|
|
void incorporateTypes(const Module &M);
|
|
|
|
|
|
|
|
void print(Type *Ty, raw_ostream &OS);
|
|
|
|
|
|
|
|
void printStructBody(StructType *Ty, raw_ostream &OS);
|
|
|
|
};
|
|
|
|
} // namespace
|
2009-09-20 10:20:51 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
void TypePrinting::incorporateTypes(const Module &M) {
|
2012-08-03 08:30:35 +08:00
|
|
|
NamedTypes.run(M, false);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
// The list of struct types we got back includes all the struct types, split
|
|
|
|
// the unnamed ones out to a numbering and remove the anonymous structs.
|
|
|
|
unsigned NextNumber = 0;
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
|
|
|
|
for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
|
|
|
|
StructType *STy = *I;
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
// Ignore anonymous types.
|
2011-08-13 02:07:07 +08:00
|
|
|
if (STy->isLiteral())
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
continue;
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
if (STy->getName().empty())
|
|
|
|
NumberedTypes[STy] = NextNumber++;
|
|
|
|
else
|
|
|
|
*NextToUse++ = STy;
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
NamedTypes.erase(NextToUse, NamedTypes.end());
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
/// CalcTypeName - Write the specified type to the specified raw_ostream, making
|
|
|
|
/// use of type names or up references to shorten the type name where possible.
|
|
|
|
void TypePrinting::print(Type *Ty, raw_ostream &OS) {
|
2009-03-01 04:25:14 +08:00
|
|
|
switch (Ty->getTypeID()) {
|
2013-12-07 10:27:52 +08:00
|
|
|
case Type::VoidTyID: OS << "void"; return;
|
|
|
|
case Type::HalfTyID: OS << "half"; return;
|
|
|
|
case Type::FloatTyID: OS << "float"; return;
|
|
|
|
case Type::DoubleTyID: OS << "double"; return;
|
|
|
|
case Type::X86_FP80TyID: OS << "x86_fp80"; return;
|
|
|
|
case Type::FP128TyID: OS << "fp128"; return;
|
|
|
|
case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
|
|
|
|
case Type::LabelTyID: OS << "label"; return;
|
|
|
|
case Type::MetadataTyID: OS << "metadata"; return;
|
|
|
|
case Type::X86_MMXTyID: OS << "x86_mmx"; return;
|
2009-03-01 05:18:43 +08:00
|
|
|
case Type::IntegerTyID:
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2009-03-01 04:35:42 +08:00
|
|
|
case Type::FunctionTyID: {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
FunctionType *FTy = cast<FunctionType>(Ty);
|
|
|
|
print(FTy->getReturnType(), OS);
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << " (";
|
2009-03-01 04:35:42 +08:00
|
|
|
for (FunctionType::param_iterator I = FTy->param_begin(),
|
|
|
|
E = FTy->param_end(); I != E; ++I) {
|
|
|
|
if (I != FTy->param_begin())
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << ", ";
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
print(*I, OS);
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
2009-03-01 04:35:42 +08:00
|
|
|
if (FTy->isVarArg()) {
|
2009-03-01 05:27:31 +08:00
|
|
|
if (FTy->getNumParams()) OS << ", ";
|
|
|
|
OS << "...";
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << ')';
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-03-01 04:35:42 +08:00
|
|
|
}
|
|
|
|
case Type::StructTyID: {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
StructType *STy = cast<StructType>(Ty);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2011-08-13 02:07:07 +08:00
|
|
|
if (STy->isLiteral())
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return printStructBody(STy, OS);
|
|
|
|
|
|
|
|
if (!STy->getName().empty())
|
|
|
|
return PrintLLVMName(OS, STy->getName(), LocalPrefix);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
DenseMap<StructType*, unsigned>::iterator I = NumberedTypes.find(STy);
|
|
|
|
if (I != NumberedTypes.end())
|
|
|
|
OS << '%' << I->second;
|
|
|
|
else // Not enumerated, print the hex address.
|
2011-11-03 01:24:36 +08:00
|
|
|
OS << "%\"type " << STy << '\"';
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-03-01 04:35:42 +08:00
|
|
|
}
|
|
|
|
case Type::PointerTyID: {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
PointerType *PTy = cast<PointerType>(Ty);
|
|
|
|
print(PTy->getElementType(), OS);
|
2009-03-01 04:35:42 +08:00
|
|
|
if (unsigned AddressSpace = PTy->getAddressSpace())
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << " addrspace(" << AddressSpace << ')';
|
|
|
|
OS << '*';
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-03-01 04:35:42 +08:00
|
|
|
}
|
|
|
|
case Type::ArrayTyID: {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
ArrayType *ATy = cast<ArrayType>(Ty);
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << '[' << ATy->getNumElements() << " x ";
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
print(ATy->getElementType(), OS);
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << ']';
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-03-01 04:35:42 +08:00
|
|
|
}
|
|
|
|
case Type::VectorTyID: {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
VectorType *PTy = cast<VectorType>(Ty);
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << "<" << PTy->getNumElements() << " x ";
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
print(PTy->getElementType(), OS);
|
2009-03-01 05:27:31 +08:00
|
|
|
OS << '>';
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
return;
|
2009-03-01 04:35:42 +08:00
|
|
|
}
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
2013-12-07 10:27:52 +08:00
|
|
|
llvm_unreachable("Invalid TypeID");
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
|
|
|
|
if (STy->isOpaque()) {
|
|
|
|
OS << "opaque";
|
|
|
|
return;
|
2009-03-01 04:25:14 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
if (STy->isPacked())
|
|
|
|
OS << '<';
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
if (STy->getNumElements() == 0) {
|
|
|
|
OS << "{}";
|
|
|
|
} else {
|
|
|
|
StructType::element_iterator I = STy->element_begin();
|
|
|
|
OS << "{ ";
|
|
|
|
print(*I++, OS);
|
|
|
|
for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
|
|
|
|
OS << ", ";
|
|
|
|
print(*I, OS);
|
2009-03-01 07:20:19 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
OS << " }";
|
2009-03-01 07:20:19 +08:00
|
|
|
}
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
if (STy->isPacked())
|
|
|
|
OS << '>';
|
2009-03-01 07:20:19 +08:00
|
|
|
}
|
|
|
|
|
2015-03-18 03:53:41 +08:00
|
|
|
namespace {
|
2008-08-19 12:36:02 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SlotTracker Class: Enumerate slot numbers for unnamed values
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// This class provides computation of slot numbers for LLVM Assembly writing.
|
|
|
|
///
|
|
|
|
class SlotTracker {
|
|
|
|
public:
|
2009-07-09 05:44:25 +08:00
|
|
|
/// ValueMap - A mapping of Values to slot numbers.
|
2008-08-19 12:36:02 +08:00
|
|
|
typedef DenseMap<const Value*, unsigned> ValueMap;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
|
|
|
private:
|
2009-07-09 05:44:25 +08:00
|
|
|
/// TheModule - The module for which we are holding slot numbers.
|
2008-08-19 12:36:02 +08:00
|
|
|
const Module* TheModule;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2009-07-09 05:44:25 +08:00
|
|
|
/// TheFunction - The function for which we are holding slot numbers.
|
2008-08-19 12:36:02 +08:00
|
|
|
const Function* TheFunction;
|
|
|
|
bool FunctionProcessed;
|
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
|
|
|
bool ShouldInitializeAllMetadata;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2011-07-11 15:28:49 +08:00
|
|
|
/// mMap - The slot map for the module level data.
|
2008-08-19 12:36:02 +08:00
|
|
|
ValueMap mMap;
|
|
|
|
unsigned mNext;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2011-07-11 15:28:49 +08:00
|
|
|
/// fMap - The slot map for the function level data.
|
2008-08-19 12:36:02 +08:00
|
|
|
ValueMap fMap;
|
|
|
|
unsigned fNext;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2009-07-09 05:44:25 +08:00
|
|
|
/// mdnMap - Map for MDNodes.
|
2009-12-31 10:20:11 +08:00
|
|
|
DenseMap<const MDNode*, unsigned> mdnMap;
|
2009-07-09 05:44:25 +08:00
|
|
|
unsigned mdnNext;
|
2013-02-11 16:43:33 +08:00
|
|
|
|
|
|
|
/// asMap - The slot map for attribute sets.
|
|
|
|
DenseMap<AttributeSet, unsigned> asMap;
|
|
|
|
unsigned asNext;
|
2008-08-19 12:36:02 +08:00
|
|
|
public:
|
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
|
|
|
/// Construct from a module.
|
|
|
|
///
|
|
|
|
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
|
|
|
|
/// functions, giving correct numbering for metadata referenced only from
|
|
|
|
/// within a function (even if no functions have been initialized).
|
|
|
|
explicit SlotTracker(const Module *M,
|
|
|
|
bool ShouldInitializeAllMetadata = false);
|
2008-08-19 12:36:02 +08:00
|
|
|
/// Construct from a function, starting out in incorp state.
|
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
|
|
|
///
|
|
|
|
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
|
|
|
|
/// functions, giving correct numbering for metadata referenced only from
|
|
|
|
/// within a function (even if no functions have been initialized).
|
|
|
|
explicit SlotTracker(const Function *F,
|
|
|
|
bool ShouldInitializeAllMetadata = false);
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
/// Return the slot number of the specified value in it's type
|
|
|
|
/// plane. If something is not in the SlotTracker, return -1.
|
|
|
|
int getLocalSlot(const Value *V);
|
|
|
|
int getGlobalSlot(const GlobalValue *V);
|
2014-11-12 05:30:22 +08:00
|
|
|
int getMetadataSlot(const MDNode *N);
|
2013-02-11 16:43:33 +08:00
|
|
|
int getAttributeGroupSlot(AttributeSet AS);
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
/// If you'd like to deal with a function instead of just a module, use
|
|
|
|
/// this method to get its data into the SlotTracker.
|
|
|
|
void incorporateFunction(const Function *F) {
|
|
|
|
TheFunction = F;
|
|
|
|
FunctionProcessed = false;
|
|
|
|
}
|
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
const Function *getFunction() const { return TheFunction; }
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// After calling incorporateFunction, use this method to remove the
|
|
|
|
/// most recently incorporated function from the SlotTracker. This
|
|
|
|
/// will reset the state of the machine back to just the module contents.
|
|
|
|
void purgeFunction();
|
|
|
|
|
2009-07-09 05:44:25 +08:00
|
|
|
/// MDNode map iterators.
|
2009-12-31 10:20:11 +08:00
|
|
|
typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator;
|
|
|
|
mdn_iterator mdn_begin() { return mdnMap.begin(); }
|
|
|
|
mdn_iterator mdn_end() { return mdnMap.end(); }
|
|
|
|
unsigned mdn_size() const { return mdnMap.size(); }
|
|
|
|
bool mdn_empty() const { return mdnMap.empty(); }
|
2009-07-09 05:44:25 +08:00
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
/// AttributeSet map iterators.
|
|
|
|
typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator;
|
|
|
|
as_iterator as_begin() { return asMap.begin(); }
|
|
|
|
as_iterator as_end() { return asMap.end(); }
|
|
|
|
unsigned as_size() const { return asMap.size(); }
|
|
|
|
bool as_empty() const { return asMap.empty(); }
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// This function does the actual initialization.
|
|
|
|
inline void initialize();
|
|
|
|
|
2009-07-09 05:44:25 +08:00
|
|
|
// Implementation Details
|
|
|
|
private:
|
2008-08-19 12:36:02 +08:00
|
|
|
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
|
|
|
|
void CreateModuleSlot(const GlobalValue *V);
|
2009-07-09 05:44:25 +08:00
|
|
|
|
|
|
|
/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
|
2014-11-12 05:30:22 +08:00
|
|
|
void CreateMetadataSlot(const MDNode *N);
|
2009-07-09 05:44:25 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// CreateFunctionSlot - Insert the specified Value* into the slot table.
|
|
|
|
void CreateFunctionSlot(const Value *V);
|
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
/// \brief Insert the specified AttributeSet into the slot table.
|
|
|
|
void CreateAttributeSetSlot(AttributeSet AS);
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// Add all of the module level global variables (and their initializers)
|
|
|
|
/// and function declarations, but not the contents of those functions.
|
|
|
|
void processModule();
|
|
|
|
|
2009-07-09 05:44:25 +08:00
|
|
|
/// Add all of the functions arguments, basic blocks, and instructions.
|
2008-08-19 12:36:02 +08:00
|
|
|
void processFunction();
|
|
|
|
|
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
|
|
|
/// Add all of the metadata from a function.
|
|
|
|
void processFunctionMetadata(const Function &F);
|
|
|
|
|
2015-03-15 03:48:31 +08:00
|
|
|
/// Add all of the metadata from an instruction.
|
|
|
|
void processInstructionMetadata(const Instruction &I);
|
|
|
|
|
2015-02-16 06:54:22 +08:00
|
|
|
SlotTracker(const SlotTracker &) = delete;
|
|
|
|
void operator=(const SlotTracker &) = delete;
|
2008-08-19 12:36:02 +08:00
|
|
|
};
|
2015-03-18 03:53:41 +08:00
|
|
|
} // namespace
|
2008-08-19 12:36:02 +08:00
|
|
|
|
2015-03-18 03:53:41 +08:00
|
|
|
static SlotTracker *createSlotTracker(const Module *M) {
|
2013-05-09 04:38:31 +08:00
|
|
|
return new SlotTracker(M);
|
|
|
|
}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
static SlotTracker *createSlotTracker(const Value *V) {
|
|
|
|
if (const Argument *FA = dyn_cast<Argument>(V))
|
|
|
|
return new SlotTracker(FA->getParent());
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(V))
|
2011-10-01 03:50:40 +08:00
|
|
|
if (I->getParent())
|
|
|
|
return new SlotTracker(I->getParent()->getParent());
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
|
|
|
|
return new SlotTracker(BB->getParent());
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
|
|
|
|
return new SlotTracker(GV->getParent());
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
|
2009-09-20 10:20:51 +08:00
|
|
|
return new SlotTracker(GA->getParent());
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (const Function *Func = dyn_cast<Function>(V))
|
|
|
|
return new SlotTracker(Func);
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2014-04-09 14:08:46 +08:00
|
|
|
return nullptr;
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
2010-01-05 09:29:26 +08:00
|
|
|
#define ST_DEBUG(X) dbgs() << X
|
2008-08-19 12:36:02 +08:00
|
|
|
#else
|
2008-08-19 12:47:09 +08:00
|
|
|
#define ST_DEBUG(X)
|
2008-08-19 12:36:02 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Module level constructor. Causes the contents of the Module (sans functions)
|
|
|
|
// to be added to the slot table.
|
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
|
|
|
SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
|
|
|
|
: TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
|
|
|
|
ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
|
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
|
|
|
fNext(0), mdnNext(0), asNext(0) {}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
// Function level constructor. Causes the contents of the Module and the one
|
|
|
|
// function provided to be added to the slot table.
|
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
|
|
|
SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
|
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
|
|
|
: TheModule(F ? F->getParent() : nullptr), TheFunction(F),
|
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
|
|
|
FunctionProcessed(false),
|
|
|
|
ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
|
|
|
|
fNext(0), mdnNext(0), asNext(0) {}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
inline void SlotTracker::initialize() {
|
|
|
|
if (TheModule) {
|
|
|
|
processModule();
|
2014-04-09 14:08:46 +08:00
|
|
|
TheModule = nullptr; ///< Prevent re-processing next time we're called.
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
if (TheFunction && !FunctionProcessed)
|
|
|
|
processFunction();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iterate through all the global variables, functions, and global
|
|
|
|
// variable initializers and create slots for them.
|
|
|
|
void SlotTracker::processModule() {
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("begin processModule!\n");
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
// Add all of the unnamed global variables to the value table.
|
|
|
|
for (Module::const_global_iterator I = TheModule->global_begin(),
|
2009-07-09 05:44:25 +08:00
|
|
|
E = TheModule->global_end(); I != E; ++I) {
|
2009-09-20 10:20:51 +08:00
|
|
|
if (!I->hasName())
|
2008-08-19 12:36:02 +08:00
|
|
|
CreateModuleSlot(I);
|
2009-07-09 05:44:25 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2009-07-30 06:04:47 +08:00
|
|
|
// Add metadata used by named metadata.
|
2009-09-20 10:20:51 +08:00
|
|
|
for (Module::const_named_metadata_iterator
|
2009-07-30 06:04:47 +08:00
|
|
|
I = TheModule->named_metadata_begin(),
|
|
|
|
E = TheModule->named_metadata_end(); I != E; ++I) {
|
|
|
|
const NamedMDNode *NMD = I;
|
2010-07-22 02:54:18 +08:00
|
|
|
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
|
|
|
|
CreateMetadataSlot(NMD->getOperand(i));
|
2009-07-30 06:04:47 +08:00
|
|
|
}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
|
2013-02-11 16:43:33 +08:00
|
|
|
I != E; ++I) {
|
2008-08-19 12:36:02 +08:00
|
|
|
if (!I->hasName())
|
2013-02-11 16:43:33 +08:00
|
|
|
// Add all the unnamed functions to the table.
|
2008-08-19 12:36:02 +08:00
|
|
|
CreateModuleSlot(I);
|
2009-09-20 10:20:51 +08:00
|
|
|
|
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
|
|
|
if (ShouldInitializeAllMetadata)
|
|
|
|
processFunctionMetadata(*I);
|
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
// Add all the function attributes to the table.
|
2013-02-20 15:21:42 +08:00
|
|
|
// FIXME: Add attributes of other objects?
|
2013-02-11 16:43:33 +08:00
|
|
|
AttributeSet FnAttrs = I->getAttributes().getFnAttributes();
|
|
|
|
if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex))
|
|
|
|
CreateAttributeSetSlot(FnAttrs);
|
|
|
|
}
|
|
|
|
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("end processModule!\n");
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Process the arguments, basic blocks, and instructions of a function.
|
|
|
|
void SlotTracker::processFunction() {
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("begin processFunction!\n");
|
2008-08-19 12:36:02 +08:00
|
|
|
fNext = 0;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
// Add all the function arguments with no names.
|
|
|
|
for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
|
|
|
|
AE = TheFunction->arg_end(); AI != AE; ++AI)
|
|
|
|
if (!AI->hasName())
|
|
|
|
CreateFunctionSlot(AI);
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("Inserting Instructions:\n");
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
// Add all of the basic blocks and instructions with no names.
|
2015-03-15 03:44:01 +08:00
|
|
|
for (auto &BB : *TheFunction) {
|
|
|
|
if (!BB.hasName())
|
|
|
|
CreateFunctionSlot(&BB);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2015-04-25 06:04:41 +08:00
|
|
|
processFunctionMetadata(*TheFunction);
|
|
|
|
|
2015-03-15 03:44:01 +08:00
|
|
|
for (auto &I : BB) {
|
|
|
|
if (!I.getType()->isVoidTy() && !I.hasName())
|
|
|
|
CreateFunctionSlot(&I);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2015-03-15 03:48:31 +08:00
|
|
|
// We allow direct calls to any llvm.foo function here, because the
|
|
|
|
// target may not be linked into the optimizer.
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
|
2013-02-22 17:09:42 +08:00
|
|
|
// Add all the call attributes to the table.
|
|
|
|
AttributeSet Attrs = CI->getAttributes().getFnAttributes();
|
|
|
|
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
|
|
|
|
CreateAttributeSetSlot(Attrs);
|
2015-03-15 03:44:01 +08:00
|
|
|
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
|
2013-02-22 17:09:42 +08:00
|
|
|
// Add all the call attributes to the table.
|
|
|
|
AttributeSet Attrs = II->getAttributes().getFnAttributes();
|
|
|
|
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
|
|
|
|
CreateAttributeSetSlot(Attrs);
|
2010-05-11 04:53:17 +08:00
|
|
|
}
|
2009-07-09 05:44:25 +08:00
|
|
|
}
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
2009-09-17 04:21:17 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
FunctionProcessed = true;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("end processFunction!\n");
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
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
|
|
|
void SlotTracker::processFunctionMetadata(const Function &F) {
|
2015-04-25 06:04:41 +08:00
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
|
|
|
for (auto &BB : F) {
|
|
|
|
F.getAllMetadata(MDs);
|
|
|
|
for (auto &MD : MDs)
|
|
|
|
CreateMetadataSlot(MD.second);
|
|
|
|
|
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
|
|
|
for (auto &I : BB)
|
|
|
|
processInstructionMetadata(I);
|
2015-04-25 06:04:41 +08:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2015-03-15 03:48:31 +08:00
|
|
|
void SlotTracker::processInstructionMetadata(const Instruction &I) {
|
|
|
|
// Process metadata used directly by intrinsics.
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(&I))
|
|
|
|
if (Function *F = CI->getCalledFunction())
|
|
|
|
if (F->isIntrinsic())
|
|
|
|
for (auto &Op : I.operands())
|
|
|
|
if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
|
|
|
|
if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
|
|
|
|
CreateMetadataSlot(N);
|
|
|
|
|
|
|
|
// Process metadata attached to this instruction.
|
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
|
|
|
I.getAllMetadata(MDs);
|
|
|
|
for (auto &MD : MDs)
|
|
|
|
CreateMetadataSlot(MD.second);
|
|
|
|
}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
/// Clean up after incorporating a function. This is the only way to get out of
|
|
|
|
/// the function incorporation state that affects get*Slot/Create*Slot. Function
|
|
|
|
/// incorporation state is indicated by TheFunction != 0.
|
|
|
|
void SlotTracker::purgeFunction() {
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("begin purgeFunction!\n");
|
2008-08-19 12:36:02 +08:00
|
|
|
fMap.clear(); // Simply discard the function level map
|
2014-04-09 14:08:46 +08:00
|
|
|
TheFunction = nullptr;
|
2008-08-19 12:36:02 +08:00
|
|
|
FunctionProcessed = false;
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG("end purgeFunction!\n");
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getGlobalSlot - Get the slot number of a global value.
|
|
|
|
int SlotTracker::getGlobalSlot(const GlobalValue *V) {
|
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2011-07-11 15:28:49 +08:00
|
|
|
// Find the value in the module map
|
2008-08-19 12:36:02 +08:00
|
|
|
ValueMap::iterator MI = mMap.find(V);
|
2008-10-02 03:58:59 +08:00
|
|
|
return MI == mMap.end() ? -1 : (int)MI->second;
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
2014-11-12 05:30:22 +08:00
|
|
|
/// getMetadataSlot - Get the slot number of a MDNode.
|
|
|
|
int SlotTracker::getMetadataSlot(const MDNode *N) {
|
2009-07-09 05:44:25 +08:00
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2011-07-11 15:28:49 +08:00
|
|
|
// Find the MDNode in the module map
|
2014-11-12 05:30:22 +08:00
|
|
|
mdn_iterator MI = mdnMap.find(N);
|
2009-07-09 05:44:25 +08:00
|
|
|
return MI == mdnMap.end() ? -1 : (int)MI->second;
|
|
|
|
}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
/// getLocalSlot - Get the slot number for a value that is local to a function.
|
|
|
|
int SlotTracker::getLocalSlot(const Value *V) {
|
|
|
|
assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
ValueMap::iterator FI = fMap.find(V);
|
2008-10-02 03:58:59 +08:00
|
|
|
return FI == fMap.end() ? -1 : (int)FI->second;
|
2008-08-19 12:36:02 +08:00
|
|
|
}
|
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
|
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
|
|
|
|
|
|
|
// Find the AttributeSet in the module map.
|
|
|
|
as_iterator AI = asMap.find(AS);
|
|
|
|
return AI == asMap.end() ? -1 : (int)AI->second;
|
|
|
|
}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
|
|
|
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
|
|
|
|
void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
|
|
|
|
assert(V && "Can't insert a null Value into SlotTracker!");
|
2009-12-29 15:25:48 +08:00
|
|
|
assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
|
2008-08-19 12:36:02 +08:00
|
|
|
assert(!V->hasName() && "Doesn't need a slot!");
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
unsigned DestSlot = mNext++;
|
|
|
|
mMap[V] = DestSlot;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
|
2008-08-19 12:36:02 +08:00
|
|
|
DestSlot << " [");
|
|
|
|
// G = Global, F = Function, A = Alias, o = other
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
|
2008-08-19 12:36:02 +08:00
|
|
|
(isa<Function>(V) ? 'F' :
|
|
|
|
(isa<GlobalAlias>(V) ? 'A' : 'o'))) << "]\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CreateSlot - Create a new slot for the specified value if it has no name.
|
|
|
|
void SlotTracker::CreateFunctionSlot(const Value *V) {
|
2009-12-29 15:25:48 +08:00
|
|
|
assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
unsigned DestSlot = fNext++;
|
|
|
|
fMap[V] = DestSlot;
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
// G = Global, F = Function, o = other
|
2008-08-19 12:47:09 +08:00
|
|
|
ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
|
2008-08-19 12:36:02 +08:00
|
|
|
DestSlot << " [o]\n");
|
2009-09-20 10:20:51 +08:00
|
|
|
}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
2014-11-12 05:30:22 +08:00
|
|
|
/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
|
|
|
|
void SlotTracker::CreateMetadataSlot(const MDNode *N) {
|
|
|
|
assert(N && "Can't insert a null Value into SlotTracker!");
|
2009-09-20 10:20:51 +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
|
|
|
unsigned DestSlot = mdnNext;
|
|
|
|
if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
|
|
|
|
return;
|
|
|
|
++mdnNext;
|
2008-08-19 12:36:02 +08:00
|
|
|
|
2009-12-31 10:27:30 +08:00
|
|
|
// Recursively add any MDNodes referenced by operands.
|
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
|
|
|
|
if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
|
|
|
|
CreateMetadataSlot(Op);
|
2009-07-09 05:44:25 +08:00
|
|
|
}
|
2008-08-19 12:36:02 +08:00
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
|
|
|
|
assert(AS.hasAttributes(AttributeSet::FunctionIndex) &&
|
|
|
|
"Doesn't need a slot!");
|
|
|
|
|
|
|
|
as_iterator I = asMap.find(AS);
|
|
|
|
if (I != asMap.end())
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned DestSlot = asNext++;
|
|
|
|
asMap[AS] = DestSlot;
|
|
|
|
}
|
|
|
|
|
2008-08-19 12:36:02 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AsmWriter Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-08-13 04:56:03 +08:00
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
|
2009-08-13 23:27:57 +08:00
|
|
|
TypePrinting *TypePrinter,
|
2010-07-21 07:55:01 +08:00
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context);
|
2008-08-19 12:36:02 +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
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
|
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context,
|
|
|
|
bool FromValue = false);
|
|
|
|
|
2006-12-06 14:40:49 +08:00
|
|
|
static const char *getPredicateText(unsigned predicate) {
|
2006-12-04 13:19:18 +08:00
|
|
|
const char * pred = "unknown";
|
|
|
|
switch (predicate) {
|
2009-12-31 10:13:35 +08:00
|
|
|
case FCmpInst::FCMP_FALSE: pred = "false"; break;
|
|
|
|
case FCmpInst::FCMP_OEQ: pred = "oeq"; break;
|
|
|
|
case FCmpInst::FCMP_OGT: pred = "ogt"; break;
|
|
|
|
case FCmpInst::FCMP_OGE: pred = "oge"; break;
|
|
|
|
case FCmpInst::FCMP_OLT: pred = "olt"; break;
|
|
|
|
case FCmpInst::FCMP_OLE: pred = "ole"; break;
|
|
|
|
case FCmpInst::FCMP_ONE: pred = "one"; break;
|
|
|
|
case FCmpInst::FCMP_ORD: pred = "ord"; break;
|
|
|
|
case FCmpInst::FCMP_UNO: pred = "uno"; break;
|
|
|
|
case FCmpInst::FCMP_UEQ: pred = "ueq"; break;
|
|
|
|
case FCmpInst::FCMP_UGT: pred = "ugt"; break;
|
|
|
|
case FCmpInst::FCMP_UGE: pred = "uge"; break;
|
|
|
|
case FCmpInst::FCMP_ULT: pred = "ult"; break;
|
|
|
|
case FCmpInst::FCMP_ULE: pred = "ule"; break;
|
|
|
|
case FCmpInst::FCMP_UNE: pred = "une"; break;
|
|
|
|
case FCmpInst::FCMP_TRUE: pred = "true"; break;
|
|
|
|
case ICmpInst::ICMP_EQ: pred = "eq"; break;
|
|
|
|
case ICmpInst::ICMP_NE: pred = "ne"; break;
|
|
|
|
case ICmpInst::ICMP_SGT: pred = "sgt"; break;
|
|
|
|
case ICmpInst::ICMP_SGE: pred = "sge"; break;
|
|
|
|
case ICmpInst::ICMP_SLT: pred = "slt"; break;
|
|
|
|
case ICmpInst::ICMP_SLE: pred = "sle"; break;
|
|
|
|
case ICmpInst::ICMP_UGT: pred = "ugt"; break;
|
|
|
|
case ICmpInst::ICMP_UGE: pred = "uge"; break;
|
|
|
|
case ICmpInst::ICMP_ULT: pred = "ult"; break;
|
|
|
|
case ICmpInst::ICMP_ULE: pred = "ule"; break;
|
2006-12-04 13:19:18 +08:00
|
|
|
}
|
|
|
|
return pred;
|
|
|
|
}
|
|
|
|
|
2011-07-29 05:48:00 +08:00
|
|
|
static void writeAtomicRMWOperation(raw_ostream &Out,
|
|
|
|
AtomicRMWInst::BinOp Op) {
|
|
|
|
switch (Op) {
|
|
|
|
default: Out << " <unknown operation " << Op << ">"; break;
|
|
|
|
case AtomicRMWInst::Xchg: Out << " xchg"; break;
|
|
|
|
case AtomicRMWInst::Add: Out << " add"; break;
|
|
|
|
case AtomicRMWInst::Sub: Out << " sub"; break;
|
|
|
|
case AtomicRMWInst::And: Out << " and"; break;
|
|
|
|
case AtomicRMWInst::Nand: Out << " nand"; break;
|
|
|
|
case AtomicRMWInst::Or: Out << " or"; break;
|
|
|
|
case AtomicRMWInst::Xor: Out << " xor"; break;
|
|
|
|
case AtomicRMWInst::Max: Out << " max"; break;
|
|
|
|
case AtomicRMWInst::Min: Out << " min"; break;
|
|
|
|
case AtomicRMWInst::UMax: Out << " umax"; break;
|
|
|
|
case AtomicRMWInst::UMin: Out << " umin"; break;
|
|
|
|
}
|
|
|
|
}
|
2009-07-09 05:44:25 +08:00
|
|
|
|
2009-08-13 04:56:03 +08:00
|
|
|
static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
|
2012-11-27 08:42:44 +08:00
|
|
|
if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
|
|
|
|
// Unsafe algebra implies all the others, no need to write them all out
|
|
|
|
if (FPO->hasUnsafeAlgebra())
|
|
|
|
Out << " fast";
|
|
|
|
else {
|
|
|
|
if (FPO->hasNoNaNs())
|
|
|
|
Out << " nnan";
|
|
|
|
if (FPO->hasNoInfs())
|
|
|
|
Out << " ninf";
|
|
|
|
if (FPO->hasNoSignedZeros())
|
|
|
|
Out << " nsz";
|
|
|
|
if (FPO->hasAllowReciprocal())
|
|
|
|
Out << " arcp";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-21 05:19:07 +08:00
|
|
|
if (const OverflowingBinaryOperator *OBO =
|
|
|
|
dyn_cast<OverflowingBinaryOperator>(U)) {
|
2009-08-21 01:11:38 +08:00
|
|
|
if (OBO->hasNoUnsignedWrap())
|
2009-07-28 00:11:46 +08:00
|
|
|
Out << " nuw";
|
2009-08-21 01:11:38 +08:00
|
|
|
if (OBO->hasNoSignedWrap())
|
2009-07-28 00:11:46 +08:00
|
|
|
Out << " nsw";
|
2011-02-07 05:44:57 +08:00
|
|
|
} else if (const PossiblyExactOperator *Div =
|
|
|
|
dyn_cast<PossiblyExactOperator>(U)) {
|
2009-07-21 05:19:07 +08:00
|
|
|
if (Div->isExact())
|
2009-07-28 00:11:46 +08:00
|
|
|
Out << " exact";
|
2009-07-28 05:53:46 +08:00
|
|
|
} else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
|
|
|
|
if (GEP->isInBounds())
|
|
|
|
Out << " inbounds";
|
2009-07-21 05:19:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-15 04:57:55 +08:00
|
|
|
static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
|
|
|
|
TypePrinting &TypePrinter,
|
2010-07-21 07:55:01 +08:00
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2007-01-11 20:24:14 +08:00
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
|
2010-02-16 00:12:20 +08:00
|
|
|
if (CI->getType()->isIntegerTy(1)) {
|
2007-01-12 12:24:46 +08:00
|
|
|
Out << (CI->getZExtValue() ? "true" : "false");
|
2008-08-17 15:19:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
Out << CI->getValue();
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-17 15:19:36 +08:00
|
|
|
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
|
2012-05-24 23:59:06 +08:00
|
|
|
if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle ||
|
2011-12-17 08:04:22 +08:00
|
|
|
&CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble) {
|
2007-09-12 11:30:33 +08:00
|
|
|
// We would like to output the FP constant value in exponential notation,
|
|
|
|
// but we cannot do this if doing so will lose precision. Check here to
|
|
|
|
// make sure that we only output it in exponential format if we can parse
|
|
|
|
// the value back and get the same value.
|
|
|
|
//
|
2009-01-22 04:32:55 +08:00
|
|
|
bool ignored;
|
2011-12-17 08:04:22 +08:00
|
|
|
bool isHalf = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEhalf;
|
2007-09-12 11:30:33 +08:00
|
|
|
bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble;
|
2012-02-16 16:12:24 +08:00
|
|
|
bool isInf = CFP->getValueAPF().isInfinity();
|
|
|
|
bool isNaN = CFP->getValueAPF().isNaN();
|
|
|
|
if (!isHalf && !isInf && !isNaN) {
|
2011-12-17 08:04:22 +08:00
|
|
|
double Val = isDouble ? CFP->getValueAPF().convertToDouble() :
|
|
|
|
CFP->getValueAPF().convertToFloat();
|
|
|
|
SmallString<128> StrVal;
|
|
|
|
raw_svector_ostream(StrVal) << Val;
|
|
|
|
|
|
|
|
// Check to make sure that the stringized number is not some string like
|
|
|
|
// "Inf" or NaN, that atof will accept, but the lexer will not. Check
|
|
|
|
// that the string matches the "[-+]?[0-9]" regex.
|
|
|
|
//
|
|
|
|
if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
|
|
|
|
((StrVal[0] == '-' || StrVal[0] == '+') &&
|
|
|
|
(StrVal[1] >= '0' && StrVal[1] <= '9'))) {
|
|
|
|
// Reparse stringized version!
|
2012-02-16 12:19:15 +08:00
|
|
|
if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) {
|
2015-03-10 15:33:23 +08:00
|
|
|
Out << StrVal;
|
2011-12-17 08:04:22 +08:00
|
|
|
return;
|
|
|
|
}
|
2007-09-12 11:30:33 +08:00
|
|
|
}
|
2002-04-19 02:53:13 +08:00
|
|
|
}
|
2007-09-12 11:30:33 +08:00
|
|
|
// Otherwise we could not reparse it to exactly the same value, so we must
|
2009-01-22 04:32:55 +08:00
|
|
|
// output the string in hexadecimal format! Note that loading and storing
|
|
|
|
// floating point types changes the bits of NaNs on some hosts, notably
|
|
|
|
// x86, so we must not use these types.
|
2014-03-16 02:47:07 +08:00
|
|
|
static_assert(sizeof(double) == sizeof(uint64_t),
|
|
|
|
"assuming that double is 64 bits!");
|
2008-11-10 12:30:26 +08:00
|
|
|
char Buffer[40];
|
2009-01-22 04:32:55 +08:00
|
|
|
APFloat apf = CFP->getValueAPF();
|
2011-12-17 08:04:22 +08:00
|
|
|
// Halves and floats are represented in ASCII IR as double, convert.
|
2009-01-22 04:32:55 +08:00
|
|
|
if (!isDouble)
|
2009-09-20 10:20:51 +08:00
|
|
|
apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
|
2009-01-22 04:32:55 +08:00
|
|
|
&ignored);
|
2009-09-20 10:20:51 +08:00
|
|
|
Out << "0x" <<
|
|
|
|
utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()),
|
2009-01-22 04:32:55 +08:00
|
|
|
Buffer+40);
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2012-05-24 23:59:06 +08:00
|
|
|
// Either half, or some form of long double.
|
|
|
|
// These appear as a magic letter identifying the type, then a
|
|
|
|
// fixed number of hex digits.
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << "0x";
|
2012-05-24 23:59:06 +08:00
|
|
|
// Bit position, in the current word, of the next nibble to print.
|
|
|
|
int shiftcount;
|
|
|
|
|
2009-03-24 05:16:53 +08:00
|
|
|
if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) {
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << 'K';
|
2009-03-24 05:16:53 +08:00
|
|
|
// api needed to prevent premature destruction
|
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
|
|
|
const uint64_t* p = api.getRawData();
|
|
|
|
uint64_t word = p[1];
|
2012-05-24 23:59:06 +08:00
|
|
|
shiftcount = 12;
|
2009-03-24 05:16:53 +08:00
|
|
|
int width = api.getBitWidth();
|
|
|
|
for (int j=0; j<width; j+=4, shiftcount-=4) {
|
|
|
|
unsigned int nibble = (word>>shiftcount) & 15;
|
|
|
|
if (nibble < 10)
|
|
|
|
Out << (unsigned char)(nibble + '0');
|
|
|
|
else
|
|
|
|
Out << (unsigned char)(nibble - 10 + 'A');
|
|
|
|
if (shiftcount == 0 && j+4 < width) {
|
|
|
|
word = *p;
|
|
|
|
shiftcount = 64;
|
|
|
|
if (width-j-4 < 64)
|
|
|
|
shiftcount = width-j-4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
2012-05-24 23:59:06 +08:00
|
|
|
} else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) {
|
|
|
|
shiftcount = 60;
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << 'L';
|
2012-05-24 23:59:06 +08:00
|
|
|
} else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) {
|
|
|
|
shiftcount = 60;
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << 'M';
|
2012-05-24 23:59:06 +08:00
|
|
|
} else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEhalf) {
|
|
|
|
shiftcount = 12;
|
|
|
|
Out << 'H';
|
|
|
|
} else
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Unsupported floating point type");
|
2008-08-19 13:06:27 +08:00
|
|
|
// api needed to prevent premature destruction
|
2008-10-10 02:53:47 +08:00
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
2008-08-19 13:06:27 +08:00
|
|
|
const uint64_t* p = api.getRawData();
|
|
|
|
uint64_t word = *p;
|
|
|
|
int width = api.getBitWidth();
|
|
|
|
for (int j=0; j<width; j+=4, shiftcount-=4) {
|
|
|
|
unsigned int nibble = (word>>shiftcount) & 15;
|
|
|
|
if (nibble < 10)
|
|
|
|
Out << (unsigned char)(nibble + '0');
|
2007-09-12 11:30:33 +08:00
|
|
|
else
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << (unsigned char)(nibble - 10 + 'A');
|
|
|
|
if (shiftcount == 0 && j+4 < width) {
|
|
|
|
word = *(++p);
|
|
|
|
shiftcount = 64;
|
|
|
|
if (width-j-4 < 64)
|
|
|
|
shiftcount = width-j-4;
|
2007-09-12 11:30:33 +08:00
|
|
|
}
|
|
|
|
}
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (isa<ConstantAggregateZero>(CV)) {
|
2004-02-15 13:55:15 +08:00
|
|
|
Out << "zeroinitializer";
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-10-28 11:38:12 +08:00
|
|
|
if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
|
|
|
|
Out << "blockaddress(";
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
|
|
|
|
Context);
|
2009-10-28 11:38:12 +08:00
|
|
|
Out << ", ";
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
|
|
|
|
Context);
|
2009-10-28 11:38:12 +08:00
|
|
|
Out << ")";
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Type *ETy = CA->getType()->getElementType();
|
2012-02-05 10:29:43 +08:00
|
|
|
Out << '[';
|
|
|
|
TypePrinter.print(ETy, Out);
|
|
|
|
Out << ' ';
|
|
|
|
WriteAsOperandInternal(Out, CA->getOperand(0),
|
|
|
|
&TypePrinter, Machine,
|
|
|
|
Context);
|
|
|
|
for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
|
|
|
|
Out << ", ";
|
2012-01-31 11:15:40 +08:00
|
|
|
TypePrinter.print(ETy, Out);
|
|
|
|
Out << ' ';
|
2012-02-05 10:29:43 +08:00
|
|
|
WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
|
2012-01-31 11:15:40 +08:00
|
|
|
Context);
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2012-02-05 10:29:43 +08:00
|
|
|
Out << ']';
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2012-11-16 06:34:00 +08:00
|
|
|
|
2012-01-26 10:32:04 +08:00
|
|
|
if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
|
|
|
|
// As a special case, print the array as a string if it is an array of
|
|
|
|
// i8 with ConstantInt values.
|
|
|
|
if (CA->isString()) {
|
|
|
|
Out << "c\"";
|
|
|
|
PrintEscapedString(CA->getAsString(), Out);
|
|
|
|
Out << '"';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Type *ETy = CA->getType()->getElementType();
|
|
|
|
Out << '[';
|
2012-01-31 11:15:40 +08:00
|
|
|
TypePrinter.print(ETy, Out);
|
|
|
|
Out << ' ';
|
|
|
|
WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
|
|
|
|
&TypePrinter, Machine,
|
|
|
|
Context);
|
|
|
|
for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
|
|
|
|
Out << ", ";
|
2012-01-26 10:32:04 +08:00
|
|
|
TypePrinter.print(ETy, Out);
|
|
|
|
Out << ' ';
|
2012-01-31 11:15:40 +08:00
|
|
|
WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
|
|
|
|
Machine, Context);
|
2012-01-26 10:32:04 +08:00
|
|
|
}
|
2012-01-31 11:15:40 +08:00
|
|
|
Out << ']';
|
2012-01-26 10:32:04 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
|
2007-01-09 02:21:30 +08:00
|
|
|
if (CS->getType()->isPacked())
|
|
|
|
Out << '<';
|
2004-06-05 05:11:51 +08:00
|
|
|
Out << '{';
|
2006-02-25 20:27:03 +08:00
|
|
|
unsigned N = CS->getNumOperands();
|
|
|
|
if (N) {
|
2008-08-19 12:47:09 +08:00
|
|
|
Out << ' ';
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(CS->getOperand(0)->getType(), Out);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2002-04-17 05:36:08 +08:00
|
|
|
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
|
|
|
|
Context);
|
2002-04-17 05:36:08 +08:00
|
|
|
|
2006-02-25 20:27:03 +08:00
|
|
|
for (unsigned i = 1; i < N; i++) {
|
2002-04-17 05:36:08 +08:00
|
|
|
Out << ", ";
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(CS->getOperand(i)->getType(), Out);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2002-04-17 05:36:08 +08:00
|
|
|
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
|
|
|
|
Context);
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << '}';
|
2007-01-09 02:21:30 +08:00
|
|
|
if (CS->getType()->isPacked())
|
|
|
|
Out << '>';
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2012-01-26 10:32:04 +08:00
|
|
|
if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
|
|
|
|
Type *ETy = CV->getType()->getVectorElementType();
|
2009-02-11 08:25:25 +08:00
|
|
|
Out << '<';
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2012-01-26 10:32:04 +08:00
|
|
|
WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
|
|
|
|
Machine, Context);
|
|
|
|
for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
|
2008-08-19 13:26:17 +08:00
|
|
|
Out << ", ";
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2012-01-26 10:32:04 +08:00
|
|
|
WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
|
|
|
|
Machine, Context);
|
2008-08-19 13:06:27 +08:00
|
|
|
}
|
2009-02-11 08:25:25 +08:00
|
|
|
Out << '>';
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (isa<ConstantPointerNull>(CV)) {
|
2002-04-17 05:36:08 +08:00
|
|
|
Out << "null";
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (isa<UndefValue>(CV)) {
|
2004-10-17 02:08:06 +08:00
|
|
|
Out << "undef";
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
|
2006-12-04 13:19:18 +08:00
|
|
|
Out << CE->getOpcodeName();
|
2009-07-28 00:11:46 +08:00
|
|
|
WriteOptimizationInfo(Out, CE);
|
2006-12-04 13:19:18 +08:00
|
|
|
if (CE->isCompare())
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << ' ' << getPredicateText(CE->getPredicate());
|
2006-12-04 13:19:18 +08:00
|
|
|
Out << " (";
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2015-03-14 02:20:45 +08:00
|
|
|
if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
|
|
|
|
TypePrinter.print(
|
|
|
|
cast<PointerType>(GEP->getPointerOperandType()->getScalarType())
|
|
|
|
->getElementType(),
|
|
|
|
Out);
|
|
|
|
Out << ", ";
|
|
|
|
}
|
|
|
|
|
2002-07-15 07:14:45 +08:00
|
|
|
for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print((*OI)->getType(), Out);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
|
2002-07-15 07:14:45 +08:00
|
|
|
if (OI+1 != CE->op_end())
|
2002-07-31 02:54:25 +08:00
|
|
|
Out << ", ";
|
2002-07-15 07:14:45 +08:00
|
|
|
}
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2008-06-01 03:12:39 +08:00
|
|
|
if (CE->hasIndices()) {
|
2011-04-13 23:22:40 +08:00
|
|
|
ArrayRef<unsigned> Indices = CE->getIndices();
|
2008-06-01 03:12:39 +08:00
|
|
|
for (unsigned i = 0, e = Indices.size(); i != e; ++i)
|
|
|
|
Out << ", " << Indices[i];
|
|
|
|
}
|
|
|
|
|
2006-11-27 09:05:10 +08:00
|
|
|
if (CE->isCast()) {
|
2002-08-16 03:37:43 +08:00
|
|
|
Out << " to ";
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(CE->getType(), Out);
|
2002-08-16 03:37:43 +08:00
|
|
|
}
|
2006-11-27 09:05:10 +08:00
|
|
|
|
2004-06-05 05:11:51 +08:00
|
|
|
Out << ')';
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << "<placeholder or erroneous Constant>";
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
|
|
|
|
2015-01-13 07:45:31 +08:00
|
|
|
static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
|
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2009-12-31 10:31:59 +08:00
|
|
|
Out << "!{";
|
|
|
|
for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
|
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
|
|
|
const Metadata *MD = Node->getOperand(mi);
|
|
|
|
if (!MD)
|
2009-12-31 10:31:59 +08:00
|
|
|
Out << "null";
|
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
|
|
|
else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
|
|
|
|
Value *V = MDV->getValue();
|
2009-12-31 10:31:59 +08:00
|
|
|
TypePrinter->print(V->getType(), Out);
|
|
|
|
Out << ' ';
|
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
|
|
|
WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
|
|
|
|
} else {
|
|
|
|
WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
|
2009-12-31 10:31:59 +08:00
|
|
|
}
|
|
|
|
if (mi + 1 != me)
|
|
|
|
Out << ", ";
|
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-12-31 10:31:59 +08:00
|
|
|
Out << "}";
|
|
|
|
}
|
|
|
|
|
2015-01-14 04:44:56 +08:00
|
|
|
namespace {
|
|
|
|
struct FieldSeparator {
|
|
|
|
bool Skip;
|
2015-02-21 09:02:18 +08:00
|
|
|
const char *Sep;
|
|
|
|
FieldSeparator(const char *Sep = ", ") : Skip(true), Sep(Sep) {}
|
2015-01-14 04:44:56 +08:00
|
|
|
};
|
|
|
|
raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
|
|
|
|
if (FS.Skip) {
|
|
|
|
FS.Skip = false;
|
|
|
|
return OS;
|
|
|
|
}
|
2015-02-21 09:02:18 +08:00
|
|
|
return OS << FS.Sep;
|
2015-01-14 04:44:56 +08:00
|
|
|
}
|
2015-03-27 08:17:42 +08:00
|
|
|
struct MDFieldPrinter {
|
|
|
|
raw_ostream &Out;
|
|
|
|
FieldSeparator FS;
|
|
|
|
TypePrinting *TypePrinter;
|
|
|
|
SlotTracker *Machine;
|
|
|
|
const Module *Context;
|
|
|
|
|
|
|
|
explicit MDFieldPrinter(raw_ostream &Out)
|
|
|
|
: Out(Out), TypePrinter(nullptr), Machine(nullptr), Context(nullptr) {}
|
|
|
|
MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context)
|
|
|
|
: Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
|
|
|
|
}
|
2015-04-30 00:38:44 +08:00
|
|
|
void printTag(const DINode *N);
|
2015-03-27 08:17:42 +08:00
|
|
|
void printString(StringRef Name, StringRef Value,
|
|
|
|
bool ShouldSkipEmpty = true);
|
|
|
|
void printMetadata(StringRef Name, const Metadata *MD,
|
|
|
|
bool ShouldSkipNull = true);
|
|
|
|
template <class IntTy>
|
|
|
|
void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
|
|
|
|
void printBool(StringRef Name, bool Value);
|
|
|
|
void printDIFlags(StringRef Name, unsigned Flags);
|
|
|
|
template <class IntTy, class Stringifier>
|
|
|
|
void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
|
|
|
|
bool ShouldSkipZero = true);
|
|
|
|
};
|
2015-01-14 04:44:56 +08:00
|
|
|
} // end namespace
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
void MDFieldPrinter::printTag(const DINode *N) {
|
2015-03-27 08:17:42 +08:00
|
|
|
Out << FS << "tag: ";
|
|
|
|
if (const char *Tag = dwarf::TagString(N->getTag()))
|
|
|
|
Out << Tag;
|
|
|
|
else
|
|
|
|
Out << N->getTag();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MDFieldPrinter::printString(StringRef Name, StringRef Value,
|
|
|
|
bool ShouldSkipEmpty) {
|
|
|
|
if (ShouldSkipEmpty && Value.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << FS << Name << ": \"";
|
|
|
|
PrintEscapedString(Value, Out);
|
|
|
|
Out << "\"";
|
|
|
|
}
|
|
|
|
|
2015-02-07 06:27:22 +08:00
|
|
|
static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
|
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
|
|
|
if (!MD) {
|
|
|
|
Out << "null";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
|
|
|
|
}
|
|
|
|
|
2015-03-27 08:17:42 +08:00
|
|
|
void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
|
|
|
|
bool ShouldSkipNull) {
|
|
|
|
if (ShouldSkipNull && !MD)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << FS << Name << ": ";
|
|
|
|
writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
|
2015-02-07 06:28:05 +08:00
|
|
|
}
|
|
|
|
|
2015-03-27 08:17:42 +08:00
|
|
|
template <class IntTy>
|
|
|
|
void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
|
|
|
|
if (ShouldSkipZero && !Int)
|
2015-03-01 06:16:56 +08:00
|
|
|
return;
|
|
|
|
|
2015-03-27 08:17:42 +08:00
|
|
|
Out << FS << Name << ": " << Int;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MDFieldPrinter::printBool(StringRef Name, bool Value) {
|
|
|
|
Out << FS << Name << ": " << (Value ? "true" : "false");
|
|
|
|
}
|
|
|
|
|
|
|
|
void MDFieldPrinter::printDIFlags(StringRef Name, unsigned Flags) {
|
|
|
|
if (!Flags)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << FS << Name << ": ";
|
|
|
|
|
|
|
|
SmallVector<unsigned, 8> SplitFlags;
|
2015-04-30 00:38:44 +08:00
|
|
|
unsigned Extra = DINode::splitFlags(Flags, SplitFlags);
|
2015-03-27 08:17:42 +08:00
|
|
|
|
|
|
|
FieldSeparator FlagsFS(" | ");
|
|
|
|
for (unsigned F : SplitFlags) {
|
2015-04-30 00:38:44 +08:00
|
|
|
const char *StringF = DINode::getFlagString(F);
|
2015-03-27 08:17:42 +08:00
|
|
|
assert(StringF && "Expected valid flag");
|
|
|
|
Out << FlagsFS << StringF;
|
|
|
|
}
|
|
|
|
if (Extra || SplitFlags.empty())
|
|
|
|
Out << FlagsFS << Extra;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class IntTy, class Stringifier>
|
|
|
|
void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
|
|
|
|
Stringifier toString, bool ShouldSkipZero) {
|
|
|
|
if (!Value)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << FS << Name << ": ";
|
|
|
|
if (const char *S = toString(Value))
|
|
|
|
Out << S;
|
|
|
|
else
|
|
|
|
Out << Value;
|
2015-03-01 06:16:56 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
|
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
|
|
|
Out << "!GenericDINode(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("header", N->getHeader());
|
2015-02-04 05:54:14 +08:00
|
|
|
if (N->getNumDwarfOperands()) {
|
2015-03-27 08:17:42 +08:00
|
|
|
Out << Printer.FS << "operands: {";
|
2015-02-04 05:54:14 +08:00
|
|
|
FieldSeparator IFS;
|
|
|
|
for (auto &I : N->dwarf_operands()) {
|
|
|
|
Out << IFS;
|
2015-02-07 06:27:22 +08:00
|
|
|
writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
|
2015-02-04 05:54:14 +08:00
|
|
|
}
|
|
|
|
Out << "}";
|
|
|
|
}
|
|
|
|
Out << ")";
|
2015-01-20 08:01:43 +08:00
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDILocation(raw_ostream &Out, const DILocation *DL,
|
2015-01-14 04:44:56 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DILocation(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
2015-01-15 06:14:26 +08:00
|
|
|
// Always output the line, since 0 is a relevant and important value for it.
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
|
|
|
|
Printer.printInt("column", DL->getColumn());
|
|
|
|
Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
|
2015-01-14 04:44:56 +08:00
|
|
|
Out << ")";
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
|
2015-02-13 09:10:38 +08:00
|
|
|
TypePrinting *, SlotTracker *, const Module *) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DISubrange(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out);
|
|
|
|
Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
|
2015-04-07 08:39:59 +08:00
|
|
|
Printer.printInt("lowerBound", N->getLowerBound());
|
2015-02-13 09:10:38 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:10:38 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
|
2015-02-10 08:52:32 +08:00
|
|
|
TypePrinting *, SlotTracker *, const Module *) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIEnumerator(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out);
|
|
|
|
Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
|
|
|
|
Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
|
2015-02-13 09:14:11 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:14:11 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
|
2015-02-13 09:14:58 +08:00
|
|
|
TypePrinting *, SlotTracker *, const Module *) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIBasicType(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out);
|
2015-03-01 07:21:38 +08:00
|
|
|
if (N->getTag() != dwarf::DW_TAG_base_type)
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
|
|
|
Printer.printInt("size", N->getSizeInBits());
|
|
|
|
Printer.printInt("align", N->getAlignInBits());
|
|
|
|
Printer.printDwarfEnum("encoding", N->getEncoding(),
|
|
|
|
dwarf::AttributeEncodingString);
|
2015-02-13 09:14:58 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:14:58 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
|
2015-02-13 09:20:38 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIDerivedType(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope());
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("baseType", N->getRawBaseType(),
|
2015-03-27 08:17:42 +08:00
|
|
|
/* ShouldSkipNull */ false);
|
|
|
|
Printer.printInt("size", N->getSizeInBits());
|
|
|
|
Printer.printInt("align", N->getAlignInBits());
|
|
|
|
Printer.printInt("offset", N->getOffsetInBits());
|
|
|
|
Printer.printDIFlags("flags", N->getFlags());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("extraData", N->getRawExtraData());
|
2015-02-13 09:20:38 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:20:38 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
|
2015-02-13 09:20:38 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DICompositeType(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope());
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("baseType", N->getRawBaseType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("size", N->getSizeInBits());
|
|
|
|
Printer.printInt("align", N->getAlignInBits());
|
|
|
|
Printer.printInt("offset", N->getOffsetInBits());
|
|
|
|
Printer.printDIFlags("flags", N->getFlags());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("elements", N->getRawElements());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
|
|
|
|
dwarf::LanguageString);
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
|
|
|
|
Printer.printMetadata("templateParams", N->getRawTemplateParams());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printString("identifier", N->getIdentifier());
|
2015-02-13 09:20:38 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:20:38 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
|
2015-02-13 09:22:59 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DISubroutineType(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printDIFlags("flags", N->getFlags());
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("types", N->getRawTypeArray(),
|
|
|
|
/* ShouldSkipNull */ false);
|
2015-02-13 09:22:59 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:19:14 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
|
2015-02-10 08:52:32 +08:00
|
|
|
SlotTracker *, const Module *) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIFile(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out);
|
|
|
|
Printer.printString("filename", N->getFilename(),
|
|
|
|
/* ShouldSkipEmpty */ false);
|
|
|
|
Printer.printString("directory", N->getDirectory(),
|
|
|
|
/* ShouldSkipEmpty */ false);
|
2015-02-13 09:19:14 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:19:14 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
|
2015-02-13 09:25:10 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DICompileUnit(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printDwarfEnum("language", N->getSourceLanguage(),
|
|
|
|
dwarf::LanguageString, /* ShouldSkipZero */ false);
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printString("producer", N->getProducer());
|
|
|
|
Printer.printBool("isOptimized", N->isOptimized());
|
|
|
|
Printer.printString("flags", N->getFlags());
|
|
|
|
Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
|
|
|
|
/* ShouldSkipZero */ false);
|
|
|
|
Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
|
|
|
|
Printer.printInt("emissionKind", N->getEmissionKind(),
|
|
|
|
/* ShouldSkipZero */ false);
|
2015-03-28 07:05:04 +08:00
|
|
|
Printer.printMetadata("enums", N->getRawEnumTypes());
|
|
|
|
Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
|
|
|
|
Printer.printMetadata("subprograms", N->getRawSubprograms());
|
|
|
|
Printer.printMetadata("globals", N->getRawGlobalVariables());
|
|
|
|
Printer.printMetadata("imports", N->getRawImportedEntities());
|
2015-05-22 04:37:30 +08:00
|
|
|
Printer.printInt("dwoId", N->getDWOId());
|
2015-02-13 09:25:10 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:25:10 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
|
2015-02-13 09:26:47 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DISubprogram(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printString("name", N->getName());
|
|
|
|
Printer.printString("linkageName", N->getLinkageName());
|
2015-03-31 00:19:15 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-03-31 00:19:15 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printBool("isLocal", N->isLocalToUnit());
|
|
|
|
Printer.printBool("isDefinition", N->isDefinition());
|
|
|
|
Printer.printInt("scopeLine", N->getScopeLine());
|
2015-03-31 00:19:15 +08:00
|
|
|
Printer.printMetadata("containingType", N->getRawContainingType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printDwarfEnum("virtuality", N->getVirtuality(),
|
|
|
|
dwarf::VirtualityString);
|
|
|
|
Printer.printInt("virtualIndex", N->getVirtualIndex());
|
|
|
|
Printer.printDIFlags("flags", N->getFlags());
|
|
|
|
Printer.printBool("isOptimized", N->isOptimized());
|
2015-03-31 00:19:15 +08:00
|
|
|
Printer.printMetadata("function", N->getRawFunction());
|
|
|
|
Printer.printMetadata("templateParams", N->getRawTemplateParams());
|
|
|
|
Printer.printMetadata("declaration", N->getRawDeclaration());
|
|
|
|
Printer.printMetadata("variables", N->getRawVariables());
|
2015-02-13 09:26:47 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:26:47 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
|
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
|
|
|
Out << "!DILexicalBlock(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
2015-03-31 00:37:48 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
|
|
|
Printer.printInt("column", N->getColumn());
|
2015-02-13 09:29:28 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:29:28 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDILexicalBlockFile(raw_ostream &Out,
|
|
|
|
const DILexicalBlockFile *N,
|
2015-02-13 09:30:42 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DILexicalBlockFile(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
2015-03-31 00:37:48 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("discriminator", N->getDiscriminator(),
|
|
|
|
/* ShouldSkipZero */ false);
|
2015-02-13 09:30:42 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:30:42 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
|
2015-02-13 09:32:09 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DINamespace(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-03-31 01:21:38 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-02-13 09:32:09 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:32:09 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDITemplateTypeParameter(raw_ostream &Out,
|
|
|
|
const DITemplateTypeParameter *N,
|
2015-02-13 09:34:32 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DITemplateTypeParameter(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-04-07 03:03:45 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
|
2015-02-13 09:34:32 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:34:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDITemplateValueParameter(raw_ostream &Out,
|
|
|
|
const DITemplateValueParameter *N,
|
2015-02-13 09:34:32 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DITemplateValueParameter(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
2015-03-01 07:21:38 +08:00
|
|
|
if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-04-07 03:03:45 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
|
2015-02-13 09:34:32 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:34:32 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
|
2015-02-13 09:35:40 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIGlobalVariable(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printString("name", N->getName());
|
|
|
|
Printer.printString("linkageName", N->getLinkageName());
|
2015-03-28 01:29:58 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-03-28 01:29:58 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printBool("isLocal", N->isLocalToUnit());
|
|
|
|
Printer.printBool("isDefinition", N->isDefinition());
|
2015-03-28 01:29:58 +08:00
|
|
|
Printer.printMetadata("variable", N->getRawVariable());
|
|
|
|
Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
|
2015-02-13 09:35:40 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:35:40 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
|
2015-02-13 09:39:44 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DILocalVariable(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
|
|
|
Printer.printInt("arg", N->getArg(),
|
|
|
|
/* ShouldSkipZero */
|
|
|
|
N->getTag() == dwarf::DW_TAG_auto_variable);
|
2015-03-28 01:29:58 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-03-28 01:29:58 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printDIFlags("flags", N->getFlags());
|
2015-02-13 09:39:44 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:39:44 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
|
2015-02-13 09:42:09 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIExpression(";
|
2015-02-13 09:42:09 +08:00
|
|
|
FieldSeparator FS;
|
|
|
|
if (N->isValid()) {
|
|
|
|
for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
|
|
|
|
const char *OpStr = dwarf::OperationEncodingString(I->getOp());
|
|
|
|
assert(OpStr && "Expected valid opcode");
|
|
|
|
|
|
|
|
Out << FS << OpStr;
|
|
|
|
for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
|
|
|
|
Out << FS << I->getArg(A);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (const auto &I : N->getElements())
|
|
|
|
Out << FS << I;
|
|
|
|
}
|
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:42:09 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
|
2015-02-13 09:43:22 +08:00
|
|
|
TypePrinting *TypePrinter, SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIObjCProperty(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-03-31 01:21:38 +08:00
|
|
|
Printer.printMetadata("file", N->getRawFile());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
|
|
|
Printer.printString("setter", N->getSetterName());
|
|
|
|
Printer.printString("getter", N->getGetterName());
|
|
|
|
Printer.printInt("attributes", N->getAttributes());
|
2015-03-31 01:21:38 +08:00
|
|
|
Printer.printMetadata("type", N->getRawType());
|
2015-02-13 09:43:22 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
2015-02-13 09:43:22 +08:00
|
|
|
|
2015-04-30 00:38:44 +08:00
|
|
|
static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
|
2015-02-13 09:46:02 +08:00
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context) {
|
2015-04-30 00:38:44 +08:00
|
|
|
Out << "!DIImportedEntity(";
|
2015-03-27 08:17:42 +08:00
|
|
|
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
|
|
|
Printer.printTag(N);
|
|
|
|
Printer.printString("name", N->getName());
|
2015-03-31 01:21:38 +08:00
|
|
|
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
|
|
|
|
Printer.printMetadata("entity", N->getRawEntity());
|
2015-03-27 08:17:42 +08:00
|
|
|
Printer.printInt("line", N->getLine());
|
2015-02-13 09:46:02 +08:00
|
|
|
Out << ")";
|
2015-02-10 08:52:32 +08:00
|
|
|
}
|
|
|
|
|
2015-02-13 09:46:02 +08:00
|
|
|
|
2015-01-13 07:45:31 +08:00
|
|
|
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
|
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2015-01-20 07:13:14 +08:00
|
|
|
if (Node->isDistinct())
|
2015-01-13 07:45:31 +08:00
|
|
|
Out << "distinct ";
|
2015-03-17 05:21:10 +08:00
|
|
|
else if (Node->isTemporary())
|
|
|
|
Out << "<temporary!> "; // Handle broken code.
|
2015-01-13 07:45:31 +08:00
|
|
|
|
2015-01-20 07:13:14 +08:00
|
|
|
switch (Node->getMetadataID()) {
|
2015-01-13 07:45:31 +08:00
|
|
|
default:
|
|
|
|
llvm_unreachable("Expected uniquable MDNode");
|
2015-01-20 07:13:14 +08:00
|
|
|
#define HANDLE_MDNODE_LEAF(CLASS) \
|
2015-01-13 07:45:31 +08:00
|
|
|
case Metadata::CLASS##Kind: \
|
2015-01-20 07:13:14 +08:00
|
|
|
write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
|
2015-01-13 07:45:31 +08:00
|
|
|
break;
|
|
|
|
#include "llvm/IR/Metadata.def"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 10:29:41 +08:00
|
|
|
// Full implementation of printing a Value as an operand with support for
|
|
|
|
// TypePrinting, etc.
|
2009-08-13 04:56:03 +08:00
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
|
2009-08-13 23:27:57 +08:00
|
|
|
TypePrinting *TypePrinter,
|
2010-07-21 07:55:01 +08:00
|
|
|
SlotTracker *Machine,
|
|
|
|
const Module *Context) {
|
2008-08-17 12:40:13 +08:00
|
|
|
if (V->hasName()) {
|
|
|
|
PrintLLVMName(Out, V);
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-17 12:40:13 +08:00
|
|
|
const Constant *CV = dyn_cast<Constant>(V);
|
|
|
|
if (CV && !isa<GlobalValue>(CV)) {
|
2009-08-13 23:27:57 +08:00
|
|
|
assert(TypePrinter && "Constants require TypePrinting!");
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
|
2008-08-17 12:40:13 +08:00
|
|
|
Out << "asm ";
|
|
|
|
if (IA->hasSideEffects())
|
|
|
|
Out << "sideeffect ";
|
2009-10-22 07:28:00 +08:00
|
|
|
if (IA->isAlignStack())
|
|
|
|
Out << "alignstack ";
|
2012-09-06 03:00:49 +08:00
|
|
|
// We don't emit the AD_ATT dialect as it's the assumed default.
|
|
|
|
if (IA->getDialect() == InlineAsm::AD_Intel)
|
|
|
|
Out << "inteldialect ";
|
2008-08-17 12:40:13 +08:00
|
|
|
Out << '"';
|
|
|
|
PrintEscapedString(IA->getAsmString(), Out);
|
|
|
|
Out << "\", \"";
|
|
|
|
PrintEscapedString(IA->getConstraintString(), Out);
|
|
|
|
Out << '"';
|
2008-08-19 13:06:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-07-23 01:43:22 +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
|
|
|
if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
|
|
|
|
WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
|
|
|
|
Context, /* FromValue */ true);
|
2009-07-23 01:43:22 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
char Prefix = '%';
|
|
|
|
int Slot;
|
2011-08-03 14:15:41 +08:00
|
|
|
// If we have a SlotTracker, use it.
|
2008-08-19 13:06:27 +08:00
|
|
|
if (Machine) {
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
|
|
|
|
Slot = Machine->getGlobalSlot(GV);
|
|
|
|
Prefix = '@';
|
|
|
|
} else {
|
|
|
|
Slot = Machine->getLocalSlot(V);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2011-08-03 14:15:41 +08:00
|
|
|
// If the local value didn't succeed, then we may be referring to a value
|
|
|
|
// from a different function. Translate it, as this can happen when using
|
|
|
|
// address of blocks.
|
|
|
|
if (Slot == -1)
|
|
|
|
if ((Machine = createSlotTracker(V))) {
|
|
|
|
Slot = Machine->getLocalSlot(V);
|
|
|
|
delete Machine;
|
|
|
|
}
|
2008-08-19 13:06:27 +08:00
|
|
|
}
|
2011-08-03 14:15:41 +08:00
|
|
|
} else if ((Machine = createSlotTracker(V))) {
|
|
|
|
// Otherwise, create one to get the # and then destroy it.
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
|
|
|
|
Slot = Machine->getGlobalSlot(GV);
|
|
|
|
Prefix = '@';
|
2006-01-26 06:26:05 +08:00
|
|
|
} else {
|
2011-08-03 14:15:41 +08:00
|
|
|
Slot = Machine->getLocalSlot(V);
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2011-08-03 14:15:41 +08:00
|
|
|
delete Machine;
|
2014-04-09 14:08:46 +08:00
|
|
|
Machine = nullptr;
|
2011-08-03 14:15:41 +08:00
|
|
|
} else {
|
|
|
|
Slot = -1;
|
2002-04-17 05:36:08 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
if (Slot != -1)
|
|
|
|
Out << Prefix << Slot;
|
|
|
|
else
|
|
|
|
Out << "<badref>";
|
2002-04-17 05:36:08 +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
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
|
|
|
|
TypePrinting *TypePrinter,
|
|
|
|
SlotTracker *Machine, const Module *Context,
|
|
|
|
bool FromValue) {
|
|
|
|
if (const MDNode *N = dyn_cast<MDNode>(MD)) {
|
|
|
|
if (!Machine)
|
|
|
|
Machine = new SlotTracker(Context);
|
|
|
|
int Slot = Machine->getMetadataSlot(N);
|
|
|
|
if (Slot == -1)
|
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
|
|
|
// Give the pointer value instead of "badref", since this comes up all
|
|
|
|
// the time when debugging.
|
|
|
|
Out << "<" << N << ">";
|
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
|
|
|
else
|
|
|
|
Out << '!' << Slot;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const MDString *MDS = dyn_cast<MDString>(MD)) {
|
|
|
|
Out << "!\"";
|
|
|
|
PrintEscapedString(MDS->getString(), Out);
|
|
|
|
Out << '"';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto *V = cast<ValueAsMetadata>(MD);
|
|
|
|
assert(TypePrinter && "TypePrinter required for metadata values");
|
|
|
|
assert((FromValue || !isa<LocalAsMetadata>(V)) &&
|
|
|
|
"Unexpected function-local metadata outside of value argument");
|
|
|
|
|
|
|
|
TypePrinter->print(V->getValue()->getType(), Out);
|
|
|
|
Out << ' ';
|
|
|
|
WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
|
|
|
|
}
|
|
|
|
|
2015-03-18 03:53:41 +08:00
|
|
|
namespace {
|
|
|
|
class AssemblyWriter {
|
|
|
|
formatted_raw_ostream &Out;
|
|
|
|
const Module *TheModule;
|
|
|
|
std::unique_ptr<SlotTracker> ModuleSlotTracker;
|
|
|
|
SlotTracker &Machine;
|
|
|
|
TypePrinting TypePrinter;
|
|
|
|
AssemblyAnnotationWriter *AnnotationWriter;
|
|
|
|
SetVector<const Comdat *> Comdats;
|
2015-04-15 09:36:30 +08:00
|
|
|
bool ShouldPreserveUseListOrder;
|
2015-03-18 03:53:41 +08:00
|
|
|
UseListOrderStack UseListOrders;
|
2015-04-25 05:03:05 +08:00
|
|
|
SmallVector<StringRef, 8> MDNames;
|
2015-03-18 03:53:41 +08:00
|
|
|
|
|
|
|
public:
|
|
|
|
/// Construct an AssemblyWriter with an external SlotTracker
|
2015-04-15 09:36:30 +08:00
|
|
|
AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
|
|
|
|
AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder = false);
|
2015-03-18 03:53:41 +08:00
|
|
|
|
|
|
|
/// Construct an AssemblyWriter with an internally allocated SlotTracker
|
|
|
|
AssemblyWriter(formatted_raw_ostream &o, const Module *M,
|
2015-04-15 09:36:30 +08:00
|
|
|
AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder = false);
|
2015-03-18 03:53:41 +08:00
|
|
|
|
|
|
|
void printMDNodeBody(const MDNode *MD);
|
|
|
|
void printNamedMDNode(const NamedMDNode *NMD);
|
|
|
|
|
|
|
|
void printModule(const Module *M);
|
|
|
|
|
|
|
|
void writeOperand(const Value *Op, bool PrintType);
|
|
|
|
void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx);
|
|
|
|
void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope);
|
|
|
|
void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
|
|
|
|
AtomicOrdering FailureOrdering,
|
|
|
|
SynchronizationScope SynchScope);
|
|
|
|
|
|
|
|
void writeAllMDNodes();
|
|
|
|
void writeMDNode(unsigned Slot, const MDNode *Node);
|
|
|
|
void writeAllAttributeGroups();
|
|
|
|
|
|
|
|
void printTypeIdentities();
|
|
|
|
void printGlobal(const GlobalVariable *GV);
|
|
|
|
void printAlias(const GlobalAlias *GV);
|
|
|
|
void printComdat(const Comdat *C);
|
|
|
|
void printFunction(const Function *F);
|
|
|
|
void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx);
|
|
|
|
void printBasicBlock(const BasicBlock *BB);
|
|
|
|
void printInstructionLine(const Instruction &I);
|
|
|
|
void printInstruction(const Instruction &I);
|
|
|
|
|
|
|
|
void printUseListOrder(const UseListOrder &Order);
|
|
|
|
void printUseLists(const Function *F);
|
|
|
|
|
|
|
|
private:
|
|
|
|
void init();
|
|
|
|
|
2015-04-25 04:59:52 +08:00
|
|
|
/// \brief Print out metadata attachments.
|
|
|
|
void printMetadataAttachments(
|
2015-04-25 05:06:21 +08:00
|
|
|
const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
|
|
|
|
StringRef Separator);
|
2015-04-25 04:59:52 +08:00
|
|
|
|
2015-03-18 03:53:41 +08:00
|
|
|
// printInfoComment - Print a little comment after the instruction indicating
|
|
|
|
// which slot it occupies.
|
|
|
|
void printInfoComment(const Value &V);
|
2015-05-05 21:20:42 +08:00
|
|
|
|
|
|
|
// printGCRelocateComment - print comment after call to the gc.relocate
|
|
|
|
// intrinsic indicating base and derived pointer names.
|
|
|
|
void printGCRelocateComment(const Value &V);
|
2015-03-18 03:53:41 +08:00
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
2013-05-09 04:38:31 +08:00
|
|
|
void AssemblyWriter::init() {
|
2014-06-28 02:19:56 +08:00
|
|
|
if (!TheModule)
|
|
|
|
return;
|
|
|
|
TypePrinter.incorporateTypes(*TheModule);
|
|
|
|
for (const Function &F : *TheModule)
|
|
|
|
if (const Comdat *C = F.getComdat())
|
|
|
|
Comdats.insert(C);
|
|
|
|
for (const GlobalVariable &GV : TheModule->globals())
|
|
|
|
if (const Comdat *C = GV.getComdat())
|
|
|
|
Comdats.insert(C);
|
2013-05-09 04:38:31 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2013-05-09 04:38:31 +08:00
|
|
|
AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
|
2015-04-15 09:36:30 +08:00
|
|
|
const Module *M, AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder)
|
|
|
|
: Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
|
|
|
|
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
|
2013-05-09 04:38:31 +08:00
|
|
|
init();
|
|
|
|
}
|
2002-04-19 02:53:13 +08:00
|
|
|
|
2013-05-09 04:38:31 +08:00
|
|
|
AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, const Module *M,
|
2015-04-15 09:36:30 +08:00
|
|
|
AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder)
|
|
|
|
: Out(o), TheModule(M), ModuleSlotTracker(createSlotTracker(M)),
|
|
|
|
Machine(*ModuleSlotTracker), AnnotationWriter(AAW),
|
|
|
|
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
|
2013-05-09 04:38:31 +08:00
|
|
|
init();
|
|
|
|
}
|
2009-12-31 10:13:35 +08:00
|
|
|
|
2006-12-06 14:24:27 +08:00
|
|
|
void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
|
2014-04-09 14:08:46 +08:00
|
|
|
if (!Operand) {
|
2005-02-25 00:58:29 +08:00
|
|
|
Out << "<null operand!>";
|
2009-12-31 10:33:14 +08:00
|
|
|
return;
|
2005-02-25 00:58:29 +08:00
|
|
|
}
|
2009-12-31 10:33:14 +08:00
|
|
|
if (PrintType) {
|
|
|
|
TypePrinter.print(Operand->getType(), Out);
|
|
|
|
Out << ' ';
|
|
|
|
}
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
|
2001-09-08 00:36:04 +08:00
|
|
|
}
|
|
|
|
|
2011-07-26 07:16:38 +08:00
|
|
|
void AssemblyWriter::writeAtomic(AtomicOrdering Ordering,
|
|
|
|
SynchronizationScope SynchScope) {
|
|
|
|
if (Ordering == NotAtomic)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (SynchScope) {
|
|
|
|
case SingleThread: Out << " singlethread"; break;
|
|
|
|
case CrossThread: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (Ordering) {
|
|
|
|
default: Out << " <bad ordering " << int(Ordering) << ">"; break;
|
|
|
|
case Unordered: Out << " unordered"; break;
|
|
|
|
case Monotonic: Out << " monotonic"; break;
|
|
|
|
case Acquire: Out << " acquire"; break;
|
|
|
|
case Release: Out << " release"; break;
|
|
|
|
case AcquireRelease: Out << " acq_rel"; break;
|
|
|
|
case SequentiallyConsistent: Out << " seq_cst"; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-11 18:48:52 +08:00
|
|
|
void AssemblyWriter::writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
|
|
|
|
AtomicOrdering FailureOrdering,
|
|
|
|
SynchronizationScope SynchScope) {
|
|
|
|
assert(SuccessOrdering != NotAtomic && FailureOrdering != NotAtomic);
|
|
|
|
|
|
|
|
switch (SynchScope) {
|
|
|
|
case SingleThread: Out << " singlethread"; break;
|
|
|
|
case CrossThread: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (SuccessOrdering) {
|
|
|
|
default: Out << " <bad ordering " << int(SuccessOrdering) << ">"; break;
|
|
|
|
case Unordered: Out << " unordered"; break;
|
|
|
|
case Monotonic: Out << " monotonic"; break;
|
|
|
|
case Acquire: Out << " acquire"; break;
|
|
|
|
case Release: Out << " release"; break;
|
|
|
|
case AcquireRelease: Out << " acq_rel"; break;
|
|
|
|
case SequentiallyConsistent: Out << " seq_cst"; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (FailureOrdering) {
|
|
|
|
default: Out << " <bad ordering " << int(FailureOrdering) << ">"; break;
|
|
|
|
case Unordered: Out << " unordered"; break;
|
|
|
|
case Monotonic: Out << " monotonic"; break;
|
|
|
|
case Acquire: Out << " acquire"; break;
|
|
|
|
case Release: Out << " release"; break;
|
|
|
|
case AcquireRelease: Out << " acq_rel"; break;
|
|
|
|
case SequentiallyConsistent: Out << " seq_cst"; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-20 10:20:51 +08:00
|
|
|
void AssemblyWriter::writeParamOperand(const Value *Operand,
|
2012-12-30 21:50:49 +08:00
|
|
|
AttributeSet Attrs, unsigned Idx) {
|
2014-04-09 14:08:46 +08:00
|
|
|
if (!Operand) {
|
2007-11-27 21:23:08 +08:00
|
|
|
Out << "<null operand!>";
|
2009-12-31 10:33:14 +08:00
|
|
|
return;
|
2007-11-27 21:23:08 +08:00
|
|
|
}
|
2009-12-31 10:33:14 +08:00
|
|
|
|
|
|
|
// Print the type
|
|
|
|
TypePrinter.print(Operand->getType(), Out);
|
|
|
|
// Print parameter attributes list
|
2012-12-30 21:50:49 +08:00
|
|
|
if (Attrs.hasAttributes(Idx))
|
|
|
|
Out << ' ' << Attrs.getAsString(Idx);
|
2009-12-31 10:33:14 +08:00
|
|
|
Out << ' ';
|
|
|
|
// Print the operand
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
|
2007-11-27 21:23:08 +08:00
|
|
|
}
|
2001-09-08 00:36:04 +08:00
|
|
|
|
2001-10-30 00:05:51 +08:00
|
|
|
void AssemblyWriter::printModule(const Module *M) {
|
2013-02-11 16:43:33 +08:00
|
|
|
Machine.initialize();
|
|
|
|
|
2015-04-15 09:36:30 +08:00
|
|
|
if (ShouldPreserveUseListOrder)
|
2014-08-20 05:30:15 +08:00
|
|
|
UseListOrders = predictUseListOrder(M);
|
|
|
|
|
2005-03-03 07:12:40 +08:00
|
|
|
if (!M->getModuleIdentifier().empty() &&
|
2005-04-22 07:48:37 +08:00
|
|
|
// Don't print the ID if it will start a new line (which would
|
2005-03-03 07:12:40 +08:00
|
|
|
// require a comment char before it).
|
|
|
|
M->getModuleIdentifier().find('\n') == std::string::npos)
|
|
|
|
Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
|
|
|
|
|
2014-02-26 04:01:08 +08:00
|
|
|
const std::string &DL = M->getDataLayoutStr();
|
|
|
|
if (!DL.empty())
|
|
|
|
Out << "target datalayout = \"" << DL << "\"\n";
|
2004-07-26 05:44:54 +08:00
|
|
|
if (!M->getTargetTriple().empty())
|
2004-07-26 05:29:43 +08:00
|
|
|
Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2006-01-24 12:13:11 +08:00
|
|
|
if (!M->getModuleInlineAsm().empty()) {
|
2006-01-24 08:45:30 +08:00
|
|
|
// Split the string into lines, to make it easier to read the .ll file.
|
2006-01-24 12:13:11 +08:00
|
|
|
std::string Asm = M->getModuleInlineAsm();
|
2006-01-24 08:45:30 +08:00
|
|
|
size_t CurPos = 0;
|
|
|
|
size_t NewLine = Asm.find_first_of('\n', CurPos);
|
2009-08-13 07:54:22 +08:00
|
|
|
Out << '\n';
|
2006-01-24 08:45:30 +08:00
|
|
|
while (NewLine != std::string::npos) {
|
|
|
|
// We found a newline, print the portion of the asm string from the
|
|
|
|
// last newline up to this newline.
|
|
|
|
Out << "module asm \"";
|
|
|
|
PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
|
|
|
|
Out);
|
|
|
|
Out << "\"\n";
|
|
|
|
CurPos = NewLine+1;
|
|
|
|
NewLine = Asm.find_first_of('\n', CurPos);
|
|
|
|
}
|
2011-03-02 12:14:42 +08:00
|
|
|
std::string rest(Asm.begin()+CurPos, Asm.end());
|
|
|
|
if (!rest.empty()) {
|
|
|
|
Out << "module asm \"";
|
|
|
|
PrintEscapedString(rest, Out);
|
|
|
|
Out << "\"\n";
|
|
|
|
}
|
2006-01-24 07:03:36 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
printTypeIdentities();
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
// Output all comdats.
|
|
|
|
if (!Comdats.empty())
|
|
|
|
Out << '\n';
|
|
|
|
for (const Comdat *C : Comdats) {
|
|
|
|
printComdat(C);
|
|
|
|
if (C != Comdats.back())
|
|
|
|
Out << '\n';
|
|
|
|
}
|
|
|
|
|
2009-08-13 07:54:22 +08:00
|
|
|
// Output all globals.
|
|
|
|
if (!M->global_empty()) Out << '\n';
|
2006-12-06 12:41:52 +08:00
|
|
|
for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
|
2012-09-12 17:55:51 +08:00
|
|
|
I != E; ++I) {
|
|
|
|
printGlobal(I); Out << '\n';
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2007-04-26 10:24:10 +08:00
|
|
|
// Output all aliases.
|
|
|
|
if (!M->alias_empty()) Out << "\n";
|
|
|
|
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
|
|
|
|
I != E; ++I)
|
|
|
|
printAlias(I);
|
2001-09-08 00:36:04 +08:00
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
// Output global use-lists.
|
|
|
|
printUseLists(nullptr);
|
|
|
|
|
2004-09-14 13:06:58 +08:00
|
|
|
// Output all of the functions.
|
2002-06-26 00:13:24 +08:00
|
|
|
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
|
|
|
|
printFunction(I);
|
2014-08-20 05:30:15 +08:00
|
|
|
assert(UseListOrders.empty() && "All use-lists should have been consumed");
|
2009-07-09 05:44:25 +08:00
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
// Output all attribute groups.
|
2013-04-30 07:48:06 +08:00
|
|
|
if (!Machine.as_empty()) {
|
2013-02-11 16:43:33 +08:00
|
|
|
Out << '\n';
|
|
|
|
writeAllAttributeGroups();
|
|
|
|
}
|
|
|
|
|
2009-07-30 06:04:47 +08:00
|
|
|
// Output named metadata.
|
2009-08-13 07:54:22 +08:00
|
|
|
if (!M->named_metadata_empty()) Out << '\n';
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-07-30 06:04:47 +08:00
|
|
|
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
|
2009-12-31 10:13:35 +08:00
|
|
|
E = M->named_metadata_end(); I != E; ++I)
|
2009-12-31 09:54:05 +08:00
|
|
|
printNamedMDNode(I);
|
2009-07-30 06:04:47 +08:00
|
|
|
|
|
|
|
// Output metadata.
|
2009-12-31 10:20:11 +08:00
|
|
|
if (!Machine.mdn_empty()) {
|
2009-12-31 10:13:35 +08:00
|
|
|
Out << '\n';
|
|
|
|
writeAllMDNodes();
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2015-06-03 05:25:08 +08:00
|
|
|
static void printMetadataIdentifier(StringRef Name,
|
|
|
|
formatted_raw_ostream &Out) {
|
2011-06-15 14:37:58 +08:00
|
|
|
if (Name.empty()) {
|
|
|
|
Out << "<empty name> ";
|
|
|
|
} else {
|
2015-06-03 05:25:00 +08:00
|
|
|
if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
|
|
|
|
Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
|
2011-06-15 14:37:58 +08:00
|
|
|
Out << Name[0];
|
|
|
|
else
|
|
|
|
Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
|
|
|
|
for (unsigned i = 1, e = Name.size(); i != e; ++i) {
|
|
|
|
unsigned char C = Name[i];
|
2013-02-13 05:21:59 +08:00
|
|
|
if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
|
|
|
|
C == '.' || C == '_')
|
2011-06-15 14:37:58 +08:00
|
|
|
Out << C;
|
|
|
|
else
|
|
|
|
Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 05:25:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
|
|
|
|
Out << '!';
|
|
|
|
printMetadataIdentifier(NMD->getName(), Out);
|
2011-06-15 14:37:58 +08:00
|
|
|
Out << " = !{";
|
2009-12-31 09:54:05 +08:00
|
|
|
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
|
2015-06-03 05:25:00 +08:00
|
|
|
if (i)
|
|
|
|
Out << ", ";
|
2010-09-10 04:53:58 +08:00
|
|
|
int Slot = Machine.getMetadataSlot(NMD->getOperand(i));
|
|
|
|
if (Slot == -1)
|
|
|
|
Out << "<badref>";
|
|
|
|
else
|
|
|
|
Out << '!' << Slot;
|
2009-12-31 09:54:05 +08:00
|
|
|
}
|
|
|
|
Out << "}\n";
|
|
|
|
}
|
|
|
|
|
2009-08-13 01:23:50 +08:00
|
|
|
static void PrintLinkage(GlobalValue::LinkageTypes LT,
|
|
|
|
formatted_raw_ostream &Out) {
|
2008-08-19 13:06:27 +08:00
|
|
|
switch (LT) {
|
2009-07-20 09:03:30 +08:00
|
|
|
case GlobalValue::ExternalLinkage: break;
|
|
|
|
case GlobalValue::PrivateLinkage: Out << "private "; break;
|
|
|
|
case GlobalValue::InternalLinkage: Out << "internal "; break;
|
|
|
|
case GlobalValue::LinkOnceAnyLinkage: Out << "linkonce "; break;
|
|
|
|
case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break;
|
|
|
|
case GlobalValue::WeakAnyLinkage: Out << "weak "; break;
|
|
|
|
case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break;
|
|
|
|
case GlobalValue::CommonLinkage: Out << "common "; break;
|
|
|
|
case GlobalValue::AppendingLinkage: Out << "appending "; break;
|
|
|
|
case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
|
2009-04-13 13:44:34 +08:00
|
|
|
case GlobalValue::AvailableExternallyLinkage:
|
|
|
|
Out << "available_externally ";
|
|
|
|
break;
|
2008-08-19 13:06:27 +08:00
|
|
|
}
|
|
|
|
}
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
llvm-svn: 66339
2009-03-07 23:45:40 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
|
2009-08-13 01:23:50 +08:00
|
|
|
formatted_raw_ostream &Out) {
|
2008-08-19 13:06:27 +08:00
|
|
|
switch (Vis) {
|
|
|
|
case GlobalValue::DefaultVisibility: break;
|
|
|
|
case GlobalValue::HiddenVisibility: Out << "hidden "; break;
|
|
|
|
case GlobalValue::ProtectedVisibility: Out << "protected "; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-14 23:22:47 +08:00
|
|
|
static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
|
|
|
|
formatted_raw_ostream &Out) {
|
|
|
|
switch (SCT) {
|
|
|
|
case GlobalValue::DefaultStorageClass: break;
|
|
|
|
case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
|
|
|
|
case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-23 19:37:03 +08:00
|
|
|
static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM,
|
|
|
|
formatted_raw_ostream &Out) {
|
|
|
|
switch (TLM) {
|
|
|
|
case GlobalVariable::NotThreadLocal:
|
|
|
|
break;
|
|
|
|
case GlobalVariable::GeneralDynamicTLSModel:
|
|
|
|
Out << "thread_local ";
|
|
|
|
break;
|
|
|
|
case GlobalVariable::LocalDynamicTLSModel:
|
|
|
|
Out << "thread_local(localdynamic) ";
|
|
|
|
break;
|
|
|
|
case GlobalVariable::InitialExecTLSModel:
|
|
|
|
Out << "thread_local(initialexec) ";
|
|
|
|
break;
|
|
|
|
case GlobalVariable::LocalExecTLSModel:
|
|
|
|
Out << "thread_local(localexec) ";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-07 06:55:16 +08:00
|
|
|
static void maybePrintComdat(formatted_raw_ostream &Out,
|
|
|
|
const GlobalObject &GO) {
|
|
|
|
const Comdat *C = GO.getComdat();
|
|
|
|
if (!C)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (isa<GlobalVariable>(GO))
|
|
|
|
Out << ',';
|
|
|
|
Out << " comdat";
|
|
|
|
|
|
|
|
if (GO.getName() == C->getName())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << '(';
|
|
|
|
PrintLLVMName(Out, C->getName(), ComdatPrefix);
|
|
|
|
Out << ')';
|
|
|
|
}
|
|
|
|
|
2001-10-30 00:05:51 +08:00
|
|
|
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
|
2010-01-30 07:12:36 +08:00
|
|
|
if (GV->isMaterializable())
|
|
|
|
Out << "; Materializable\n";
|
|
|
|
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
|
2009-08-13 07:32:33 +08:00
|
|
|
Out << " = ";
|
2001-09-18 12:01:05 +08:00
|
|
|
|
2008-08-19 13:16:28 +08:00
|
|
|
if (!GV->hasInitializer() && GV->hasExternalLinkage())
|
|
|
|
Out << "external ";
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:16:28 +08:00
|
|
|
PrintLinkage(GV->getLinkage(), Out);
|
|
|
|
PrintVisibility(GV->getVisibility(), Out);
|
2014-01-14 23:22:47 +08:00
|
|
|
PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
|
2012-06-23 19:37:03 +08:00
|
|
|
PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
|
2014-06-06 09:20:28 +08:00
|
|
|
if (GV->hasUnnamedAddr())
|
|
|
|
Out << "unnamed_addr ";
|
2007-04-13 02:32:50 +08:00
|
|
|
|
2009-01-02 15:01:27 +08:00
|
|
|
if (unsigned AddressSpace = GV->getType()->getAddressSpace())
|
|
|
|
Out << "addrspace(" << AddressSpace << ") ";
|
2013-02-05 13:57:38 +08:00
|
|
|
if (GV->isExternallyInitialized()) Out << "externally_initialized ";
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << (GV->isConstant() ? "constant " : "global ");
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(GV->getType()->getElementType(), Out);
|
2001-09-18 12:01:05 +08:00
|
|
|
|
2008-09-15 01:21:12 +08:00
|
|
|
if (GV->hasInitializer()) {
|
|
|
|
Out << ' ';
|
2009-07-09 05:44:25 +08:00
|
|
|
writeOperand(GV->getInitializer(), false);
|
2008-09-15 01:21:12 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2010-07-08 07:16:37 +08:00
|
|
|
if (GV->hasSection()) {
|
|
|
|
Out << ", section \"";
|
|
|
|
PrintEscapedString(GV->getSection(), Out);
|
|
|
|
Out << '"';
|
|
|
|
}
|
2015-01-07 06:55:16 +08:00
|
|
|
maybePrintComdat(Out, *GV);
|
2005-11-12 08:10:19 +08:00
|
|
|
if (GV->getAlignment())
|
2005-11-06 14:48:53 +08:00
|
|
|
Out << ", align " << GV->getAlignment();
|
2007-04-25 22:27:10 +08:00
|
|
|
|
2002-06-26 00:13:24 +08:00
|
|
|
printInfoComment(*GV);
|
2001-09-10 15:58:01 +08:00
|
|
|
}
|
|
|
|
|
2007-04-25 22:27:10 +08:00
|
|
|
void AssemblyWriter::printAlias(const GlobalAlias *GA) {
|
2010-01-30 07:12:36 +08:00
|
|
|
if (GA->isMaterializable())
|
|
|
|
Out << "; Materializable\n";
|
|
|
|
|
2008-06-04 02:14:29 +08:00
|
|
|
// Don't crash when dumping partially built GA
|
|
|
|
if (!GA->hasName())
|
|
|
|
Out << "<<nameless>> = ";
|
2008-08-17 12:40:13 +08:00
|
|
|
else {
|
|
|
|
PrintLLVMName(Out, GA);
|
|
|
|
Out << " = ";
|
|
|
|
}
|
2014-07-31 06:51:54 +08:00
|
|
|
PrintLinkage(GA->getLinkage(), Out);
|
2008-08-19 13:06:27 +08:00
|
|
|
PrintVisibility(GA->getVisibility(), Out);
|
2014-01-14 23:22:47 +08:00
|
|
|
PrintDLLStorageClass(GA->getDLLStorageClass(), Out);
|
2014-05-29 02:15:43 +08:00
|
|
|
PrintThreadLocalModel(GA->getThreadLocalMode(), Out);
|
2014-06-06 09:20:28 +08:00
|
|
|
if (GA->hasUnnamedAddr())
|
|
|
|
Out << "unnamed_addr ";
|
2007-04-25 22:27:10 +08:00
|
|
|
|
|
|
|
Out << "alias ";
|
|
|
|
|
2007-04-30 02:02:48 +08:00
|
|
|
const Constant *Aliasee = GA->getAliasee();
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2014-04-09 14:08:46 +08:00
|
|
|
if (!Aliasee) {
|
2014-06-03 10:41:57 +08:00
|
|
|
TypePrinter.print(GA->getType(), Out);
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Out << " <<NULL ALIASEE>>";
|
2011-08-01 20:48:54 +08:00
|
|
|
} else {
|
2011-08-01 20:29:14 +08:00
|
|
|
writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee));
|
2011-08-01 20:48:54 +08:00
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2007-04-25 22:27:10 +08:00
|
|
|
printInfoComment(*GA);
|
2008-08-19 13:16:28 +08:00
|
|
|
Out << '\n';
|
2007-04-25 22:27:10 +08:00
|
|
|
}
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
void AssemblyWriter::printComdat(const Comdat *C) {
|
|
|
|
C->print(Out);
|
|
|
|
}
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
void AssemblyWriter::printTypeIdentities() {
|
|
|
|
if (TypePrinter.NumberedTypes.empty() &&
|
|
|
|
TypePrinter.NamedTypes.empty())
|
|
|
|
return;
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Out << '\n';
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
// We know all the numbers that each type is used and we know that it is a
|
|
|
|
// dense assignment. Convert the map to an index table.
|
|
|
|
std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
|
2011-10-01 03:48:58 +08:00
|
|
|
for (DenseMap<StructType*, unsigned>::iterator I =
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?");
|
|
|
|
NumberedTypes[I->second] = I->first;
|
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-03-01 08:03:38 +08:00
|
|
|
// Emit all numbered types.
|
|
|
|
for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
|
2009-08-13 07:32:33 +08:00
|
|
|
Out << '%' << i << " = type ";
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-03-01 08:03:38 +08:00
|
|
|
// Make sure we print out at least one level of the type structure, so
|
|
|
|
// that we do not get %2 = type %2
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
TypePrinter.printStructBody(NumberedTypes[i], Out);
|
2009-08-13 07:54:22 +08:00
|
|
|
Out << '\n';
|
2009-03-01 08:03:38 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) {
|
|
|
|
PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix);
|
2008-08-19 13:16:28 +08:00
|
|
|
Out << " = type ";
|
2004-05-25 16:53:40 +08:00
|
|
|
|
|
|
|
// Make sure we print out at least one level of the type structure, so
|
|
|
|
// that we do not get %FILE = type %FILE
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
|
2008-08-19 13:06:27 +08:00
|
|
|
Out << '\n';
|
2004-05-25 16:53:40 +08:00
|
|
|
}
|
2007-01-06 15:24:44 +08:00
|
|
|
}
|
|
|
|
|
2004-03-02 08:22:19 +08:00
|
|
|
/// printFunction - Print all aspects of a function.
|
|
|
|
///
|
2002-06-26 00:13:24 +08:00
|
|
|
void AssemblyWriter::printFunction(const Function *F) {
|
2008-08-19 13:06:27 +08:00
|
|
|
// Print out the return type and name.
|
|
|
|
Out << '\n';
|
2003-04-17 04:28:45 +08:00
|
|
|
|
2004-06-22 05:53:56 +08:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
|
2003-10-31 07:41:03 +08:00
|
|
|
|
2010-01-30 07:12:36 +08:00
|
|
|
if (F->isMaterializable())
|
|
|
|
Out << "; Materializable\n";
|
|
|
|
|
2013-04-17 04:55:47 +08:00
|
|
|
const AttributeSet &Attrs = F->getAttributes();
|
2013-04-30 07:48:06 +08:00
|
|
|
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) {
|
2013-04-17 04:55:47 +08:00
|
|
|
AttributeSet AS = Attrs.getFnAttributes();
|
2013-05-01 21:07:03 +08:00
|
|
|
std::string AttrStr;
|
|
|
|
|
|
|
|
unsigned Idx = 0;
|
|
|
|
for (unsigned E = AS.getNumSlots(); Idx != E; ++Idx)
|
|
|
|
if (AS.getSlotIndex(Idx) == AttributeSet::FunctionIndex)
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (AttributeSet::iterator I = AS.begin(Idx), E = AS.end(Idx);
|
|
|
|
I != E; ++I) {
|
|
|
|
Attribute Attr = *I;
|
|
|
|
if (!Attr.isStringAttribute()) {
|
|
|
|
if (!AttrStr.empty()) AttrStr += ' ';
|
|
|
|
AttrStr += Attr.getAsString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-17 04:55:47 +08:00
|
|
|
if (!AttrStr.empty())
|
|
|
|
Out << "; Function Attrs: " << AttrStr << '\n';
|
|
|
|
}
|
|
|
|
|
2007-01-31 04:08:39 +08:00
|
|
|
if (F->isDeclaration())
|
2007-08-20 06:15:26 +08:00
|
|
|
Out << "declare ";
|
|
|
|
else
|
2006-12-30 04:29:48 +08:00
|
|
|
Out << "define ";
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-08-19 13:06:27 +08:00
|
|
|
PrintLinkage(F->getLinkage(), Out);
|
|
|
|
PrintVisibility(F->getVisibility(), Out);
|
2014-01-14 23:22:47 +08:00
|
|
|
PrintDLLStorageClass(F->getDLLStorageClass(), Out);
|
2003-04-17 04:28:45 +08:00
|
|
|
|
2005-05-07 04:26:43 +08:00
|
|
|
// Print the calling convention.
|
2012-09-13 23:11:12 +08:00
|
|
|
if (F->getCallingConv() != CallingConv::C) {
|
|
|
|
PrintCallingConv(F->getCallingConv(), Out);
|
|
|
|
Out << " ";
|
2005-05-07 04:26:43 +08:00
|
|
|
}
|
|
|
|
|
2011-07-18 12:54:35 +08:00
|
|
|
FunctionType *FT = F->getFunctionType();
|
2013-01-19 05:53:16 +08:00
|
|
|
if (Attrs.hasAttributes(AttributeSet::ReturnIndex))
|
|
|
|
Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' ';
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(F->getReturnType(), Out);
|
2008-08-19 13:26:17 +08:00
|
|
|
Out << ' ';
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << '(';
|
2004-05-26 15:18:52 +08:00
|
|
|
Machine.incorporateFunction(F);
|
2001-09-08 00:36:04 +08:00
|
|
|
|
2001-10-30 00:05:51 +08:00
|
|
|
// Loop over the arguments, printing them...
|
2001-09-08 00:36:04 +08:00
|
|
|
|
2006-12-31 13:24:50 +08:00
|
|
|
unsigned Idx = 1;
|
2007-04-18 08:57:22 +08:00
|
|
|
if (!F->isDeclaration()) {
|
|
|
|
// If this isn't a declaration, print the argument names as well.
|
|
|
|
for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
// Insert commas as we go... the first arg doesn't get a comma
|
|
|
|
if (I != F->arg_begin()) Out << ", ";
|
2012-12-30 21:50:49 +08:00
|
|
|
printArgument(I, Attrs, Idx);
|
2007-04-18 08:57:22 +08:00
|
|
|
Idx++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Otherwise, print the types from the function type.
|
|
|
|
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
|
|
|
|
// Insert commas as we go... the first arg doesn't get a comma
|
|
|
|
if (i) Out << ", ";
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2007-04-18 08:57:22 +08:00
|
|
|
// Output type...
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(FT->getParamType(i), Out);
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2012-12-30 21:50:49 +08:00
|
|
|
if (Attrs.hasAttributes(i+1))
|
|
|
|
Out << ' ' << Attrs.getAsString(i+1);
|
2007-04-18 08:57:22 +08:00
|
|
|
}
|
2006-12-31 13:24:50 +08:00
|
|
|
}
|
2001-09-08 00:36:04 +08:00
|
|
|
|
|
|
|
// Finish printing arguments...
|
2002-06-26 00:13:24 +08:00
|
|
|
if (FT->isVarArg()) {
|
2004-06-22 05:53:56 +08:00
|
|
|
if (FT->getNumParams()) Out << ", ";
|
|
|
|
Out << "..."; // Output varargs portion of signature!
|
2001-09-08 00:36:04 +08:00
|
|
|
}
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ')';
|
2011-01-26 03:09:56 +08:00
|
|
|
if (F->hasUnnamedAddr())
|
|
|
|
Out << " unnamed_addr";
|
2013-04-30 07:48:06 +08:00
|
|
|
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
|
|
|
|
Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
|
2010-07-08 07:16:37 +08:00
|
|
|
if (F->hasSection()) {
|
|
|
|
Out << " section \"";
|
|
|
|
PrintEscapedString(F->getSection(), Out);
|
|
|
|
Out << '"';
|
|
|
|
}
|
2015-01-07 06:55:16 +08:00
|
|
|
maybePrintComdat(Out, *F);
|
2005-11-06 14:48:53 +08:00
|
|
|
if (F->getAlignment())
|
|
|
|
Out << " align " << F->getAlignment();
|
2008-08-18 02:44:35 +08:00
|
|
|
if (F->hasGC())
|
|
|
|
Out << " gc \"" << F->getGC() << '"';
|
2013-09-16 09:08:15 +08:00
|
|
|
if (F->hasPrefixData()) {
|
|
|
|
Out << " prefix ";
|
|
|
|
writeOperand(F->getPrefixData(), true);
|
|
|
|
}
|
2014-12-03 10:08:38 +08:00
|
|
|
if (F->hasPrologueData()) {
|
|
|
|
Out << " prologue ";
|
|
|
|
writeOperand(F->getPrologueData(), true);
|
|
|
|
}
|
|
|
|
|
2015-04-25 06:04:41 +08:00
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
|
|
|
F->getAllMetadata(MDs);
|
|
|
|
printMetadataAttachments(MDs, " ");
|
|
|
|
|
2008-09-23 06:32:29 +08:00
|
|
|
if (F->isDeclaration()) {
|
2010-09-03 06:52:10 +08:00
|
|
|
Out << '\n';
|
2008-09-23 06:32:29 +08:00
|
|
|
} else {
|
2010-09-03 06:52:10 +08:00
|
|
|
Out << " {";
|
|
|
|
// Output all of the function's basic blocks.
|
2002-06-26 00:13:24 +08:00
|
|
|
for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
|
|
|
|
printBasicBlock(I);
|
2001-09-08 00:36:04 +08:00
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
// Output the function's use-lists.
|
|
|
|
printUseLists(F);
|
|
|
|
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << "}\n";
|
2001-09-08 00:36:04 +08:00
|
|
|
}
|
|
|
|
|
2004-05-26 15:18:52 +08:00
|
|
|
Machine.purgeFunction();
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2004-03-02 08:22:19 +08:00
|
|
|
/// printArgument - This member is called for every argument that is passed into
|
|
|
|
/// the function. Simply print it out
|
|
|
|
///
|
2009-09-20 10:20:51 +08:00
|
|
|
void AssemblyWriter::printArgument(const Argument *Arg,
|
2012-12-30 21:50:49 +08:00
|
|
|
AttributeSet Attrs, unsigned Idx) {
|
2001-06-07 04:29:01 +08:00
|
|
|
// Output type...
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(Arg->getType(), Out);
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2007-11-27 21:23:08 +08:00
|
|
|
// Output parameter attributes list
|
2012-12-30 21:50:49 +08:00
|
|
|
if (Attrs.hasAttributes(Idx))
|
|
|
|
Out << ' ' << Attrs.getAsString(Idx);
|
2006-12-31 13:24:50 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
// Output name, if available...
|
2008-08-17 12:40:13 +08:00
|
|
|
if (Arg->hasName()) {
|
|
|
|
Out << ' ';
|
|
|
|
PrintLLVMName(Out, Arg);
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2004-03-02 08:22:19 +08:00
|
|
|
/// printBasicBlock - This member is called for each basic block in a method.
|
|
|
|
///
|
2001-10-30 00:05:51 +08:00
|
|
|
void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
|
2008-04-26 00:53:59 +08:00
|
|
|
if (BB->hasName()) { // Print out the label if it exists...
|
2008-08-17 12:40:13 +08:00
|
|
|
Out << "\n";
|
2009-07-26 07:55:21 +08:00
|
|
|
PrintLLVMName(Out, BB->getName(), LabelPrefix);
|
2008-08-17 12:40:13 +08:00
|
|
|
Out << ':';
|
2008-04-26 00:53:59 +08:00
|
|
|
} else if (!BB->use_empty()) { // Don't print block # of no uses...
|
2011-04-11 07:18:04 +08:00
|
|
|
Out << "\n; <label>:";
|
2007-01-11 11:54:27 +08:00
|
|
|
int Slot = Machine.getLocalSlot(BB);
|
2004-06-10 03:41:19 +08:00
|
|
|
if (Slot != -1)
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << Slot;
|
2004-06-10 03:41:19 +08:00
|
|
|
else
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << "<badref>";
|
2002-10-03 03:38:55 +08:00
|
|
|
}
|
2003-11-20 08:09:43 +08:00
|
|
|
|
2014-04-09 14:08:46 +08:00
|
|
|
if (!BB->getParent()) {
|
2009-08-17 23:48:08 +08:00
|
|
|
Out.PadToColumn(50);
|
2009-08-13 01:23:50 +08:00
|
|
|
Out << "; Error: Block without parent!";
|
|
|
|
} else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
|
2010-09-03 06:52:10 +08:00
|
|
|
// Output predecessors for the block.
|
2009-08-17 23:48:08 +08:00
|
|
|
Out.PadToColumn(50);
|
2009-08-13 01:23:50 +08:00
|
|
|
Out << ";";
|
2010-03-26 07:25:28 +08:00
|
|
|
const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2008-04-22 10:45:44 +08:00
|
|
|
if (PI == PE) {
|
|
|
|
Out << " No predecessors!";
|
|
|
|
} else {
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << " preds = ";
|
2008-04-22 10:45:44 +08:00
|
|
|
writeOperand(*PI, false);
|
|
|
|
for (++PI; PI != PE; ++PI) {
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2006-12-06 14:24:27 +08:00
|
|
|
writeOperand(*PI, false);
|
2003-11-17 06:59:57 +08:00
|
|
|
}
|
2002-10-03 03:38:55 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2008-04-22 10:45:44 +08:00
|
|
|
Out << "\n";
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-06-22 05:53:56 +08:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
|
2003-10-31 07:41:03 +08:00
|
|
|
|
2001-09-08 00:36:04 +08:00
|
|
|
// Output all of the instructions in the basic block...
|
2009-07-14 02:27:59 +08:00
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
2013-05-09 04:38:31 +08:00
|
|
|
printInstructionLine(*I);
|
2009-07-14 02:27:59 +08:00
|
|
|
}
|
2004-03-09 02:51:45 +08:00
|
|
|
|
2004-06-22 05:53:56 +08:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2013-05-09 04:38:31 +08:00
|
|
|
/// printInstructionLine - Print an instruction and a newline character.
|
|
|
|
void AssemblyWriter::printInstructionLine(const Instruction &I) {
|
|
|
|
printInstruction(I);
|
|
|
|
Out << '\n';
|
|
|
|
}
|
|
|
|
|
2015-05-05 21:20:42 +08:00
|
|
|
/// printGCRelocateComment - print comment after call to the gc.relocate
|
|
|
|
/// intrinsic indicating base and derived pointer names.
|
|
|
|
void AssemblyWriter::printGCRelocateComment(const Value &V) {
|
|
|
|
assert(isGCRelocate(&V));
|
|
|
|
GCRelocateOperands GCOps(cast<Instruction>(&V));
|
|
|
|
|
|
|
|
Out << " ; (";
|
2015-05-06 10:36:26 +08:00
|
|
|
writeOperand(GCOps.getBasePtr(), false);
|
2015-05-05 21:20:42 +08:00
|
|
|
Out << ", ";
|
2015-05-06 10:36:26 +08:00
|
|
|
writeOperand(GCOps.getDerivedPtr(), false);
|
2015-05-05 21:20:42 +08:00
|
|
|
Out << ")";
|
|
|
|
}
|
|
|
|
|
2004-03-02 08:22:19 +08:00
|
|
|
/// printInfoComment - Print a little comment after the instruction indicating
|
|
|
|
/// which slot it occupies.
|
|
|
|
///
|
2002-06-26 00:13:24 +08:00
|
|
|
void AssemblyWriter::printInfoComment(const Value &V) {
|
2015-05-05 21:20:42 +08:00
|
|
|
if (isGCRelocate(&V))
|
|
|
|
printGCRelocateComment(V);
|
|
|
|
|
2013-04-17 04:55:47 +08:00
|
|
|
if (AnnotationWriter)
|
2010-02-11 04:41:46 +08:00
|
|
|
AnnotationWriter->printInfoComment(V, Out);
|
2001-10-13 14:42:36 +08:00
|
|
|
}
|
|
|
|
|
2006-08-28 09:02:49 +08:00
|
|
|
// This member is called for each Instruction in a function..
|
2002-06-26 00:13:24 +08:00
|
|
|
void AssemblyWriter::printInstruction(const Instruction &I) {
|
2004-06-22 05:53:56 +08:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
|
2003-10-31 07:41:03 +08:00
|
|
|
|
2009-08-13 07:32:33 +08:00
|
|
|
// Print out indentation for an instruction.
|
2009-08-13 09:41:52 +08:00
|
|
|
Out << " ";
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
// Print out name if it exists...
|
2008-08-17 12:40:13 +08:00
|
|
|
if (I.hasName()) {
|
|
|
|
PrintLLVMName(Out, &I);
|
|
|
|
Out << " = ";
|
2009-12-29 15:25:48 +08:00
|
|
|
} else if (!I.getType()->isVoidTy()) {
|
2008-08-30 01:19:30 +08:00
|
|
|
// Print out the def slot taken.
|
|
|
|
int SlotNum = Machine.getLocalSlot(&I);
|
|
|
|
if (SlotNum == -1)
|
|
|
|
Out << "<badref> = ";
|
|
|
|
else
|
|
|
|
Out << '%' << SlotNum << " = ";
|
2008-08-17 12:40:13 +08:00
|
|
|
}
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2014-04-25 04:14:34 +08:00
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
|
|
|
|
if (CI->isMustTailCall())
|
|
|
|
Out << "musttail ";
|
|
|
|
else if (CI->isTailCall())
|
|
|
|
Out << "tail ";
|
|
|
|
}
|
2003-09-09 01:45:59 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
// Print out the opcode...
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << I.getOpcodeName();
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2011-08-13 06:50:01 +08:00
|
|
|
// If this is an atomic load or store, print out the atomic marker.
|
|
|
|
if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
|
|
|
|
(isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
|
|
|
|
Out << " atomic";
|
|
|
|
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
llvm-svn: 210903
2014-06-13 22:24:07 +08:00
|
|
|
if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
|
|
|
|
Out << " weak";
|
|
|
|
|
2011-08-13 06:50:01 +08:00
|
|
|
// If this is a volatile operation, print out the volatile marker.
|
|
|
|
if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
|
|
|
|
(isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
|
|
|
|
(isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
|
|
|
|
(isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
|
|
|
|
Out << " volatile";
|
|
|
|
|
2009-07-28 00:11:46 +08:00
|
|
|
// Print out optimization information.
|
|
|
|
WriteOptimizationInfo(Out, &I);
|
|
|
|
|
2006-12-03 14:27:29 +08:00
|
|
|
// Print out the compare instruction predicates
|
2008-05-13 03:01:56 +08:00
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
|
2008-08-24 06:52:27 +08:00
|
|
|
Out << ' ' << getPredicateText(CI->getPredicate());
|
2006-12-03 14:27:29 +08:00
|
|
|
|
2011-07-29 05:48:00 +08:00
|
|
|
// Print out the atomicrmw operation
|
|
|
|
if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
|
|
|
|
writeAtomicRMWOperation(Out, RMWI->getOperation());
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
// Print out the type of the operands...
|
2014-04-09 14:08:46 +08:00
|
|
|
const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
// Special case conditional branches to swizzle the condition out to the front
|
2009-02-09 23:45:06 +08:00
|
|
|
if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
|
2013-02-11 09:16:51 +08:00
|
|
|
const BranchInst &BI(cast<BranchInst>(I));
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2009-02-09 23:45:06 +08:00
|
|
|
writeOperand(BI.getCondition(), true);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2009-02-09 23:45:06 +08:00
|
|
|
writeOperand(BI.getSuccessor(0), true);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2009-02-09 23:45:06 +08:00
|
|
|
writeOperand(BI.getSuccessor(1), true);
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-04-14 02:34:38 +08:00
|
|
|
} else if (isa<SwitchInst>(I)) {
|
2013-02-11 09:16:51 +08:00
|
|
|
const SwitchInst& SI(cast<SwitchInst>(I));
|
2009-10-28 03:13:16 +08:00
|
|
|
// Special case switch instruction to get formatting nice and correct.
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2011-09-30 04:21:17 +08:00
|
|
|
writeOperand(SI.getCondition(), true);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2011-09-30 04:21:17 +08:00
|
|
|
writeOperand(SI.getDefaultDest(), true);
|
2008-08-24 06:52:27 +08:00
|
|
|
Out << " [";
|
2013-02-11 09:16:51 +08:00
|
|
|
for (SwitchInst::ConstCaseIt i = SI.case_begin(), e = SI.case_end();
|
2012-03-08 15:06:20 +08:00
|
|
|
i != e; ++i) {
|
2009-08-13 09:41:52 +08:00
|
|
|
Out << "\n ";
|
2012-03-08 15:06:20 +08:00
|
|
|
writeOperand(i.getCaseValue(), true);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2012-03-08 15:06:20 +08:00
|
|
|
writeOperand(i.getCaseSuccessor(), true);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2009-08-13 09:41:52 +08:00
|
|
|
Out << "\n ]";
|
2009-10-28 08:19:10 +08:00
|
|
|
} else if (isa<IndirectBrInst>(I)) {
|
|
|
|
// Special case indirectbr instruction to get formatting nice and correct.
|
2009-10-28 03:13:16 +08:00
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, true);
|
2009-10-30 10:01:10 +08:00
|
|
|
Out << ", [";
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-10-28 03:13:16 +08:00
|
|
|
for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
|
|
|
|
if (i != 1)
|
|
|
|
Out << ", ";
|
|
|
|
writeOperand(I.getOperand(i), true);
|
|
|
|
}
|
|
|
|
Out << ']';
|
2011-06-20 22:18:48 +08:00
|
|
|
} else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ' ';
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ' ';
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2011-06-20 22:18:48 +08:00
|
|
|
for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
|
2004-06-22 05:53:56 +08:00
|
|
|
if (op) Out << ", ";
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << "[ ";
|
2011-06-20 22:18:48 +08:00
|
|
|
writeOperand(PN->getIncomingValue(op), false); Out << ", ";
|
|
|
|
writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
|
2001-06-11 23:04:20 +08:00
|
|
|
}
|
2008-06-01 03:12:39 +08:00
|
|
|
} else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2008-06-01 03:12:39 +08:00
|
|
|
writeOperand(I.getOperand(0), true);
|
|
|
|
for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
|
|
|
|
Out << ", " << *i;
|
|
|
|
} else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
|
|
|
writeOperand(I.getOperand(0), true); Out << ", ";
|
2008-06-01 03:12:39 +08:00
|
|
|
writeOperand(I.getOperand(1), true);
|
|
|
|
for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
|
|
|
|
Out << ", " << *i;
|
2011-08-13 04:24:12 +08:00
|
|
|
} else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
|
|
|
|
Out << ' ';
|
|
|
|
TypePrinter.print(I.getType(), Out);
|
|
|
|
Out << " personality ";
|
|
|
|
writeOperand(I.getOperand(0), true); Out << '\n';
|
|
|
|
|
|
|
|
if (LPI->isCleanup())
|
|
|
|
Out << " cleanup";
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
|
|
|
|
if (i != 0 || LPI->isCleanup()) Out << "\n";
|
|
|
|
if (LPI->isCatch(i))
|
|
|
|
Out << " catch ";
|
|
|
|
else
|
|
|
|
Out << " filter ";
|
|
|
|
|
|
|
|
writeOperand(LPI->getClause(i), true);
|
|
|
|
}
|
2008-02-23 08:35:18 +08:00
|
|
|
} else if (isa<ReturnInst>(I) && !Operand) {
|
|
|
|
Out << " void";
|
2005-05-07 04:26:43 +08:00
|
|
|
} else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
|
|
|
|
// Print the calling convention being used.
|
2012-09-13 23:11:12 +08:00
|
|
|
if (CI->getCallingConv() != CallingConv::C) {
|
|
|
|
Out << " ";
|
|
|
|
PrintCallingConv(CI->getCallingConv(), Out);
|
2005-05-07 04:26:43 +08:00
|
|
|
}
|
|
|
|
|
2010-06-23 21:09:06 +08:00
|
|
|
Operand = CI->getCalledValue();
|
[opaque pointer type] Add textual IR support for explicit type parameter to the call instruction
See r230786 and r230794 for similar changes to gep and load
respectively.
Call is a bit different because it often doesn't have a single explicit
type - usually the type is deduced from the arguments, and just the
return type is explicit. In those cases there's no need to change the
IR.
When that's not the case, the IR usually contains the pointer type of
the first operand - but since typed pointers are going away, that
representation is insufficient so I'm just stripping the "pointerness"
of the explicit type away.
This does make the IR a bit weird - it /sort of/ reads like the type of
the first operand: "call void () %x(" but %x is actually of type "void
()*" and will eventually be just of type "ptr". But this seems not too
bad and I don't think it would benefit from repeating the type
("void (), void () * %x(" and then eventually "void (), ptr %x(") as has
been done with gep and load.
This also has a side benefit: since the explicit type is no longer a
pointer, there's no ambiguity between an explicit type and a function
that returns a function pointer. Previously this case needed an explicit
type (eg: a function returning a void() function was written as
"call void () () * @x(" rather than "call void () * @x(" because of the
ambiguity between a function returning a pointer to a void() function
and a function returning void).
No ambiguity means even function pointer return types can just be
written alone, without writing the whole function's type.
This leaves /only/ the varargs case where the explicit type is required.
Given the special type syntax in call instructions, the regex-fu used
for migration was a bit more involved in its own unique way (as every
one of these is) so here it is. Use it in conjunction with the apply.sh
script and associated find/xargs commands I've provided in rr230786 to
migrate your out of tree tests. Do let me know if any of this doesn't
cover your cases & we can iterate on a more general script/regexes to
help others with out of tree tests.
About 9 test cases couldn't be automatically migrated - half of those
were functions returning function pointers, where I just had to manually
delete the function argument types now that we didn't need an explicit
function type there. The other half were typedefs of function types used
in calls - just had to manually drop the * from those.
import fileinput
import sys
import re
pat = re.compile(r'((?:=|:|^|\s)call\s(?:[^@]*?))(\s*$|\s*(?:(?:\[\[[a-zA-Z0-9_]+\]\]|[@%](?:(")?[\\\?@a-zA-Z0-9_.]*?(?(3)"|)|{{.*}}))(?:\(|$)|undef|inttoptr|bitcast|null|asm).*$)')
addrspace_end = re.compile(r"addrspace\(\d+\)\s*\*$")
func_end = re.compile("(?:void.*|\)\s*)\*$")
def conv(match, line):
if not match or re.search(addrspace_end, match.group(1)) or not re.search(func_end, match.group(1)):
return line
return line[:match.start()] + match.group(1)[:match.group(1).rfind('*')].rstrip() + match.group(2) + line[match.end():]
for line in sys.stdin:
sys.stdout.write(conv(re.search(pat, line), line))
llvm-svn: 235145
2015-04-17 07:24:18 +08:00
|
|
|
FunctionType *FTy = cast<FunctionType>(CI->getFunctionType());
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Type *RetTy = FTy->getReturnType();
|
2012-12-08 07:16:57 +08:00
|
|
|
const AttributeSet &PAL = CI->getAttributes();
|
2001-11-07 05:28:12 +08:00
|
|
|
|
2013-01-19 05:53:16 +08:00
|
|
|
if (PAL.hasAttributes(AttributeSet::ReturnIndex))
|
|
|
|
Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex);
|
2008-09-30 04:49:50 +08:00
|
|
|
|
2003-08-05 23:34:45 +08:00
|
|
|
// If possible, print out the short form of the call instruction. We can
|
2002-04-08 06:49:37 +08:00
|
|
|
// only do this if the first argument is a pointer to a nonvararg function,
|
2003-08-05 23:34:45 +08:00
|
|
|
// and if the return type is not a pointer to a function.
|
2001-11-07 05:28:12 +08:00
|
|
|
//
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
[opaque pointer type] Add textual IR support for explicit type parameter to the call instruction
See r230786 and r230794 for similar changes to gep and load
respectively.
Call is a bit different because it often doesn't have a single explicit
type - usually the type is deduced from the arguments, and just the
return type is explicit. In those cases there's no need to change the
IR.
When that's not the case, the IR usually contains the pointer type of
the first operand - but since typed pointers are going away, that
representation is insufficient so I'm just stripping the "pointerness"
of the explicit type away.
This does make the IR a bit weird - it /sort of/ reads like the type of
the first operand: "call void () %x(" but %x is actually of type "void
()*" and will eventually be just of type "ptr". But this seems not too
bad and I don't think it would benefit from repeating the type
("void (), void () * %x(" and then eventually "void (), ptr %x(") as has
been done with gep and load.
This also has a side benefit: since the explicit type is no longer a
pointer, there's no ambiguity between an explicit type and a function
that returns a function pointer. Previously this case needed an explicit
type (eg: a function returning a void() function was written as
"call void () () * @x(" rather than "call void () * @x(" because of the
ambiguity between a function returning a pointer to a void() function
and a function returning void).
No ambiguity means even function pointer return types can just be
written alone, without writing the whole function's type.
This leaves /only/ the varargs case where the explicit type is required.
Given the special type syntax in call instructions, the regex-fu used
for migration was a bit more involved in its own unique way (as every
one of these is) so here it is. Use it in conjunction with the apply.sh
script and associated find/xargs commands I've provided in rr230786 to
migrate your out of tree tests. Do let me know if any of this doesn't
cover your cases & we can iterate on a more general script/regexes to
help others with out of tree tests.
About 9 test cases couldn't be automatically migrated - half of those
were functions returning function pointers, where I just had to manually
delete the function argument types now that we didn't need an explicit
function type there. The other half were typedefs of function types used
in calls - just had to manually drop the * from those.
import fileinput
import sys
import re
pat = re.compile(r'((?:=|:|^|\s)call\s(?:[^@]*?))(\s*$|\s*(?:(?:\[\[[a-zA-Z0-9_]+\]\]|[@%](?:(")?[\\\?@a-zA-Z0-9_.]*?(?(3)"|)|{{.*}}))(?:\(|$)|undef|inttoptr|bitcast|null|asm).*$)')
addrspace_end = re.compile(r"addrspace\(\d+\)\s*\*$")
func_end = re.compile("(?:void.*|\)\s*)\*$")
def conv(match, line):
if not match or re.search(addrspace_end, match.group(1)) or not re.search(func_end, match.group(1)):
return line
return line[:match.start()] + match.group(1)[:match.group(1).rfind('*')].rstrip() + match.group(2) + line[match.end():]
for line in sys.stdin:
sys.stdout.write(conv(re.search(pat, line), line))
llvm-svn: 235145
2015-04-17 07:24:18 +08:00
|
|
|
TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, false);
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << '(';
|
2010-06-23 21:09:06 +08:00
|
|
|
for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
|
|
|
|
if (op > 0)
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2012-12-30 21:50:49 +08:00
|
|
|
writeParamOperand(CI->getArgOperand(op), PAL, op + 1);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2014-08-26 08:33:28 +08:00
|
|
|
|
|
|
|
// Emit an ellipsis if this is a musttail call in a vararg function. This
|
|
|
|
// is only to aid readability, musttail calls forward varargs by default.
|
|
|
|
if (CI->isMustTailCall() && CI->getParent() &&
|
|
|
|
CI->getParent()->getParent() &&
|
|
|
|
CI->getParent()->getParent()->isVarArg())
|
|
|
|
Out << ", ...";
|
|
|
|
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ')';
|
2012-12-30 18:32:01 +08:00
|
|
|
if (PAL.hasAttributes(AttributeSet::FunctionIndex))
|
2013-02-22 17:09:42 +08:00
|
|
|
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
|
2002-06-26 00:13:24 +08:00
|
|
|
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
|
2010-03-24 21:21:49 +08:00
|
|
|
Operand = II->getCalledValue();
|
2015-04-25 03:32:54 +08:00
|
|
|
FunctionType *FTy = cast<FunctionType>(II->getFunctionType());
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Type *RetTy = FTy->getReturnType();
|
2012-12-08 07:16:57 +08:00
|
|
|
const AttributeSet &PAL = II->getAttributes();
|
2003-08-05 23:34:45 +08:00
|
|
|
|
2005-05-07 04:26:43 +08:00
|
|
|
// Print the calling convention being used.
|
2012-09-13 23:11:12 +08:00
|
|
|
if (II->getCallingConv() != CallingConv::C) {
|
|
|
|
Out << " ";
|
|
|
|
PrintCallingConv(II->getCallingConv(), Out);
|
2005-05-07 04:26:43 +08:00
|
|
|
}
|
|
|
|
|
2013-01-19 05:53:16 +08:00
|
|
|
if (PAL.hasAttributes(AttributeSet::ReturnIndex))
|
|
|
|
Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex);
|
2008-09-30 04:49:50 +08:00
|
|
|
|
2003-08-05 23:34:45 +08:00
|
|
|
// If possible, print out the short form of the invoke instruction. We can
|
|
|
|
// only do this if the first argument is a pointer to a nonvararg function,
|
|
|
|
// and if the return type is not a pointer to a function.
|
|
|
|
//
|
2008-10-16 02:02:08 +08:00
|
|
|
Out << ' ';
|
2015-04-25 03:32:54 +08:00
|
|
|
TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, false);
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << '(';
|
2010-06-23 21:09:06 +08:00
|
|
|
for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
|
2010-03-24 21:21:49 +08:00
|
|
|
if (op)
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2012-12-30 21:50:49 +08:00
|
|
|
writeParamOperand(II->getArgOperand(op), PAL, op + 1);
|
2001-10-13 14:42:36 +08:00
|
|
|
}
|
|
|
|
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ')';
|
2012-12-30 18:32:01 +08:00
|
|
|
if (PAL.hasAttributes(AttributeSet::FunctionIndex))
|
2013-02-22 17:09:42 +08:00
|
|
|
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
|
2008-09-27 06:53:05 +08:00
|
|
|
|
2009-08-13 09:41:52 +08:00
|
|
|
Out << "\n to ";
|
2001-10-13 14:42:36 +08:00
|
|
|
writeOperand(II->getNormalDest(), true);
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << " unwind ";
|
2004-02-09 05:44:31 +08:00
|
|
|
writeOperand(II->getUnwindDest(), true);
|
2001-10-13 14:42:36 +08:00
|
|
|
|
2009-10-24 05:09:37 +08:00
|
|
|
} else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ' ';
|
2014-01-25 09:24:06 +08:00
|
|
|
if (AI->isUsedWithInAlloca())
|
2014-03-09 14:41:58 +08:00
|
|
|
Out << "inalloca ";
|
|
|
|
TypePrinter.print(AI->getAllocatedType(), Out);
|
AsmWriter: Write alloca array size explicitly (and -instcombine fixup)
Write the `alloca` array size explicitly when it's non-canonical.
Previously, if the array size was `iX 1` (where X is not 32), the type
would mutate to `i32` when round-tripping through assembly.
The testcase I added fails in `verify-uselistorder` (as well as
`FileCheck`), since the use-lists for `i32 1` and `i64 1` change.
(Manman Ren came across this when running `verify-uselistorder` on some
non-trivial, optimized code as part of PR5680.)
The type mutation started with r104911, which allowed array sizes to be
something other than an `i32`. Starting with r204945, we
"canonicalized" to `i64` on 64-bit platforms -- and then on every
round-trip through assembly, mutated back to `i32`.
I bundled a fixup for `-instcombine` to avoid r204945 on scalar
allocations. (There wasn't a clean way to sequence this into two
commits, since the assembly change on its own caused testcase churn, and
the `-instcombine` change can't be tested without the assembly changes.)
An obvious alternative fix -- change `AllocaInst::AllocaInst()`,
`AsmWriter` and `LLParser` to treat `intptr_t` as the canonical type for
scalar allocations -- was rejected out of hand, since this required
teaching them each about the data layout.
A follow-up commit will add an `-instcombine` to canonicalize the scalar
allocation array size to `i32 1` rather than leaving `iX 1` alone.
rdar://problem/20075773
llvm-svn: 232200
2015-03-14 03:30:44 +08:00
|
|
|
|
|
|
|
// Explicitly write the array size if the code is broken, if it's an array
|
|
|
|
// allocation, or if the type is not canonical for scalar allocations. The
|
|
|
|
// latter case prevents the type from mutating when round-tripping through
|
|
|
|
// assembly.
|
|
|
|
if (!AI->getArraySize() || AI->isArrayAllocation() ||
|
|
|
|
!AI->getArraySize()->getType()->isIntegerTy(32)) {
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ", ";
|
2002-04-14 02:34:38 +08:00
|
|
|
writeOperand(AI->getArraySize(), true);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2005-11-05 17:21:28 +08:00
|
|
|
if (AI->getAlignment()) {
|
2005-11-06 05:20:34 +08:00
|
|
|
Out << ", align " << AI->getAlignment();
|
2005-11-05 17:21:28 +08:00
|
|
|
}
|
2001-10-13 14:42:36 +08:00
|
|
|
} else if (isa<CastInst>(I)) {
|
2008-09-15 01:21:12 +08:00
|
|
|
if (Operand) {
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, true); // Work with broken code
|
|
|
|
}
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << " to ";
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
2003-10-18 13:57:43 +08:00
|
|
|
} else if (isa<VAArgInst>(I)) {
|
2008-09-15 01:21:12 +08:00
|
|
|
if (Operand) {
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, true); // Work with broken code
|
|
|
|
}
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ", ";
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
|
|
|
} else if (Operand) { // Print the normal way.
|
2015-02-28 05:17:42 +08:00
|
|
|
if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
|
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
llvm-svn: 230786
2015-02-28 03:29:02 +08:00
|
|
|
Out << ' ';
|
|
|
|
TypePrinter.print(GEP->getSourceElementType(), Out);
|
|
|
|
Out << ',';
|
2015-02-28 05:17:42 +08:00
|
|
|
} else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
|
|
|
|
Out << ' ';
|
|
|
|
TypePrinter.print(LI->getType(), Out);
|
2015-03-02 23:24:41 +08:00
|
|
|
Out << ',';
|
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
llvm-svn: 230786
2015-02-28 03:29:02 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-04-22 07:48:37 +08:00
|
|
|
// PrintAllTypes - Instructions who have operands of all the same type
|
2001-06-07 04:29:01 +08:00
|
|
|
// omit the type from all but the first operand. If the instruction has
|
|
|
|
// different type operands (for example br), then they are all printed.
|
|
|
|
bool PrintAllTypes = false;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
Type *TheType = Operand->getType();
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2007-02-02 21:54:55 +08:00
|
|
|
// Select, Store and ShuffleVector always print all types.
|
2008-03-05 06:05:14 +08:00
|
|
|
if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
|
|
|
|
|| isa<ReturnInst>(I)) {
|
2003-04-17 04:20:02 +08:00
|
|
|
PrintAllTypes = true;
|
|
|
|
} else {
|
|
|
|
for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
|
|
|
|
Operand = I.getOperand(i);
|
2009-01-16 02:40:57 +08:00
|
|
|
// note that Operand shouldn't be null, but the test helps make dump()
|
|
|
|
// more tolerant of malformed IR
|
2009-01-15 01:51:41 +08:00
|
|
|
if (Operand && Operand->getType() != TheType) {
|
2003-04-17 04:20:02 +08:00
|
|
|
PrintAllTypes = true; // We have differing types! Print them all!
|
|
|
|
break;
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
}
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2001-10-30 00:05:51 +08:00
|
|
|
if (!PrintAllTypes) {
|
2004-06-22 05:53:56 +08:00
|
|
|
Out << ' ';
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(TheType, Out);
|
2001-10-30 00:05:51 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2008-09-15 01:21:12 +08:00
|
|
|
Out << ' ';
|
2002-06-26 00:13:24 +08:00
|
|
|
for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
|
2008-09-15 01:21:12 +08:00
|
|
|
if (i) Out << ", ";
|
2002-06-26 00:13:24 +08:00
|
|
|
writeOperand(I.getOperand(i), PrintAllTypes);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2011-08-10 07:02:53 +08:00
|
|
|
// Print atomic ordering/alignment for memory operations
|
|
|
|
if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
|
|
|
|
if (LI->isAtomic())
|
|
|
|
writeAtomic(LI->getOrdering(), LI->getSynchScope());
|
|
|
|
if (LI->getAlignment())
|
|
|
|
Out << ", align " << LI->getAlignment();
|
|
|
|
} else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
|
|
|
|
if (SI->isAtomic())
|
|
|
|
writeAtomic(SI->getOrdering(), SI->getSynchScope());
|
|
|
|
if (SI->getAlignment())
|
|
|
|
Out << ", align " << SI->getAlignment();
|
2011-07-29 05:48:00 +08:00
|
|
|
} else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
|
2014-03-11 18:48:52 +08:00
|
|
|
writeAtomicCmpXchg(CXI->getSuccessOrdering(), CXI->getFailureOrdering(),
|
|
|
|
CXI->getSynchScope());
|
2011-07-29 05:48:00 +08:00
|
|
|
} else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
|
|
|
|
writeAtomic(RMWI->getOrdering(), RMWI->getSynchScope());
|
2011-07-26 07:16:38 +08:00
|
|
|
} else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
|
|
|
|
writeAtomic(FI->getOrdering(), FI->getSynchScope());
|
2007-04-23 03:24:39 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2009-12-29 04:10:43 +08:00
|
|
|
// Print Metadata info.
|
2014-11-12 05:30:22 +08:00
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
|
2010-02-25 14:53:04 +08:00
|
|
|
I.getAllMetadata(InstMD);
|
2015-04-25 05:06:21 +08:00
|
|
|
printMetadataAttachments(InstMD, ", ");
|
2015-04-25 04:59:52 +08:00
|
|
|
|
|
|
|
// Print a nice comment.
|
|
|
|
printInfoComment(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AssemblyWriter::printMetadataAttachments(
|
2015-04-25 05:06:21 +08:00
|
|
|
const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
|
|
|
|
StringRef Separator) {
|
2015-04-25 04:59:52 +08:00
|
|
|
if (MDs.empty())
|
|
|
|
return;
|
|
|
|
|
2015-04-25 05:03:05 +08:00
|
|
|
if (MDNames.empty())
|
|
|
|
TheModule->getMDKindNames(MDNames);
|
|
|
|
|
2015-04-25 04:59:52 +08:00
|
|
|
for (const auto &I : MDs) {
|
|
|
|
unsigned Kind = I.first;
|
2015-04-25 05:06:21 +08:00
|
|
|
Out << Separator;
|
2015-06-03 05:25:08 +08:00
|
|
|
if (Kind < MDNames.size()) {
|
|
|
|
Out << "!";
|
|
|
|
printMetadataIdentifier(MDNames[Kind], Out);
|
|
|
|
} else
|
2015-04-25 05:06:21 +08:00
|
|
|
Out << "!<unknown kind #" << Kind << ">";
|
2015-04-25 04:59:52 +08:00
|
|
|
Out << ' ';
|
|
|
|
WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
|
2009-10-08 00:37:55 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2013-05-09 04:38:31 +08:00
|
|
|
void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
|
IR: Make metadata typeless in assembly
Now that `Metadata` is typeless, reflect that in the assembly. These
are the matching assembly changes for the metadata/value split in
r223802.
- Only use the `metadata` type when referencing metadata from a call
intrinsic -- i.e., only when it's used as a `Value`.
- Stop pretending that `ValueAsMetadata` is wrapped in an `MDNode`
when referencing it from call intrinsics.
So, assembly like this:
define @foo(i32 %v) {
call void @llvm.foo(metadata !{i32 %v}, metadata !0)
call void @llvm.foo(metadata !{i32 7}, metadata !0)
call void @llvm.foo(metadata !1, metadata !0)
call void @llvm.foo(metadata !3, metadata !0)
call void @llvm.foo(metadata !{metadata !3}, metadata !0)
ret void, !bar !2
}
!0 = metadata !{metadata !2}
!1 = metadata !{i32* @global}
!2 = metadata !{metadata !3}
!3 = metadata !{}
turns into this:
define @foo(i32 %v) {
call void @llvm.foo(metadata i32 %v, metadata !0)
call void @llvm.foo(metadata i32 7, metadata !0)
call void @llvm.foo(metadata i32* @global, metadata !0)
call void @llvm.foo(metadata !3, metadata !0)
call void @llvm.foo(metadata !{!3}, metadata !0)
ret void, !bar !2
}
!0 = !{!2}
!1 = !{i32* @global}
!2 = !{!3}
!3 = !{}
I wrote an upgrade script that handled almost all of the tests in llvm
and many of the tests in cfe (even handling many `CHECK` lines). I've
attached it (or will attach it in a moment if you're speedy) to PR21532
to help everyone update their out-of-tree testcases.
This is part of PR21532.
llvm-svn: 224257
2014-12-16 03:07:53 +08:00
|
|
|
Out << '!' << Slot << " = ";
|
2013-05-09 04:38:31 +08:00
|
|
|
printMDNodeBody(Node);
|
2015-02-26 06:46:38 +08:00
|
|
|
Out << "\n";
|
2013-05-09 04:38:31 +08:00
|
|
|
}
|
|
|
|
|
2009-12-31 10:13:35 +08:00
|
|
|
void AssemblyWriter::writeAllMDNodes() {
|
|
|
|
SmallVector<const MDNode *, 16> Nodes;
|
2009-12-31 10:20:11 +08:00
|
|
|
Nodes.resize(Machine.mdn_size());
|
|
|
|
for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
|
|
|
|
I != E; ++I)
|
2009-12-31 10:13:35 +08:00
|
|
|
Nodes[I->second] = cast<MDNode>(I->first);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
2009-12-31 10:13:35 +08:00
|
|
|
for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
|
2013-05-09 04:38:31 +08:00
|
|
|
writeMDNode(i, Nodes[i]);
|
2009-12-31 10:13:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
|
2010-07-21 07:55:01 +08:00
|
|
|
WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
|
2009-12-31 10:13:35 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2013-02-11 16:43:33 +08:00
|
|
|
void AssemblyWriter::writeAllAttributeGroups() {
|
|
|
|
std::vector<std::pair<AttributeSet, unsigned> > asVec;
|
|
|
|
asVec.resize(Machine.as_size());
|
|
|
|
|
|
|
|
for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
|
|
|
|
I != E; ++I)
|
|
|
|
asVec[I->second] = *I;
|
|
|
|
|
|
|
|
for (std::vector<std::pair<AttributeSet, unsigned> >::iterator
|
|
|
|
I = asVec.begin(), E = asVec.end(); I != E; ++I)
|
|
|
|
Out << "attributes #" << I->second << " = { "
|
2013-05-01 21:07:03 +08:00
|
|
|
<< I->first.getAsString(AttributeSet::FunctionIndex, true) << " }\n";
|
2013-02-11 16:43:33 +08:00
|
|
|
}
|
|
|
|
|
2014-08-20 05:30:15 +08:00
|
|
|
void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
|
|
|
|
bool IsInFunction = Machine.getFunction();
|
|
|
|
if (IsInFunction)
|
|
|
|
Out << " ";
|
|
|
|
|
|
|
|
Out << "uselistorder";
|
|
|
|
if (const BasicBlock *BB =
|
|
|
|
IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
|
|
|
|
Out << "_bb ";
|
|
|
|
writeOperand(BB->getParent(), false);
|
|
|
|
Out << ", ";
|
|
|
|
writeOperand(BB, false);
|
|
|
|
} else {
|
|
|
|
Out << " ";
|
|
|
|
writeOperand(Order.V, true);
|
|
|
|
}
|
|
|
|
Out << ", { ";
|
|
|
|
|
|
|
|
assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
|
|
|
|
Out << Order.Shuffle[0];
|
|
|
|
for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
|
|
|
|
Out << ", " << Order.Shuffle[I];
|
|
|
|
Out << " }\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
void AssemblyWriter::printUseLists(const Function *F) {
|
|
|
|
auto hasMore =
|
|
|
|
[&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
|
|
|
|
if (!hasMore())
|
|
|
|
// Nothing to do.
|
|
|
|
return;
|
|
|
|
|
|
|
|
Out << "\n; uselistorder directives\n";
|
|
|
|
while (hasMore()) {
|
|
|
|
printUseListOrder(UseListOrders.back());
|
|
|
|
UseListOrders.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// External Interface declarations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-04-14 06:36:38 +08:00
|
|
|
void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const {
|
|
|
|
SlotTracker SlotTable(this->getParent());
|
|
|
|
formatted_raw_ostream OS(ROS);
|
|
|
|
AssemblyWriter W(OS, SlotTable, this->getParent(), AAW);
|
|
|
|
W.printFunction(this);
|
|
|
|
}
|
|
|
|
|
2015-04-15 10:12:41 +08:00
|
|
|
void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder) const {
|
2008-08-24 06:23:09 +08:00
|
|
|
SlotTracker SlotTable(this);
|
2009-08-13 01:23:50 +08:00
|
|
|
formatted_raw_ostream OS(ROS);
|
2015-04-15 10:12:41 +08:00
|
|
|
AssemblyWriter W(OS, SlotTable, this, AAW, ShouldPreserveUseListOrder);
|
2009-12-31 10:23:35 +08:00
|
|
|
W.printModule(this);
|
2002-04-09 06:03:40 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2014-04-23 20:23:05 +08:00
|
|
|
void NamedMDNode::print(raw_ostream &ROS) const {
|
2010-07-22 07:38:33 +08:00
|
|
|
SlotTracker SlotTable(getParent());
|
|
|
|
formatted_raw_ostream OS(ROS);
|
2014-04-23 20:23:05 +08:00
|
|
|
AssemblyWriter W(OS, SlotTable, getParent(), nullptr);
|
2010-07-22 07:38:33 +08:00
|
|
|
W.printNamedMDNode(this);
|
|
|
|
}
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
void Comdat::print(raw_ostream &ROS) const {
|
|
|
|
PrintLLVMName(ROS, getName(), ComdatPrefix);
|
|
|
|
ROS << " = comdat ";
|
|
|
|
|
|
|
|
switch (getSelectionKind()) {
|
|
|
|
case Comdat::Any:
|
|
|
|
ROS << "any";
|
|
|
|
break;
|
|
|
|
case Comdat::ExactMatch:
|
|
|
|
ROS << "exactmatch";
|
|
|
|
break;
|
|
|
|
case Comdat::Largest:
|
|
|
|
ROS << "largest";
|
|
|
|
break;
|
|
|
|
case Comdat::NoDuplicates:
|
|
|
|
ROS << "noduplicates";
|
|
|
|
break;
|
|
|
|
case Comdat::SameSize:
|
|
|
|
ROS << "samesize";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ROS << '\n';
|
|
|
|
}
|
|
|
|
|
2009-03-01 05:11:05 +08:00
|
|
|
void Type::print(raw_ostream &OS) const {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
TypePrinting TP;
|
|
|
|
TP.print(const_cast<Type*>(this), OS);
|
2011-10-01 03:48:58 +08:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
// If the type is a named struct type, print the body as well.
|
|
|
|
if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
|
2011-08-13 02:07:07 +08:00
|
|
|
if (!STy->isLiteral()) {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-10 01:41:24 +08:00
|
|
|
OS << " = type ";
|
|
|
|
TP.printStructBody(STy, OS);
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
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
|
|
|
static bool isReferencingMDNode(const Instruction &I) {
|
|
|
|
if (const auto *CI = dyn_cast<CallInst>(&I))
|
|
|
|
if (Function *F = CI->getCalledFunction())
|
|
|
|
if (F->isIntrinsic())
|
|
|
|
for (auto &Op : I.operands())
|
|
|
|
if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
|
|
|
|
if (isa<MDNode>(V->getMetadata()))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-04-06 07:33:25 +08:00
|
|
|
void Value::print(raw_ostream &ROS) const {
|
2009-08-13 04:56:03 +08:00
|
|
|
formatted_raw_ostream OS(ROS);
|
2008-08-24 06:23:09 +08:00
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(this)) {
|
2014-04-06 07:33:25 +08:00
|
|
|
const Function *F = I->getParent() ? I->getParent()->getParent() : nullptr;
|
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
|
|
|
SlotTracker SlotTable(
|
|
|
|
F,
|
|
|
|
/* ShouldInitializeAllMetadata */ isReferencingMDNode(*I));
|
2014-04-06 07:33:25 +08:00
|
|
|
AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr);
|
2009-12-31 10:23:35 +08:00
|
|
|
W.printInstruction(*I);
|
2008-08-24 06:23:09 +08:00
|
|
|
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
|
|
|
|
SlotTracker SlotTable(BB->getParent());
|
2014-04-06 07:33:25 +08:00
|
|
|
AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr);
|
2009-12-31 10:23:35 +08:00
|
|
|
W.printBasicBlock(BB);
|
2008-08-24 06:23:09 +08:00
|
|
|
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
|
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
|
|
|
SlotTracker SlotTable(GV->getParent(),
|
|
|
|
/* ShouldInitializeAllMetadata */ isa<Function>(GV));
|
2014-04-06 07:33:25 +08:00
|
|
|
AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr);
|
2009-12-31 10:23:35 +08:00
|
|
|
if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
|
|
|
|
W.printGlobal(V);
|
|
|
|
else if (const Function *F = dyn_cast<Function>(GV))
|
|
|
|
W.printFunction(F);
|
|
|
|
else
|
|
|
|
W.printAlias(cast<GlobalAlias>(GV));
|
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
|
|
|
} else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
|
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
|
|
|
V->getMetadata()->print(ROS, getModuleFromVal(V));
|
2008-08-24 06:23:09 +08:00
|
|
|
} else if (const Constant *C = dyn_cast<Constant>(this)) {
|
2009-03-01 07:20:19 +08:00
|
|
|
TypePrinting TypePrinter;
|
2009-03-01 05:26:53 +08:00
|
|
|
TypePrinter.print(C->getType(), OS);
|
2009-03-01 05:11:05 +08:00
|
|
|
OS << ' ';
|
2014-04-06 07:33:25 +08:00
|
|
|
WriteConstantInternal(OS, C, TypePrinter, nullptr, nullptr);
|
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
|
|
|
} else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
|
2014-01-09 10:29:41 +08:00
|
|
|
this->printAsOperand(OS);
|
2008-08-24 06:23:09 +08:00
|
|
|
} else {
|
2014-05-09 08:49:03 +08:00
|
|
|
llvm_unreachable("Unknown value to print out!");
|
2008-08-24 06:23:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 10:29:41 +08:00
|
|
|
void Value::printAsOperand(raw_ostream &O, bool PrintType, const Module *M) const {
|
|
|
|
// Fast path: Don't construct and populate a TypePrinting object if we
|
|
|
|
// won't be needing any types printed.
|
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
|
|
|
bool IsMetadata = isa<MetadataAsValue>(this);
|
|
|
|
if (!PrintType && ((!isa<Constant>(this) && !IsMetadata) || hasName() ||
|
|
|
|
isa<GlobalValue>(this))) {
|
2014-04-09 14:08:46 +08:00
|
|
|
WriteAsOperandInternal(O, this, nullptr, nullptr, M);
|
2014-01-09 10:29:41 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!M)
|
|
|
|
M = getModuleFromVal(this);
|
|
|
|
|
|
|
|
TypePrinting TypePrinter;
|
|
|
|
if (M)
|
|
|
|
TypePrinter.incorporateTypes(*M);
|
|
|
|
if (PrintType) {
|
|
|
|
TypePrinter.print(getType(), O);
|
|
|
|
O << ' ';
|
|
|
|
}
|
|
|
|
|
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
|
|
|
SlotTracker Machine(M, /* ShouldInitializeAllMetadata */ IsMetadata);
|
|
|
|
WriteAsOperandInternal(O, this, &TypePrinter, &Machine, M);
|
2014-01-09 10:29:41 +08:00
|
|
|
}
|
|
|
|
|
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
|
|
|
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
|
|
|
|
const Module *M, bool OnlyAsOperand) {
|
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
|
|
|
formatted_raw_ostream OS(ROS);
|
|
|
|
|
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
|
|
|
auto *N = dyn_cast<MDNode>(&MD);
|
|
|
|
TypePrinting TypePrinter;
|
|
|
|
SlotTracker Machine(M, /* ShouldInitializeAllMetadata */ N);
|
|
|
|
if (M)
|
|
|
|
TypePrinter.incorporateTypes(*M);
|
|
|
|
|
|
|
|
WriteAsOperandInternal(OS, &MD, &TypePrinter, &Machine, M,
|
|
|
|
/* FromValue */ true);
|
|
|
|
if (OnlyAsOperand || !N)
|
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
|
|
|
return;
|
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 << " = ";
|
|
|
|
WriteMDNodeBodyInternal(OS, N, &TypePrinter, &Machine, M);
|
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
|
|
|
}
|
|
|
|
|
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
|
|
|
void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
|
|
|
|
printMetadataImpl(OS, *this, M, /* OnlyAsOperand */ true);
|
|
|
|
}
|
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
|
|
|
|
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
|
|
|
void Metadata::print(raw_ostream &OS, const Module *M) const {
|
|
|
|
printMetadataImpl(OS, *this, M, /* OnlyAsOperand */ false);
|
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
|
|
|
}
|
|
|
|
|
2008-08-26 01:03:15 +08:00
|
|
|
// Value::dump - allow easy printing of Values from the debugger.
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2010-01-05 09:29:26 +08:00
|
|
|
void Value::dump() const { print(dbgs()); dbgs() << '\n'; }
|
2004-05-26 02:14:38 +08:00
|
|
|
|
2008-10-02 04:16:19 +08:00
|
|
|
// Type::dump - allow easy printing of Types from the debugger.
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2014-08-12 11:24:59 +08:00
|
|
|
void Type::dump() const { print(dbgs()); dbgs() << '\n'; }
|
2009-03-01 05:05:51 +08:00
|
|
|
|
2008-08-26 01:03:15 +08:00
|
|
|
// Module::dump() - Allow printing of Modules from the debugger.
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2014-04-09 14:08:46 +08:00
|
|
|
void Module::dump() const { print(dbgs(), nullptr); }
|
2011-12-10 07:18:34 +08:00
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
// \brief Allow printing of Comdats from the debugger.
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2014-06-28 02:19:56 +08:00
|
|
|
void Comdat::dump() const { print(dbgs()); }
|
|
|
|
|
2011-12-10 07:18:34 +08:00
|
|
|
// NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2014-04-23 20:23:05 +08:00
|
|
|
void NamedMDNode::dump() const { print(dbgs()); }
|
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
|
|
|
|
2015-03-15 14:53:32 +08:00
|
|
|
LLVM_DUMP_METHOD
|
|
|
|
void Metadata::dump() const { dump(nullptr); }
|
|
|
|
|
2015-02-26 06:08:21 +08:00
|
|
|
LLVM_DUMP_METHOD
|
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
|
|
|
void Metadata::dump(const Module *M) const {
|
|
|
|
print(dbgs(), M);
|
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
|
|
|
dbgs() << '\n';
|
|
|
|
}
|