2007-04-22 06:23:29 +00:00
|
|
|
//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-04-22 06:23:29 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-04-29 07:54:31 +00:00
|
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
2007-04-22 06:23:29 +00:00
|
|
|
#include "BitcodeReader.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "llvm/AutoUpgrade.h"
|
2013-07-26 04:16:55 +00:00
|
|
|
#include "llvm/Bitcode/LLVMBitCodes.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/OperandTraits.h"
|
|
|
|
#include "llvm/IR/Operator.h"
|
2012-02-06 22:30:29 +00:00
|
|
|
#include "llvm/Support/DataStream.h"
|
2007-04-24 04:04:35 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2007-04-29 07:54:31 +00:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2013-07-26 04:16:55 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2007-04-22 06:23:29 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
enum {
|
|
|
|
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
|
|
|
|
};
|
|
|
|
|
2012-01-02 07:49:53 +00:00
|
|
|
void BitcodeReader::materializeForwardReferencedFunctions() {
|
|
|
|
while (!BlockAddrFwdRefs.empty()) {
|
|
|
|
Function *F = BlockAddrFwdRefs.begin()->first;
|
|
|
|
F->Materialize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
void BitcodeReader::FreeState() {
|
2010-01-27 20:34:15 +00:00
|
|
|
if (BufferOwned)
|
|
|
|
delete Buffer;
|
2007-05-18 04:02:46 +00:00
|
|
|
Buffer = 0;
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
std::vector<Type*>().swap(TypeList);
|
2007-05-18 04:02:46 +00:00
|
|
|
ValueList.clear();
|
2009-08-04 06:00:18 +00:00
|
|
|
MDValueList.clear();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-12-07 23:16:57 +00:00
|
|
|
std::vector<AttributeSet>().swap(MAttributes);
|
2007-05-18 04:02:46 +00:00
|
|
|
std::vector<BasicBlock*>().swap(FunctionBBs);
|
|
|
|
std::vector<Function*>().swap(FunctionsWithBodies);
|
|
|
|
DeferredFunctionInfo.clear();
|
2010-07-20 21:42:28 +00:00
|
|
|
MDKindMap.clear();
|
2012-09-21 14:34:31 +00:00
|
|
|
|
|
|
|
assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references");
|
2007-04-29 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2007-05-04 03:30:17 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helper functions to implement forward reference resolution, etc.
|
|
|
|
//===----------------------------------------------------------------------===//
|
2007-04-29 07:54:31 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
/// ConvertToString - Convert a string from a record into an std::string, return
|
|
|
|
/// true on failure.
|
2007-04-23 21:26:05 +00:00
|
|
|
template<typename StrTy>
|
2012-05-28 14:10:31 +00:00
|
|
|
static bool ConvertToString(ArrayRef<uint64_t> Record, unsigned Idx,
|
2007-04-23 21:26:05 +00:00
|
|
|
StrTy &Result) {
|
2007-05-04 19:11:41 +00:00
|
|
|
if (Idx > Record.size())
|
2007-04-22 06:23:29 +00:00
|
|
|
return true;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
for (unsigned i = Idx, e = Record.size(); i != e; ++i)
|
|
|
|
Result += (char)Record[i];
|
2007-04-22 06:23:29 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: // Map unknown/new linkages to external
|
2009-07-20 01:03:30 +00:00
|
|
|
case 0: return GlobalValue::ExternalLinkage;
|
|
|
|
case 1: return GlobalValue::WeakAnyLinkage;
|
|
|
|
case 2: return GlobalValue::AppendingLinkage;
|
|
|
|
case 3: return GlobalValue::InternalLinkage;
|
|
|
|
case 4: return GlobalValue::LinkOnceAnyLinkage;
|
|
|
|
case 5: return GlobalValue::DLLImportLinkage;
|
|
|
|
case 6: return GlobalValue::DLLExportLinkage;
|
|
|
|
case 7: return GlobalValue::ExternalWeakLinkage;
|
|
|
|
case 8: return GlobalValue::CommonLinkage;
|
|
|
|
case 9: return GlobalValue::PrivateLinkage;
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
case 10: return GlobalValue::WeakODRLinkage;
|
|
|
|
case 11: return GlobalValue::LinkOnceODRLinkage;
|
2009-04-13 05:44:34 +00:00
|
|
|
case 12: return GlobalValue::AvailableExternallyLinkage;
|
2009-07-20 01:03:30 +00:00
|
|
|
case 13: return GlobalValue::LinkerPrivateLinkage;
|
2010-07-01 21:55:59 +00:00
|
|
|
case 14: return GlobalValue::LinkerPrivateWeakLinkage;
|
2012-08-17 18:33:14 +00:00
|
|
|
case 15: return GlobalValue::LinkOnceODRAutoHideLinkage;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: // Map unknown visibilities to default.
|
|
|
|
case 0: return GlobalValue::DefaultVisibility;
|
|
|
|
case 1: return GlobalValue::HiddenVisibility;
|
2007-04-29 20:56:48 +00:00
|
|
|
case 2: return GlobalValue::ProtectedVisibility;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-23 11:37:03 +00:00
|
|
|
static GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
case 0: return GlobalVariable::NotThreadLocal;
|
|
|
|
default: // Map unknown non-zero value to general dynamic.
|
|
|
|
case 1: return GlobalVariable::GeneralDynamicTLSModel;
|
|
|
|
case 2: return GlobalVariable::LocalDynamicTLSModel;
|
|
|
|
case 3: return GlobalVariable::InitialExecTLSModel;
|
|
|
|
case 4: return GlobalVariable::LocalExecTLSModel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-24 07:07:11 +00:00
|
|
|
static int GetDecodedCastOpcode(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: return -1;
|
|
|
|
case bitc::CAST_TRUNC : return Instruction::Trunc;
|
|
|
|
case bitc::CAST_ZEXT : return Instruction::ZExt;
|
|
|
|
case bitc::CAST_SEXT : return Instruction::SExt;
|
|
|
|
case bitc::CAST_FPTOUI : return Instruction::FPToUI;
|
|
|
|
case bitc::CAST_FPTOSI : return Instruction::FPToSI;
|
|
|
|
case bitc::CAST_UITOFP : return Instruction::UIToFP;
|
|
|
|
case bitc::CAST_SITOFP : return Instruction::SIToFP;
|
|
|
|
case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
|
|
|
|
case bitc::CAST_FPEXT : return Instruction::FPExt;
|
|
|
|
case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
|
|
|
|
case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
|
|
|
|
case bitc::CAST_BITCAST : return Instruction::BitCast;
|
|
|
|
}
|
|
|
|
}
|
2011-07-18 04:54:35 +00:00
|
|
|
static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) {
|
2007-04-24 07:07:11 +00:00
|
|
|
switch (Val) {
|
|
|
|
default: return -1;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_ADD:
|
2010-02-15 16:12:20 +00:00
|
|
|
return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_SUB:
|
2010-02-15 16:12:20 +00:00
|
|
|
return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_MUL:
|
2010-02-15 16:12:20 +00:00
|
|
|
return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul;
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::BINOP_UDIV: return Instruction::UDiv;
|
|
|
|
case bitc::BINOP_SDIV:
|
2010-02-15 16:12:20 +00:00
|
|
|
return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv;
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::BINOP_UREM: return Instruction::URem;
|
|
|
|
case bitc::BINOP_SREM:
|
2010-02-15 16:12:20 +00:00
|
|
|
return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem;
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::BINOP_SHL: return Instruction::Shl;
|
|
|
|
case bitc::BINOP_LSHR: return Instruction::LShr;
|
|
|
|
case bitc::BINOP_ASHR: return Instruction::AShr;
|
|
|
|
case bitc::BINOP_AND: return Instruction::And;
|
|
|
|
case bitc::BINOP_OR: return Instruction::Or;
|
|
|
|
case bitc::BINOP_XOR: return Instruction::Xor;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
static AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: return AtomicRMWInst::BAD_BINOP;
|
|
|
|
case bitc::RMW_XCHG: return AtomicRMWInst::Xchg;
|
|
|
|
case bitc::RMW_ADD: return AtomicRMWInst::Add;
|
|
|
|
case bitc::RMW_SUB: return AtomicRMWInst::Sub;
|
|
|
|
case bitc::RMW_AND: return AtomicRMWInst::And;
|
|
|
|
case bitc::RMW_NAND: return AtomicRMWInst::Nand;
|
|
|
|
case bitc::RMW_OR: return AtomicRMWInst::Or;
|
|
|
|
case bitc::RMW_XOR: return AtomicRMWInst::Xor;
|
|
|
|
case bitc::RMW_MAX: return AtomicRMWInst::Max;
|
|
|
|
case bitc::RMW_MIN: return AtomicRMWInst::Min;
|
|
|
|
case bitc::RMW_UMAX: return AtomicRMWInst::UMax;
|
|
|
|
case bitc::RMW_UMIN: return AtomicRMWInst::UMin;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-25 23:16:38 +00:00
|
|
|
static AtomicOrdering GetDecodedOrdering(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
case bitc::ORDERING_NOTATOMIC: return NotAtomic;
|
|
|
|
case bitc::ORDERING_UNORDERED: return Unordered;
|
|
|
|
case bitc::ORDERING_MONOTONIC: return Monotonic;
|
|
|
|
case bitc::ORDERING_ACQUIRE: return Acquire;
|
|
|
|
case bitc::ORDERING_RELEASE: return Release;
|
|
|
|
case bitc::ORDERING_ACQREL: return AcquireRelease;
|
|
|
|
default: // Map unknown orderings to sequentially-consistent.
|
|
|
|
case bitc::ORDERING_SEQCST: return SequentiallyConsistent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static SynchronizationScope GetDecodedSynchScope(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread;
|
|
|
|
default: // Map unknown scopes to cross-thread.
|
|
|
|
case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-10 08:32:32 +00:00
|
|
|
namespace llvm {
|
2007-04-24 05:48:56 +00:00
|
|
|
namespace {
|
|
|
|
/// @brief A class for maintaining the slot number definition
|
|
|
|
/// as a placeholder for the actual definition for forward constants defs.
|
|
|
|
class ConstantPlaceHolder : public ConstantExpr {
|
2012-09-15 17:09:36 +00:00
|
|
|
void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION;
|
2008-04-06 20:25:17 +00:00
|
|
|
public:
|
|
|
|
// allocate space for exactly one operand
|
|
|
|
void *operator new(size_t s) {
|
|
|
|
return User::operator new(s, 1);
|
|
|
|
}
|
2011-07-18 04:54:35 +00:00
|
|
|
explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context)
|
2008-05-10 08:32:32 +00:00
|
|
|
: ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
|
2009-08-13 21:58:54 +00:00
|
|
|
Op<0>() = UndefValue::get(Type::getInt32Ty(Context));
|
2007-04-24 05:48:56 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
/// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
|
|
|
|
static bool classof(const Value *V) {
|
2009-09-20 02:20:51 +00:00
|
|
|
return isa<ConstantExpr>(V) &&
|
2008-08-21 02:34:16 +00:00
|
|
|
cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
|
|
|
|
2008-05-10 08:32:32 +00:00
|
|
|
/// Provide fast operand accessors
|
2009-03-31 22:55:09 +00:00
|
|
|
//DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
|
2007-04-24 05:48:56 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
// FIXME: can we inherit this from ConstantExpr?
|
2008-05-10 08:32:32 +00:00
|
|
|
template <>
|
2011-01-11 15:07:38 +00:00
|
|
|
struct OperandTraits<ConstantPlaceHolder> :
|
|
|
|
public FixedNumOperandTraits<ConstantPlaceHolder, 1> {
|
2008-05-10 08:32:32 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
|
|
|
|
void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) {
|
|
|
|
if (Idx == size()) {
|
|
|
|
push_back(V);
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
if (Idx >= size())
|
|
|
|
resize(Idx+1);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
WeakVH &OldV = ValuePtrs[Idx];
|
|
|
|
if (OldV == 0) {
|
|
|
|
OldV = V;
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
// Handle constants and non-constants (e.g. instrs) differently for
|
|
|
|
// efficiency.
|
|
|
|
if (Constant *PHC = dyn_cast<Constant>(&*OldV)) {
|
|
|
|
ResolveConstants.push_back(std::make_pair(PHC, Idx));
|
|
|
|
OldV = V;
|
|
|
|
} else {
|
|
|
|
// If there was a forward reference to this value, replace it.
|
|
|
|
Value *PrevVal = OldV;
|
|
|
|
OldV->replaceAllUsesWith(V);
|
|
|
|
delete PrevVal;
|
2008-05-10 08:32:32 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-05-10 08:32:32 +00:00
|
|
|
|
2007-04-24 05:48:56 +00:00
|
|
|
Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty) {
|
2009-03-31 22:55:09 +00:00
|
|
|
if (Idx >= size())
|
2008-05-10 08:32:32 +00:00
|
|
|
resize(Idx + 1);
|
2007-04-24 05:48:56 +00:00
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
if (Value *V = ValuePtrs[Idx]) {
|
2007-05-01 07:01:57 +00:00
|
|
|
assert(Ty == V->getType() && "Type mismatch in constant table!");
|
|
|
|
return cast<Constant>(V);
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
2007-04-24 05:48:56 +00:00
|
|
|
|
|
|
|
// Create and return a placeholder, which will later be RAUW'd.
|
2009-07-07 20:18:58 +00:00
|
|
|
Constant *C = new ConstantPlaceHolder(Ty, Context);
|
2009-03-31 22:55:09 +00:00
|
|
|
ValuePtrs[Idx] = C;
|
2007-04-24 05:48:56 +00:00
|
|
|
return C;
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) {
|
2009-03-31 22:55:09 +00:00
|
|
|
if (Idx >= size())
|
2008-05-10 08:32:32 +00:00
|
|
|
resize(Idx + 1);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-03-31 22:55:09 +00:00
|
|
|
if (Value *V = ValuePtrs[Idx]) {
|
2007-05-01 07:01:57 +00:00
|
|
|
assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
|
|
|
|
return V;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-02 05:16:49 +00:00
|
|
|
// No type specified, must be invalid reference.
|
|
|
|
if (Ty == 0) return 0;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
// Create and return a placeholder, which will later be RAUW'd.
|
|
|
|
Value *V = new Argument(Ty);
|
2009-03-31 22:55:09 +00:00
|
|
|
ValuePtrs[Idx] = V;
|
2007-05-01 07:01:57 +00:00
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
/// ResolveConstantForwardRefs - Once all constants are read, this method bulk
|
|
|
|
/// resolves any forward references. The idea behind this is that we sometimes
|
|
|
|
/// get constants (such as large arrays) which reference *many* forward ref
|
|
|
|
/// constants. Replacing each of these causes a lot of thrashing when
|
|
|
|
/// building/reuniquing the constant. Instead of doing this, we look at all the
|
|
|
|
/// uses and rewrite all the place holders at once for any constant that uses
|
|
|
|
/// a placeholder.
|
|
|
|
void BitcodeReaderValueList::ResolveConstantForwardRefs() {
|
2009-09-20 02:20:51 +00:00
|
|
|
// Sort the values by-pointer so that they are efficient to look up with a
|
2008-08-21 02:34:16 +00:00
|
|
|
// binary search.
|
|
|
|
std::sort(ResolveConstants.begin(), ResolveConstants.end());
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
SmallVector<Constant*, 64> NewOps;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
while (!ResolveConstants.empty()) {
|
2009-03-31 22:55:09 +00:00
|
|
|
Value *RealVal = operator[](ResolveConstants.back().second);
|
2008-08-21 02:34:16 +00:00
|
|
|
Constant *Placeholder = ResolveConstants.back().first;
|
|
|
|
ResolveConstants.pop_back();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
// Loop over all users of the placeholder, updating them to reference the
|
|
|
|
// new value. If they reference more than one placeholder, update them all
|
|
|
|
// at once.
|
|
|
|
while (!Placeholder->use_empty()) {
|
2008-08-21 17:31:45 +00:00
|
|
|
Value::use_iterator UI = Placeholder->use_begin();
|
2010-07-09 16:01:21 +00:00
|
|
|
User *U = *UI;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
// If the using object isn't uniqued, just update the operands. This
|
|
|
|
// handles instructions and initializers for global variables.
|
2010-07-09 16:01:21 +00:00
|
|
|
if (!isa<Constant>(U) || isa<GlobalValue>(U)) {
|
2008-08-21 17:31:45 +00:00
|
|
|
UI.getUse().set(RealVal);
|
2008-08-21 02:34:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
// Otherwise, we have a constant that uses the placeholder. Replace that
|
|
|
|
// constant with a new constant that has *all* placeholder uses updated.
|
2010-07-09 16:01:21 +00:00
|
|
|
Constant *UserC = cast<Constant>(U);
|
2008-08-21 02:34:16 +00:00
|
|
|
for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
Value *NewOp;
|
|
|
|
if (!isa<ConstantPlaceHolder>(*I)) {
|
|
|
|
// Not a placeholder reference.
|
|
|
|
NewOp = *I;
|
|
|
|
} else if (*I == Placeholder) {
|
|
|
|
// Common case is that it just references this one placeholder.
|
|
|
|
NewOp = RealVal;
|
|
|
|
} else {
|
|
|
|
// Otherwise, look up the placeholder in ResolveConstants.
|
2009-09-20 02:20:51 +00:00
|
|
|
ResolveConstantsTy::iterator It =
|
|
|
|
std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(),
|
2008-08-21 02:34:16 +00:00
|
|
|
std::pair<Constant*, unsigned>(cast<Constant>(*I),
|
|
|
|
0));
|
|
|
|
assert(It != ResolveConstants.end() && It->first == *I);
|
2009-03-31 22:55:09 +00:00
|
|
|
NewOp = operator[](It->second);
|
2008-08-21 02:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NewOps.push_back(cast<Constant>(NewOp));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make the new constant.
|
|
|
|
Constant *NewC;
|
|
|
|
if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) {
|
2011-06-22 09:24:39 +00:00
|
|
|
NewC = ConstantArray::get(UserCA->getType(), NewOps);
|
2008-08-21 02:34:16 +00:00
|
|
|
} else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
|
2011-06-20 04:01:31 +00:00
|
|
|
NewC = ConstantStruct::get(UserCS->getType(), NewOps);
|
2008-08-21 02:34:16 +00:00
|
|
|
} else if (isa<ConstantVector>(UserC)) {
|
2011-02-15 00:14:00 +00:00
|
|
|
NewC = ConstantVector::get(NewOps);
|
2009-05-10 20:57:05 +00:00
|
|
|
} else {
|
|
|
|
assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
|
2011-04-13 13:46:01 +00:00
|
|
|
NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps);
|
2008-08-21 02:34:16 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-08-21 02:34:16 +00:00
|
|
|
UserC->replaceAllUsesWith(NewC);
|
|
|
|
UserC->destroyConstant();
|
|
|
|
NewOps.clear();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-05-10 20:57:05 +00:00
|
|
|
// Update all ValueHandles, they should be the only users at this point.
|
|
|
|
Placeholder->replaceAllUsesWith(RealVal);
|
2008-08-21 02:34:16 +00:00
|
|
|
delete Placeholder;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) {
|
|
|
|
if (Idx == size()) {
|
|
|
|
push_back(V);
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
if (Idx >= size())
|
|
|
|
resize(Idx+1);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
WeakVH &OldV = MDValuePtrs[Idx];
|
|
|
|
if (OldV == 0) {
|
|
|
|
OldV = V;
|
|
|
|
return;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
// If there was a forward reference to this value, replace it.
|
2010-08-20 22:02:26 +00:00
|
|
|
MDNode *PrevVal = cast<MDNode>(OldV);
|
2009-08-04 06:00:18 +00:00
|
|
|
OldV->replaceAllUsesWith(V);
|
2010-08-20 22:02:26 +00:00
|
|
|
MDNode::deleteTemporary(PrevVal);
|
2009-09-03 01:38:02 +00:00
|
|
|
// Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new
|
|
|
|
// value for Idx.
|
|
|
|
MDValuePtrs[Idx] = V;
|
2009-08-04 06:00:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) {
|
|
|
|
if (Idx >= size())
|
|
|
|
resize(Idx + 1);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
if (Value *V = MDValuePtrs[Idx]) {
|
2009-10-05 05:54:46 +00:00
|
|
|
assert(V->getType()->isMetadataTy() && "Type mismatch in value table!");
|
2009-08-04 06:00:18 +00:00
|
|
|
return V;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
// Create and return a placeholder, which will later be RAUW'd.
|
2013-05-05 00:40:33 +00:00
|
|
|
Value *V = MDNode::getTemporary(Context, None);
|
2009-08-04 06:00:18 +00:00
|
|
|
MDValuePtrs[Idx] = V;
|
|
|
|
return V;
|
|
|
|
}
|
2007-04-22 06:23:29 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type *BitcodeReader::getTypeByID(unsigned ID) {
|
|
|
|
// The type table size is always specified correctly.
|
|
|
|
if (ID >= TypeList.size())
|
|
|
|
return 0;
|
2012-02-06 19:03:04 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (Type *Ty = TypeList[ID])
|
|
|
|
return Ty;
|
|
|
|
|
|
|
|
// If we have a forward reference, the only possible case is when it is to a
|
|
|
|
// named struct. Just create a placeholder for now.
|
2011-08-12 18:06:37 +00:00
|
|
|
return TypeList[ID] = StructType::create(Context);
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-04 03:30:17 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Functions for parsing blocks from the bitcode file
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-02-04 23:32:23 +00:00
|
|
|
|
|
|
|
/// \brief This fills an AttrBuilder object with the LLVM attributes that have
|
|
|
|
/// been decoded from the given integer. This function must stay in sync with
|
|
|
|
/// 'encodeLLVMAttributesForBitcode'.
|
|
|
|
static void decodeLLVMAttributesForBitcode(AttrBuilder &B,
|
|
|
|
uint64_t EncodedAttrs) {
|
|
|
|
// FIXME: Remove in 4.0.
|
|
|
|
|
|
|
|
// The alignment is stored as a 16-bit raw value from bits 31--16. We shift
|
|
|
|
// the bits above 31 down by 11 bits.
|
|
|
|
unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
|
|
|
|
assert((!Alignment || isPowerOf2_32(Alignment)) &&
|
|
|
|
"Alignment must be a power of two.");
|
|
|
|
|
|
|
|
if (Alignment)
|
|
|
|
B.addAlignmentAttr(Alignment);
|
2013-02-11 08:13:54 +00:00
|
|
|
B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
|
2013-02-04 23:32:23 +00:00
|
|
|
(EncodedAttrs & 0xffff));
|
|
|
|
}
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
bool BitcodeReader::ParseAttributeBlock() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
|
2007-05-04 03:30:17 +00:00
|
|
|
return Error("Malformed block record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-26 22:53:05 +00:00
|
|
|
if (!MAttributes.empty())
|
2007-05-04 03:30:17 +00:00
|
|
|
return Error("Multiple PARAMATTR blocks found!");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 03:30:17 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-01-27 00:36:48 +00:00
|
|
|
SmallVector<AttributeSet, 8> Attrs;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 03:30:17 +00:00
|
|
|
// Read all the records.
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("Error at end of PARAMATTR block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
2007-05-04 03:30:17 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2007-05-04 03:30:17 +00:00
|
|
|
}
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2007-05-04 03:30:17 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2007-05-04 03:30:17 +00:00
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
2013-02-04 23:32:23 +00:00
|
|
|
case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...]
|
|
|
|
// FIXME: Remove in 4.0.
|
2007-05-04 03:30:17 +00:00
|
|
|
if (Record.size() & 1)
|
|
|
|
return Error("Invalid ENTRY record");
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
|
2013-01-29 01:43:29 +00:00
|
|
|
AttrBuilder B;
|
2013-02-04 23:32:23 +00:00
|
|
|
decodeLLVMAttributesForBitcode(B, Record[i+1]);
|
2013-01-29 01:43:29 +00:00
|
|
|
Attrs.push_back(AttributeSet::get(Context, Record[i], B));
|
2007-05-04 03:30:17 +00:00
|
|
|
}
|
2008-03-12 02:25:52 +00:00
|
|
|
|
2012-12-07 23:16:57 +00:00
|
|
|
MAttributes.push_back(AttributeSet::get(Context, Attrs));
|
2007-05-04 03:30:17 +00:00
|
|
|
Attrs.clear();
|
|
|
|
break;
|
|
|
|
}
|
2013-02-12 08:13:50 +00:00
|
|
|
case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...]
|
|
|
|
for (unsigned i = 0, e = Record.size(); i != e; ++i)
|
|
|
|
Attrs.push_back(MAttributeGroups[Record[i]]);
|
|
|
|
|
|
|
|
MAttributes.push_back(AttributeSet::get(Context, Attrs));
|
|
|
|
Attrs.clear();
|
|
|
|
break;
|
|
|
|
}
|
2007-11-20 14:09:29 +00:00
|
|
|
}
|
2007-05-04 03:30:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-26 04:16:55 +00:00
|
|
|
bool BitcodeReader::ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) {
|
|
|
|
switch (Code) {
|
|
|
|
case bitc::ATTR_KIND_ALIGNMENT:
|
|
|
|
*Kind = Attribute::Alignment;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_ALWAYS_INLINE:
|
|
|
|
*Kind = Attribute::AlwaysInline;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_BUILTIN:
|
|
|
|
*Kind = Attribute::Builtin;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_BY_VAL:
|
|
|
|
*Kind = Attribute::ByVal;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_COLD:
|
|
|
|
*Kind = Attribute::Cold;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_INLINE_HINT:
|
|
|
|
*Kind = Attribute::InlineHint;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_IN_REG:
|
|
|
|
*Kind = Attribute::InReg;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_MIN_SIZE:
|
|
|
|
*Kind = Attribute::MinSize;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NAKED:
|
|
|
|
*Kind = Attribute::Naked;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NEST:
|
|
|
|
*Kind = Attribute::Nest;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_ALIAS:
|
|
|
|
*Kind = Attribute::NoAlias;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_BUILTIN:
|
|
|
|
*Kind = Attribute::NoBuiltin;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_CAPTURE:
|
|
|
|
*Kind = Attribute::NoCapture;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_DUPLICATE:
|
|
|
|
*Kind = Attribute::NoDuplicate;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
|
|
|
|
*Kind = Attribute::NoImplicitFloat;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_INLINE:
|
|
|
|
*Kind = Attribute::NoInline;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NON_LAZY_BIND:
|
|
|
|
*Kind = Attribute::NonLazyBind;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_RED_ZONE:
|
|
|
|
*Kind = Attribute::NoRedZone;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_RETURN:
|
|
|
|
*Kind = Attribute::NoReturn;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_NO_UNWIND:
|
|
|
|
*Kind = Attribute::NoUnwind;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
|
|
|
|
*Kind = Attribute::OptimizeForSize;
|
|
|
|
return false;
|
2013-08-23 11:53:55 +00:00
|
|
|
case bitc::ATTR_KIND_OPTIMIZE_NONE:
|
|
|
|
*Kind = Attribute::OptimizeNone;
|
|
|
|
return false;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_READ_NONE:
|
|
|
|
*Kind = Attribute::ReadNone;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_READ_ONLY:
|
|
|
|
*Kind = Attribute::ReadOnly;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_RETURNED:
|
|
|
|
*Kind = Attribute::Returned;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_RETURNS_TWICE:
|
|
|
|
*Kind = Attribute::ReturnsTwice;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_S_EXT:
|
|
|
|
*Kind = Attribute::SExt;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_STACK_ALIGNMENT:
|
|
|
|
*Kind = Attribute::StackAlignment;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT:
|
|
|
|
*Kind = Attribute::StackProtect;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT_REQ:
|
|
|
|
*Kind = Attribute::StackProtectReq;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT_STRONG:
|
|
|
|
*Kind = Attribute::StackProtectStrong;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_STRUCT_RET:
|
|
|
|
*Kind = Attribute::StructRet;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_SANITIZE_ADDRESS:
|
|
|
|
*Kind = Attribute::SanitizeAddress;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_SANITIZE_THREAD:
|
|
|
|
*Kind = Attribute::SanitizeThread;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_SANITIZE_MEMORY:
|
|
|
|
*Kind = Attribute::SanitizeMemory;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_UW_TABLE:
|
|
|
|
*Kind = Attribute::UWTable;
|
|
|
|
return false;
|
|
|
|
case bitc::ATTR_KIND_Z_EXT:
|
|
|
|
*Kind = Attribute::ZExt;
|
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
std::string Buf;
|
|
|
|
raw_string_ostream fmt(Buf);
|
|
|
|
fmt << "Unknown attribute kind (" << Code << ")";
|
|
|
|
fmt.flush();
|
|
|
|
return Error(Buf.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-10 23:24:25 +00:00
|
|
|
bool BitcodeReader::ParseAttributeGroupBlock() {
|
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
|
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
if (!MAttributeGroups.empty())
|
|
|
|
return Error("Multiple PARAMATTR_GROUP blocks found!");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
|
|
|
|
// Read all the records.
|
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
|
|
|
|
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("Error at end of PARAMATTR_GROUP block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
return false;
|
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
|
|
|
case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
|
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error("Invalid ENTRY record");
|
|
|
|
|
2013-02-11 22:32:29 +00:00
|
|
|
uint64_t GrpID = Record[0];
|
2013-02-10 23:24:25 +00:00
|
|
|
uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
|
|
|
|
|
|
|
|
AttrBuilder B;
|
|
|
|
for (unsigned i = 2, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Record[i] == 0) { // Enum attribute
|
2013-07-26 04:16:55 +00:00
|
|
|
Attribute::AttrKind Kind;
|
|
|
|
if (ParseAttrKind(Record[++i], &Kind))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
B.addAttribute(Kind);
|
2013-02-10 23:24:25 +00:00
|
|
|
} else if (Record[i] == 1) { // Align attribute
|
2013-07-26 04:16:55 +00:00
|
|
|
Attribute::AttrKind Kind;
|
|
|
|
if (ParseAttrKind(Record[++i], &Kind))
|
|
|
|
return true;
|
|
|
|
if (Kind == Attribute::Alignment)
|
2013-02-10 23:24:25 +00:00
|
|
|
B.addAlignmentAttr(Record[++i]);
|
|
|
|
else
|
|
|
|
B.addStackAlignmentAttr(Record[++i]);
|
|
|
|
} else { // String attribute
|
2013-02-11 22:32:29 +00:00
|
|
|
assert((Record[i] == 3 || Record[i] == 4) &&
|
|
|
|
"Invalid attribute group entry");
|
2013-02-10 23:24:25 +00:00
|
|
|
bool HasValue = (Record[i++] == 4);
|
|
|
|
SmallString<64> KindStr;
|
|
|
|
SmallString<64> ValStr;
|
|
|
|
|
|
|
|
while (Record[i] != 0 && i != e)
|
|
|
|
KindStr += Record[i++];
|
2013-02-11 22:32:29 +00:00
|
|
|
assert(Record[i] == 0 && "Kind string not null terminated");
|
2013-02-10 23:24:25 +00:00
|
|
|
|
|
|
|
if (HasValue) {
|
|
|
|
// Has a value associated with it.
|
2013-02-11 22:32:29 +00:00
|
|
|
++i; // Skip the '0' that terminates the "kind" string.
|
2013-02-10 23:24:25 +00:00
|
|
|
while (Record[i] != 0 && i != e)
|
|
|
|
ValStr += Record[i++];
|
2013-02-11 22:32:29 +00:00
|
|
|
assert(Record[i] == 0 && "Value string not null terminated");
|
2013-02-10 23:24:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
B.addAttribute(KindStr.str(), ValStr.str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-11 22:32:29 +00:00
|
|
|
MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B);
|
2013-02-10 23:24:25 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-01 05:01:34 +00:00
|
|
|
bool BitcodeReader::ParseTypeTable() {
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Malformed block record");
|
2012-02-06 19:03:04 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
return ParseTypeTableBody();
|
|
|
|
}
|
2009-09-20 02:20:51 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
bool BitcodeReader::ParseTypeTableBody() {
|
2007-04-22 06:23:29 +00:00
|
|
|
if (!TypeList.empty())
|
|
|
|
return Error("Multiple TYPE_BLOCKs found!");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
unsigned NumRecords = 0;
|
|
|
|
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
SmallString<64> TypeName;
|
2012-02-06 19:03:04 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// Read all the records for this type table.
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
Error("Error in the type table block");
|
|
|
|
return true;
|
|
|
|
case BitstreamEntry::EndBlock:
|
2007-04-22 06:23:29 +00:00
|
|
|
if (NumRecords != TypeList.size())
|
|
|
|
return Error("Invalid type forward reference in TYPE_BLOCK");
|
2007-04-24 18:15:21 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type *ResultTy = 0;
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
default: return Error("unknown type in type table");
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
|
|
|
|
// TYPE_CODE_NUMENTRY contains a count of the number of types in the
|
|
|
|
// type list. This allows us to reserve space.
|
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Invalid TYPE_CODE_NUMENTRY record");
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
TypeList.resize(Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
continue;
|
|
|
|
case bitc::TYPE_CODE_VOID: // VOID
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getVoidTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2011-12-17 00:04:22 +00:00
|
|
|
case bitc::TYPE_CODE_HALF: // HALF
|
|
|
|
ResultTy = Type::getHalfTy(Context);
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_FLOAT: // FLOAT
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getFloatTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_DOUBLE: // DOUBLE
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getDoubleTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2007-08-03 01:03:46 +00:00
|
|
|
case bitc::TYPE_CODE_X86_FP80: // X86_FP80
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getX86_FP80Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_FP128: // FP128
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getFP128Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getPPC_FP128Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_LABEL: // LABEL
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getLabelTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2009-05-30 05:06:04 +00:00
|
|
|
case bitc::TYPE_CODE_METADATA: // METADATA
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getMetadataTy(Context);
|
2009-05-30 05:06:04 +00:00
|
|
|
break;
|
2010-09-10 20:55:01 +00:00
|
|
|
case bitc::TYPE_CODE_X86_MMX: // X86_MMX
|
|
|
|
ResultTy = Type::getX86_MMXTy(Context);
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
|
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Invalid Integer type record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = IntegerType::get(Context, Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2009-09-20 02:20:51 +00:00
|
|
|
case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
|
2007-12-11 08:59:05 +00:00
|
|
|
// [pointee type, address space]
|
2007-04-22 06:23:29 +00:00
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Invalid POINTER type record");
|
2007-12-11 08:59:05 +00:00
|
|
|
unsigned AddressSpace = 0;
|
|
|
|
if (Record.size() == 2)
|
|
|
|
AddressSpace = Record[1];
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
ResultTy = getTypeByID(Record[0]);
|
|
|
|
if (ResultTy == 0) return Error("invalid element type in pointer type");
|
|
|
|
ResultTy = PointerType::get(ResultTy, AddressSpace);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2007-12-11 08:59:05 +00:00
|
|
|
}
|
2012-05-23 15:19:39 +00:00
|
|
|
case bitc::TYPE_CODE_FUNCTION_OLD: {
|
|
|
|
// FIXME: attrid is dead, remove it in LLVM 4.0
|
|
|
|
// FUNCTION: [vararg, attrid, retty, paramty x N]
|
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error("Invalid FUNCTION type record");
|
|
|
|
SmallVector<Type*, 8> ArgTys;
|
|
|
|
for (unsigned i = 3, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Type *T = getTypeByID(Record[i]))
|
|
|
|
ArgTys.push_back(T);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-23 15:19:39 +00:00
|
|
|
ResultTy = getTypeByID(Record[2]);
|
|
|
|
if (ResultTy == 0 || ArgTys.size() < Record.size()-3)
|
|
|
|
return Error("invalid type in function type");
|
|
|
|
|
|
|
|
ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
|
|
|
|
break;
|
|
|
|
}
|
2011-11-03 00:14:01 +00:00
|
|
|
case bitc::TYPE_CODE_FUNCTION: {
|
|
|
|
// FUNCTION: [vararg, retty, paramty x N]
|
|
|
|
if (Record.size() < 2)
|
|
|
|
return Error("Invalid FUNCTION type record");
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Type*, 8> ArgTys;
|
2011-11-03 00:14:01 +00:00
|
|
|
for (unsigned i = 2, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Type *T = getTypeByID(Record[i]))
|
|
|
|
ArgTys.push_back(T);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-11-03 00:14:01 +00:00
|
|
|
ResultTy = getTypeByID(Record[1]);
|
|
|
|
if (ResultTy == 0 || ArgTys.size() < Record.size()-2)
|
|
|
|
return Error("invalid type in function type");
|
|
|
|
|
|
|
|
ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
|
|
|
|
break;
|
|
|
|
}
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N]
|
2007-05-06 08:21:50 +00:00
|
|
|
if (Record.size() < 1)
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Invalid STRUCT type record");
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Type*, 8> EltTys;
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
for (unsigned i = 1, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Type *T = getTypeByID(Record[i]))
|
|
|
|
EltTys.push_back(T);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (EltTys.size() != Record.size()-1)
|
|
|
|
return Error("invalid type in struct type");
|
2009-08-05 23:16:16 +00:00
|
|
|
ResultTy = StructType::get(Context, EltTys, Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
}
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
|
|
|
|
if (ConvertToString(Record, 0, TypeName))
|
|
|
|
return Error("Invalid STRUCT_NAME record");
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
|
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Invalid STRUCT type record");
|
2012-11-15 22:34:00 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (NumRecords >= TypeList.size())
|
|
|
|
return Error("invalid TYPE table");
|
2012-11-15 22:34:00 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Check to see if this was forward referenced, if so fill in the temp.
|
|
|
|
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
|
|
|
|
if (Res) {
|
|
|
|
Res->setName(TypeName);
|
|
|
|
TypeList[NumRecords] = 0;
|
|
|
|
} else // Otherwise, create a new struct.
|
2011-08-12 18:06:37 +00:00
|
|
|
Res = StructType::create(Context, TypeName);
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
TypeName.clear();
|
2012-11-15 22:34:00 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
SmallVector<Type*, 8> EltTys;
|
|
|
|
for (unsigned i = 1, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Type *T = getTypeByID(Record[i]))
|
|
|
|
EltTys.push_back(T);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (EltTys.size() != Record.size()-1)
|
|
|
|
return Error("invalid STRUCT type record");
|
|
|
|
Res->setBody(EltTys, Record[0]);
|
|
|
|
ResultTy = Res;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
|
|
|
|
if (Record.size() != 1)
|
|
|
|
return Error("Invalid OPAQUE type record");
|
|
|
|
|
|
|
|
if (NumRecords >= TypeList.size())
|
|
|
|
return Error("invalid TYPE table");
|
2012-11-15 22:34:00 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Check to see if this was forward referenced, if so fill in the temp.
|
|
|
|
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
|
|
|
|
if (Res) {
|
|
|
|
Res->setName(TypeName);
|
|
|
|
TypeList[NumRecords] = 0;
|
|
|
|
} else // Otherwise, create a new struct with no body.
|
2011-08-12 18:06:37 +00:00
|
|
|
Res = StructType::create(Context, TypeName);
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
TypeName.clear();
|
|
|
|
ResultTy = Res;
|
|
|
|
break;
|
2012-11-15 22:34:00 +00:00
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
|
|
|
|
if (Record.size() < 2)
|
|
|
|
return Error("Invalid ARRAY type record");
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if ((ResultTy = getTypeByID(Record[1])))
|
|
|
|
ResultTy = ArrayType::get(ResultTy, Record[0]);
|
|
|
|
else
|
|
|
|
return Error("Invalid ARRAY type element");
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
|
|
|
|
if (Record.size() < 2)
|
|
|
|
return Error("Invalid VECTOR type record");
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if ((ResultTy = getTypeByID(Record[1])))
|
|
|
|
ResultTy = VectorType::get(ResultTy, Record[0]);
|
|
|
|
else
|
|
|
|
return Error("Invalid ARRAY type element");
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (NumRecords >= TypeList.size())
|
|
|
|
return Error("invalid TYPE table");
|
|
|
|
assert(ResultTy && "Didn't read a type?");
|
|
|
|
assert(TypeList[NumRecords] == 0 && "Already read type?");
|
|
|
|
TypeList[NumRecords++] = ResultTy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-01 05:01:34 +00:00
|
|
|
bool BitcodeReader::ParseValueSymbolTable() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
|
2007-04-23 21:26:05 +00:00
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-23 21:26:05 +00:00
|
|
|
// Read all the records for this value table.
|
|
|
|
SmallString<128> ValueName;
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("malformed value symbol table block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
2007-04-24 18:15:21 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2007-04-23 21:26:05 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-23 21:26:05 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2007-04-23 21:26:05 +00:00
|
|
|
default: // Default behavior: unknown type.
|
|
|
|
break;
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
|
2007-04-23 21:26:05 +00:00
|
|
|
if (ConvertToString(Record, 1, ValueName))
|
2009-05-31 06:07:28 +00:00
|
|
|
return Error("Invalid VST_ENTRY record");
|
2007-04-23 21:26:05 +00:00
|
|
|
unsigned ValueID = Record[0];
|
|
|
|
if (ValueID >= ValueList.size())
|
|
|
|
return Error("Invalid Value ID in VST_ENTRY record");
|
|
|
|
Value *V = ValueList[ValueID];
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-26 00:34:27 +00:00
|
|
|
V->setName(StringRef(ValueName.data(), ValueName.size()));
|
2007-04-23 21:26:05 +00:00
|
|
|
ValueName.clear();
|
|
|
|
break;
|
2007-05-04 01:43:33 +00:00
|
|
|
}
|
2011-04-10 23:18:04 +00:00
|
|
|
case bitc::VST_CODE_BBENTRY: {
|
2007-05-03 22:18:21 +00:00
|
|
|
if (ConvertToString(Record, 1, ValueName))
|
|
|
|
return Error("Invalid VST_BBENTRY record");
|
|
|
|
BasicBlock *BB = getBasicBlock(Record[0]);
|
|
|
|
if (BB == 0)
|
|
|
|
return Error("Invalid BB ID in VST_BBENTRY record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-26 00:34:27 +00:00
|
|
|
BB->setName(StringRef(ValueName.data(), ValueName.size()));
|
2007-05-03 22:18:21 +00:00
|
|
|
ValueName.clear();
|
|
|
|
break;
|
2007-04-23 21:26:05 +00:00
|
|
|
}
|
2007-05-04 01:43:33 +00:00
|
|
|
}
|
2007-04-23 21:26:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 17:43:22 +00:00
|
|
|
bool BitcodeReader::ParseMetadata() {
|
2010-01-11 18:52:33 +00:00
|
|
|
unsigned NextMDValueNo = MDValueList.size();
|
2009-07-22 17:43:22 +00:00
|
|
|
|
|
|
|
if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
|
|
|
|
return Error("Malformed block record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-22 17:43:22 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-22 17:43:22 +00:00
|
|
|
// Read all the records.
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
Error("malformed metadata block");
|
|
|
|
return true;
|
|
|
|
case BitstreamEntry::EndBlock:
|
2009-07-22 17:43:22 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2009-07-22 17:43:22 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-10 07:14:18 +00:00
|
|
|
bool IsFunctionLocal = false;
|
2009-07-22 17:43:22 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
2013-01-20 02:13:19 +00:00
|
|
|
unsigned Code = Stream.readRecord(Entry.ID, Record);
|
2010-09-13 18:00:48 +00:00
|
|
|
switch (Code) {
|
2009-07-22 17:43:22 +00:00
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
2009-07-29 22:34:41 +00:00
|
|
|
case bitc::METADATA_NAME: {
|
2013-01-20 02:54:05 +00:00
|
|
|
// Read name of the named metadata.
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<8> Name(Record.begin(), Record.end());
|
2009-07-29 22:34:41 +00:00
|
|
|
Record.clear();
|
|
|
|
Code = Stream.ReadCode();
|
|
|
|
|
2011-06-17 17:50:30 +00:00
|
|
|
// METADATA_NAME is always followed by METADATA_NAMED_NODE.
|
2013-01-20 02:13:19 +00:00
|
|
|
unsigned NextBitCode = Stream.readRecord(Code, Record);
|
2011-06-17 17:50:30 +00:00
|
|
|
assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode;
|
2009-07-29 22:34:41 +00:00
|
|
|
|
|
|
|
// Read named metadata elements.
|
|
|
|
unsigned Size = Record.size();
|
2010-07-21 23:38:33 +00:00
|
|
|
NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name);
|
2009-07-29 22:34:41 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i) {
|
2010-01-09 02:02:37 +00:00
|
|
|
MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i]));
|
|
|
|
if (MD == 0)
|
|
|
|
return Error("Malformed metadata record");
|
2010-07-21 23:38:33 +00:00
|
|
|
NMD->addOperand(MD);
|
2009-07-29 22:34:41 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-06-17 17:50:30 +00:00
|
|
|
case bitc::METADATA_FN_NODE:
|
2010-01-10 07:14:18 +00:00
|
|
|
IsFunctionLocal = true;
|
|
|
|
// fall-through
|
2011-06-17 17:50:30 +00:00
|
|
|
case bitc::METADATA_NODE: {
|
2010-07-13 19:33:27 +00:00
|
|
|
if (Record.size() % 2 == 1)
|
2011-06-17 17:50:30 +00:00
|
|
|
return Error("Invalid METADATA_NODE record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-23 01:07:34 +00:00
|
|
|
unsigned Size = Record.size();
|
|
|
|
SmallVector<Value*, 8> Elts;
|
|
|
|
for (unsigned i = 0; i != Size; i += 2) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[i]);
|
2011-06-17 17:50:30 +00:00
|
|
|
if (!Ty) return Error("Invalid METADATA_NODE record");
|
2009-10-05 05:54:46 +00:00
|
|
|
if (Ty->isMetadataTy())
|
2009-08-04 06:00:18 +00:00
|
|
|
Elts.push_back(MDValueList.getValueFwdRef(Record[i+1]));
|
2010-01-05 13:12:22 +00:00
|
|
|
else if (!Ty->isVoidTy())
|
2009-07-23 01:07:34 +00:00
|
|
|
Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty));
|
|
|
|
else
|
|
|
|
Elts.push_back(NULL);
|
|
|
|
}
|
2011-04-21 19:59:31 +00:00
|
|
|
Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal);
|
2010-01-10 07:14:18 +00:00
|
|
|
IsFunctionLocal = false;
|
2010-01-11 18:52:33 +00:00
|
|
|
MDValueList.AssignValue(V, NextMDValueNo++);
|
2009-07-23 01:07:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
case bitc::METADATA_STRING: {
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<8> String(Record.begin(), Record.end());
|
|
|
|
Value *V = MDString::get(Context, String);
|
2010-01-11 18:52:33 +00:00
|
|
|
MDValueList.AssignValue(V, NextMDValueNo++);
|
2009-07-22 17:43:22 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-18 19:26:43 +00:00
|
|
|
case bitc::METADATA_KIND: {
|
2012-05-28 14:10:31 +00:00
|
|
|
if (Record.size() < 2)
|
2009-09-20 02:20:51 +00:00
|
|
|
return Error("Invalid METADATA_KIND record");
|
2012-05-28 14:10:31 +00:00
|
|
|
|
2009-09-28 21:14:55 +00:00
|
|
|
unsigned Kind = Record[0];
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<8> Name(Record.begin()+1, Record.end());
|
|
|
|
|
2009-12-29 09:01:33 +00:00
|
|
|
unsigned NewKind = TheModule->getMDKindID(Name.str());
|
2010-07-20 21:42:28 +00:00
|
|
|
if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
|
|
|
|
return Error("Conflicting METADATA_KIND records");
|
2009-09-18 19:26:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in
|
2007-04-24 04:04:35 +00:00
|
|
|
/// the LSB for dense VBR encoding.
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
|
2007-04-24 04:04:35 +00:00
|
|
|
if ((V & 1) == 0)
|
|
|
|
return V >> 1;
|
2009-09-20 02:20:51 +00:00
|
|
|
if (V != 1)
|
2007-04-24 04:04:35 +00:00
|
|
|
return -(V >> 1);
|
|
|
|
// There is no such thing as -0 with integers. "-0" really means MININT.
|
|
|
|
return 1ULL << 63;
|
|
|
|
}
|
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
|
|
|
|
/// values and aliases that we can.
|
|
|
|
bool BitcodeReader::ResolveGlobalAndAliasInits() {
|
|
|
|
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
|
|
|
|
std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
|
2013-09-16 01:08:15 +00:00
|
|
|
std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
GlobalInitWorklist.swap(GlobalInits);
|
|
|
|
AliasInitWorklist.swap(AliasInits);
|
2013-09-16 01:08:15 +00:00
|
|
|
FunctionPrefixWorklist.swap(FunctionPrefixes);
|
2007-04-26 02:46:40 +00:00
|
|
|
|
|
|
|
while (!GlobalInitWorklist.empty()) {
|
2007-04-26 03:27:58 +00:00
|
|
|
unsigned ValID = GlobalInitWorklist.back().second;
|
2007-04-26 02:46:40 +00:00
|
|
|
if (ValID >= ValueList.size()) {
|
|
|
|
// Not ready to resolve this yet, it requires something later in the file.
|
2007-04-26 03:27:58 +00:00
|
|
|
GlobalInits.push_back(GlobalInitWorklist.back());
|
2007-04-26 02:46:40 +00:00
|
|
|
} else {
|
|
|
|
if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
|
|
|
|
GlobalInitWorklist.back().first->setInitializer(C);
|
|
|
|
else
|
|
|
|
return Error("Global variable initializer is not a constant!");
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
GlobalInitWorklist.pop_back();
|
2007-04-26 02:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
while (!AliasInitWorklist.empty()) {
|
|
|
|
unsigned ValID = AliasInitWorklist.back().second;
|
|
|
|
if (ValID >= ValueList.size()) {
|
|
|
|
AliasInits.push_back(AliasInitWorklist.back());
|
|
|
|
} else {
|
|
|
|
if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
|
2007-04-28 14:57:59 +00:00
|
|
|
AliasInitWorklist.back().first->setAliasee(C);
|
2007-04-26 02:46:40 +00:00
|
|
|
else
|
|
|
|
return Error("Alias initializer is not a constant!");
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
AliasInitWorklist.pop_back();
|
2007-04-26 02:46:40 +00:00
|
|
|
}
|
2013-09-16 01:08:15 +00:00
|
|
|
|
|
|
|
while (!FunctionPrefixWorklist.empty()) {
|
|
|
|
unsigned ValID = FunctionPrefixWorklist.back().second;
|
|
|
|
if (ValID >= ValueList.size()) {
|
|
|
|
FunctionPrefixes.push_back(FunctionPrefixWorklist.back());
|
|
|
|
} else {
|
|
|
|
if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
|
|
|
|
FunctionPrefixWorklist.back().first->setPrefixData(C);
|
|
|
|
else
|
|
|
|
return Error("Function prefix is not a constant!");
|
|
|
|
}
|
|
|
|
FunctionPrefixWorklist.pop_back();
|
|
|
|
}
|
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-28 14:10:31 +00:00
|
|
|
static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
|
|
|
|
SmallVector<uint64_t, 8> Words(Vals.size());
|
|
|
|
std::transform(Vals.begin(), Vals.end(), Words.begin(),
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
BitcodeReader::decodeSignRotatedValue);
|
2012-05-28 14:10:31 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
return APInt(TypeBits, Words);
|
|
|
|
}
|
|
|
|
|
2007-05-01 05:01:34 +00:00
|
|
|
bool BitcodeReader::ParseConstants() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
|
2007-04-24 03:30:34 +00:00
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 03:30:34 +00:00
|
|
|
// Read all the records for this value table.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *CurTy = Type::getInt32Ty(Context);
|
2007-04-24 05:48:56 +00:00
|
|
|
unsigned NextCstNo = ValueList.size();
|
2007-04-24 03:30:34 +00:00
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("malformed block record in AST file");
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
if (NextCstNo != ValueList.size())
|
|
|
|
return Error("Invalid constant reference!");
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
// Once all the constants have been read, go through and resolve forward
|
|
|
|
// references.
|
|
|
|
ValueList.ResolveConstantForwardRefs();
|
|
|
|
return false;
|
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
2008-08-21 02:34:16 +00:00
|
|
|
break;
|
2007-04-24 03:30:34 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 03:30:34 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
|
|
|
Value *V = 0;
|
2013-01-20 02:13:19 +00:00
|
|
|
unsigned BitCode = Stream.readRecord(Entry.ID, Record);
|
2009-07-20 21:19:07 +00:00
|
|
|
switch (BitCode) {
|
2007-04-24 03:30:34 +00:00
|
|
|
default: // Default behavior: unknown constant
|
|
|
|
case bitc::CST_CODE_UNDEF: // UNDEF
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy);
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
|
|
|
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
|
|
|
|
if (Record.empty())
|
|
|
|
return Error("Malformed CST_SETTYPE record");
|
|
|
|
if (Record[0] >= TypeList.size())
|
|
|
|
return Error("Invalid Type ID in CST_SETTYPE record");
|
|
|
|
CurTy = TypeList[Record[0]];
|
2007-04-24 04:04:35 +00:00
|
|
|
continue; // Skip the ValueList manipulation.
|
2007-04-24 03:30:34 +00:00
|
|
|
case bitc::CST_CODE_NULL: // NULL
|
2009-07-31 20:28:14 +00:00
|
|
|
V = Constant::getNullValue(CurTy);
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
|
|
|
case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!CurTy->isIntegerTy() || Record.empty())
|
2007-04-24 04:04:35 +00:00
|
|
|
return Error("Invalid CST_INTEGER record");
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
|
2007-04-24 04:04:35 +00:00
|
|
|
break;
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!CurTy->isIntegerTy() || Record.empty())
|
2007-04-24 04:04:35 +00:00
|
|
|
return Error("Invalid WIDE_INTEGER record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-05-28 14:10:31 +00:00
|
|
|
APInt VInt = ReadWideAPInt(Record,
|
|
|
|
cast<IntegerType>(CurTy)->getBitWidth());
|
2012-05-12 10:48:17 +00:00
|
|
|
V = ConstantInt::get(Context, VInt);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-04-24 04:04:35 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-09-11 18:32:33 +00:00
|
|
|
case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
|
2007-04-24 04:04:35 +00:00
|
|
|
if (Record.empty())
|
|
|
|
return Error("Invalid FLOAT record");
|
2011-12-17 00:04:22 +00:00
|
|
|
if (CurTy->isHalfTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf,
|
|
|
|
APInt(16, (uint16_t)Record[0])));
|
2011-12-17 00:04:22 +00:00
|
|
|
else if (CurTy->isFloatTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle,
|
|
|
|
APInt(32, (uint32_t)Record[0])));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isDoubleTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble,
|
|
|
|
APInt(64, Record[0])));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isX86_FP80Ty()) {
|
2009-03-23 21:16:53 +00:00
|
|
|
// Bits are not stored the same way as a normal i80 APInt, compensate.
|
|
|
|
uint64_t Rearrange[2];
|
|
|
|
Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
|
|
|
|
Rearrange[1] = Record[0] >> 48;
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended,
|
|
|
|
APInt(80, Rearrange)));
|
2009-10-05 05:54:46 +00:00
|
|
|
} else if (CurTy->isFP128Ty())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad,
|
|
|
|
APInt(128, Record)));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isPPC_FP128Ty())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble,
|
|
|
|
APInt(128, Record)));
|
2007-04-24 03:30:34 +00:00
|
|
|
else
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy);
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
2007-09-11 18:32:33 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
|
|
|
|
if (Record.empty())
|
2007-04-24 05:48:56 +00:00
|
|
|
return Error("Invalid CST_AGGREGATE record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
unsigned Size = Record.size();
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *STy = dyn_cast<StructType>(CurTy)) {
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i],
|
2007-04-24 05:48:56 +00:00
|
|
|
STy->getElementType(i)));
|
2009-07-27 22:29:26 +00:00
|
|
|
V = ConstantStruct::get(STy, Elts);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
|
|
|
|
Type *EltTy = ATy->getElementType();
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
2009-07-28 18:32:17 +00:00
|
|
|
V = ConstantArray::get(ATy, Elts);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
|
|
|
|
Type *EltTy = VTy->getElementType();
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
2009-07-28 21:19:26 +00:00
|
|
|
V = ConstantVector::get(Elts);
|
2007-04-24 05:48:56 +00:00
|
|
|
} else {
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy);
|
2007-04-24 05:48:56 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-02-05 02:41:35 +00:00
|
|
|
case bitc::CST_CODE_STRING: // STRING: [values]
|
2007-05-06 00:53:07 +00:00
|
|
|
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
|
|
|
|
if (Record.empty())
|
2012-02-05 02:41:35 +00:00
|
|
|
return Error("Invalid CST_STRING record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<16> Elts(Record.begin(), Record.end());
|
2012-02-05 02:41:35 +00:00
|
|
|
V = ConstantDataArray::getString(Context, Elts,
|
|
|
|
BitCode == bitc::CST_CODE_CSTRING);
|
2007-05-06 00:35:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-01-30 00:51:16 +00:00
|
|
|
case bitc::CST_CODE_DATA: {// DATA: [n x value]
|
|
|
|
if (Record.empty())
|
|
|
|
return Error("Invalid CST_DATA record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-01-30 00:51:16 +00:00
|
|
|
Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
|
|
|
|
unsigned Size = Record.size();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-01-30 00:51:16 +00:00
|
|
|
if (EltTy->isIntegerTy(8)) {
|
|
|
|
SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(16)) {
|
|
|
|
SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(32)) {
|
|
|
|
SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(64)) {
|
|
|
|
SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isFloatTy()) {
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallVector<float, 16> Elts(Size);
|
|
|
|
std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat);
|
2012-01-30 00:51:16 +00:00
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isDoubleTy()) {
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallVector<double, 16> Elts(Size);
|
|
|
|
std::transform(Record.begin(), Record.end(), Elts.begin(),
|
|
|
|
BitsToDouble);
|
2012-01-30 00:51:16 +00:00
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else {
|
|
|
|
return Error("Unknown element type in CE_DATA");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
|
|
|
|
if (Record.size() < 3) return Error("Invalid CE_BINOP record");
|
|
|
|
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
|
2007-04-24 18:15:21 +00:00
|
|
|
if (Opc < 0) {
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy); // Unknown binop.
|
2007-04-24 18:15:21 +00:00
|
|
|
} else {
|
|
|
|
Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
|
|
|
|
Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
|
2009-09-07 23:54:19 +00:00
|
|
|
unsigned Flags = 0;
|
|
|
|
if (Record.size() >= 4) {
|
|
|
|
if (Opc == Instruction::Add ||
|
|
|
|
Opc == Instruction::Sub ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::Mul ||
|
|
|
|
Opc == Instruction::Shl) {
|
2009-09-07 23:54:19 +00:00
|
|
|
if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
|
|
|
|
Flags |= OverflowingBinaryOperator::NoSignedWrap;
|
|
|
|
if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
|
|
|
|
Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
|
2011-02-06 21:44:57 +00:00
|
|
|
} else if (Opc == Instruction::SDiv ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::UDiv ||
|
|
|
|
Opc == Instruction::LShr ||
|
|
|
|
Opc == Instruction::AShr) {
|
2011-02-06 21:44:57 +00:00
|
|
|
if (Record[3] & (1 << bitc::PEO_EXACT))
|
2009-09-07 23:54:19 +00:00
|
|
|
Flags |= SDivOperator::IsExact;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
V = ConstantExpr::get(Opc, LHS, RHS, Flags);
|
2007-04-24 18:15:21 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
2009-09-20 02:20:51 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
|
|
|
|
if (Record.size() < 3) return Error("Invalid CE_CAST record");
|
|
|
|
int Opc = GetDecodedCastOpcode(Record[0]);
|
2007-04-24 18:15:21 +00:00
|
|
|
if (Opc < 0) {
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy); // Unknown cast.
|
2007-04-24 18:15:21 +00:00
|
|
|
} else {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[1]);
|
2007-05-06 07:33:01 +00:00
|
|
|
if (!OpTy) return Error("Invalid CE_CAST record");
|
2007-04-24 18:15:21 +00:00
|
|
|
Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getCast(Opc, Op, CurTy);
|
2007-04-24 18:15:21 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
2009-09-20 02:20:51 +00:00
|
|
|
}
|
2009-07-27 21:53:46 +00:00
|
|
|
case bitc::CST_CODE_CE_INBOUNDS_GEP:
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
|
2007-05-04 19:11:41 +00:00
|
|
|
if (Record.size() & 1) return Error("Invalid CE_GEP record");
|
2007-04-24 07:07:11 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
2007-05-04 19:11:41 +00:00
|
|
|
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy = getTypeByID(Record[i]);
|
2007-04-24 07:07:11 +00:00
|
|
|
if (!ElTy) return Error("Invalid CE_GEP record");
|
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
|
|
|
|
}
|
2011-07-21 14:31:17 +00:00
|
|
|
ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
|
2011-07-21 15:15:37 +00:00
|
|
|
V = ConstantExpr::getGetElementPtr(Elts[0], Indices,
|
|
|
|
BitCode ==
|
|
|
|
bitc::CST_CODE_CE_INBOUNDS_GEP);
|
2007-04-24 18:15:21 +00:00
|
|
|
break;
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
2013-09-12 22:02:31 +00:00
|
|
|
case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
|
2007-04-24 07:07:11 +00:00
|
|
|
if (Record.size() < 3) return Error("Invalid CE_SELECT record");
|
2013-09-12 22:02:31 +00:00
|
|
|
|
|
|
|
Type *SelectorTy = Type::getInt1Ty(Context);
|
|
|
|
|
|
|
|
// If CurTy is a vector of length n, then Record[0] must be a <n x i1>
|
|
|
|
// vector. Otherwise, it must be a single bit.
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
|
|
|
|
SelectorTy = VectorType::get(Type::getInt1Ty(Context),
|
|
|
|
VTy->getNumElements());
|
|
|
|
|
|
|
|
V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
|
|
|
|
SelectorTy),
|
|
|
|
ValueList.getConstantFwdRef(Record[1],CurTy),
|
|
|
|
ValueList.getConstantFwdRef(Record[2],CurTy));
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
2013-09-12 22:02:31 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
|
|
|
|
if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *OpTy =
|
2007-04-24 07:07:11 +00:00
|
|
|
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
|
|
|
|
if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
|
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
2012-11-25 15:23:39 +00:00
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
|
2012-11-19 19:22:55 +00:00
|
|
|
Type::getInt32Ty(Context));
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getExtractElement(Op0, Op1);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *OpTy = dyn_cast<VectorType>(CurTy);
|
2007-04-24 07:07:11 +00:00
|
|
|
if (Record.size() < 3 || OpTy == 0)
|
|
|
|
return Error("Invalid CE_INSERTELT record");
|
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
|
|
|
|
OpTy->getElementType());
|
2012-11-25 15:23:39 +00:00
|
|
|
Constant *Op2 = ValueList.getConstantFwdRef(Record[2],
|
2012-11-19 19:22:55 +00:00
|
|
|
Type::getInt32Ty(Context));
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *OpTy = dyn_cast<VectorType>(CurTy);
|
2007-04-24 07:07:11 +00:00
|
|
|
if (Record.size() < 3 || OpTy == 0)
|
2009-02-12 21:28:33 +00:00
|
|
|
return Error("Invalid CE_SHUFFLEVEC record");
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
|
2009-07-07 20:18:58 +00:00
|
|
|
OpTy->getNumElements());
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-02-12 21:28:33 +00:00
|
|
|
case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *RTy = dyn_cast<VectorType>(CurTy);
|
|
|
|
VectorType *OpTy =
|
2010-10-28 15:47:26 +00:00
|
|
|
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
|
2009-02-12 21:28:33 +00:00
|
|
|
if (Record.size() < 4 || RTy == 0 || OpTy == 0)
|
|
|
|
return Error("Invalid CE_SHUFVEC_EX record");
|
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
|
2009-07-07 20:18:58 +00:00
|
|
|
RTy->getNumElements());
|
2009-02-12 21:28:33 +00:00
|
|
|
Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
|
2009-02-12 21:28:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
|
|
|
|
if (Record.size() < 4) return Error("Invalid CE_CMP record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
2007-04-24 07:07:11 +00:00
|
|
|
if (OpTy == 0) return Error("Invalid CE_CMP record");
|
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
|
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
if (OpTy->isFPOrFPVectorTy())
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
|
2008-05-12 19:01:56 +00:00
|
|
|
else
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getICmp(Record[3], Op0, Op1);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
2007-04-24 05:48:56 +00:00
|
|
|
}
|
2012-09-05 19:00:49 +00:00
|
|
|
// This maintains backward compatibility, pre-asm dialect keywords.
|
2012-09-05 06:28:52 +00:00
|
|
|
// FIXME: Remove with the 4.0 release.
|
2012-09-05 00:56:20 +00:00
|
|
|
case bitc::CST_CODE_INLINEASM_OLD: {
|
2007-05-06 01:58:20 +00:00
|
|
|
if (Record.size() < 2) return Error("Invalid INLINEASM record");
|
|
|
|
std::string AsmStr, ConstrStr;
|
2009-10-13 20:46:56 +00:00
|
|
|
bool HasSideEffects = Record[0] & 1;
|
2009-10-21 23:28:00 +00:00
|
|
|
bool IsAlignStack = Record[0] >> 1;
|
2007-05-06 01:58:20 +00:00
|
|
|
unsigned AsmStrSize = Record[1];
|
|
|
|
if (2+AsmStrSize >= Record.size())
|
|
|
|
return Error("Invalid INLINEASM record");
|
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
|
|
|
return Error("Invalid INLINEASM record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:58:20 +00:00
|
|
|
for (unsigned i = 0; i != AsmStrSize; ++i)
|
|
|
|
AsmStr += (char)Record[2+i];
|
|
|
|
for (unsigned i = 0; i != ConstStrSize; ++i)
|
|
|
|
ConstrStr += (char)Record[3+AsmStrSize+i];
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = cast<PointerType>(CurTy);
|
2007-05-06 01:58:20 +00:00
|
|
|
V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
|
2009-10-21 23:28:00 +00:00
|
|
|
AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
|
2007-05-06 01:58:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-09-05 19:00:49 +00:00
|
|
|
// This version adds support for the asm dialect keywords (e.g.,
|
|
|
|
// inteldialect).
|
2012-09-05 00:56:20 +00:00
|
|
|
case bitc::CST_CODE_INLINEASM: {
|
|
|
|
if (Record.size() < 2) return Error("Invalid INLINEASM record");
|
|
|
|
std::string AsmStr, ConstrStr;
|
|
|
|
bool HasSideEffects = Record[0] & 1;
|
|
|
|
bool IsAlignStack = (Record[0] >> 1) & 1;
|
|
|
|
unsigned AsmDialect = Record[0] >> 2;
|
|
|
|
unsigned AsmStrSize = Record[1];
|
|
|
|
if (2+AsmStrSize >= Record.size())
|
|
|
|
return Error("Invalid INLINEASM record");
|
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
|
|
|
return Error("Invalid INLINEASM record");
|
|
|
|
|
|
|
|
for (unsigned i = 0; i != AsmStrSize; ++i)
|
|
|
|
AsmStr += (char)Record[2+i];
|
|
|
|
for (unsigned i = 0; i != ConstStrSize; ++i)
|
|
|
|
ConstrStr += (char)Record[3+AsmStrSize+i];
|
|
|
|
PointerType *PTy = cast<PointerType>(CurTy);
|
|
|
|
V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
|
|
|
|
AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
|
2012-09-05 19:00:49 +00:00
|
|
|
InlineAsm::AsmDialect(AsmDialect));
|
2012-09-05 00:56:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-10-28 05:53:48 +00:00
|
|
|
case bitc::CST_CODE_BLOCKADDRESS:{
|
|
|
|
if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FnTy = getTypeByID(Record[0]);
|
2009-10-28 05:53:48 +00:00
|
|
|
if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record");
|
|
|
|
Function *Fn =
|
|
|
|
dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
|
|
|
|
if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record");
|
2012-09-21 14:34:31 +00:00
|
|
|
|
|
|
|
// If the function is already parsed we can insert the block address right
|
|
|
|
// away.
|
|
|
|
if (!Fn->empty()) {
|
|
|
|
Function::iterator BBI = Fn->begin(), BBE = Fn->end();
|
|
|
|
for (size_t I = 0, E = Record[2]; I != E; ++I) {
|
|
|
|
if (BBI == BBE)
|
|
|
|
return Error("Invalid blockaddress block #");
|
|
|
|
++BBI;
|
|
|
|
}
|
|
|
|
V = BlockAddress::get(Fn, BBI);
|
|
|
|
} else {
|
|
|
|
// Otherwise insert a placeholder and remember it so it can be inserted
|
|
|
|
// when the function is parsed.
|
|
|
|
GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(),
|
|
|
|
Type::getInt8Ty(Context),
|
2009-10-28 05:53:48 +00:00
|
|
|
false, GlobalValue::InternalLinkage,
|
2012-09-21 14:34:31 +00:00
|
|
|
0, "");
|
|
|
|
BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef));
|
|
|
|
V = FwdRef;
|
|
|
|
}
|
2009-10-28 05:53:48 +00:00
|
|
|
break;
|
2012-11-15 22:34:00 +00:00
|
|
|
}
|
2007-04-24 05:48:56 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
ValueList.AssignValue(V, NextCstNo);
|
2007-04-24 05:48:56 +00:00
|
|
|
++NextCstNo;
|
2007-04-24 03:30:34 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
bool BitcodeReader::ParseUseLists() {
|
|
|
|
if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
|
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
// Read all the records.
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("malformed use list block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
2011-12-07 21:44:12 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2011-12-07 21:44:12 +00:00
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
// Read a use list record.
|
|
|
|
Record.clear();
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2011-12-07 21:44:12 +00:00
|
|
|
default: // Default behavior: unknown type.
|
|
|
|
break;
|
|
|
|
case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD.
|
|
|
|
unsigned RecordLength = Record.size();
|
|
|
|
if (RecordLength < 1)
|
|
|
|
return Error ("Invalid UseList reader!");
|
|
|
|
UseListRecords.push_back(Record);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
/// RememberAndSkipFunctionBody - When we see the block for a function body,
|
|
|
|
/// remember where it is and then skip it. This lets us lazily deserialize the
|
|
|
|
/// functions.
|
|
|
|
bool BitcodeReader::RememberAndSkipFunctionBody() {
|
2007-05-01 04:59:48 +00:00
|
|
|
// Get the function we are talking about.
|
|
|
|
if (FunctionsWithBodies.empty())
|
|
|
|
return Error("Insufficient function protos");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
Function *Fn = FunctionsWithBodies.back();
|
|
|
|
FunctionsWithBodies.pop_back();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// Save the current stream state.
|
|
|
|
uint64_t CurBit = Stream.GetCurrentBitNo();
|
2010-01-27 20:34:15 +00:00
|
|
|
DeferredFunctionInfo[Fn] = CurBit;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// Skip over the function block for now.
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Malformed block record");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
bool BitcodeReader::GlobalCleanup() {
|
|
|
|
// Patch the initializers for globals and aliases up.
|
|
|
|
ResolveGlobalAndAliasInits();
|
|
|
|
if (!GlobalInits.empty() || !AliasInits.empty())
|
|
|
|
return Error("Malformed global initializer set");
|
|
|
|
|
|
|
|
// Look for intrinsic functions which need to be upgraded at some point
|
|
|
|
for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
|
|
|
|
FI != FE; ++FI) {
|
|
|
|
Function *NewFn;
|
|
|
|
if (UpgradeIntrinsicFunction(FI, NewFn))
|
|
|
|
UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for global variables which need to be renamed.
|
|
|
|
for (Module::global_iterator
|
|
|
|
GI = TheModule->global_begin(), GE = TheModule->global_end();
|
|
|
|
GI != GE; ++GI)
|
|
|
|
UpgradeGlobalVariable(GI);
|
|
|
|
// Force deallocation of memory for these vectors to favor the client that
|
|
|
|
// want lazy deserialization.
|
|
|
|
std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
|
|
|
|
std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitcodeReader::ParseModule(bool Resume) {
|
|
|
|
if (Resume)
|
|
|
|
Stream.JumpToBit(NextUnreadBit);
|
|
|
|
else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
std::vector<std::string> SectionTable;
|
2008-08-17 18:44:35 +00:00
|
|
|
std::vector<std::string> GCTable;
|
2007-04-22 06:23:29 +00:00
|
|
|
|
|
|
|
// Read all the records for this module.
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advance();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
Error("malformed module block");
|
|
|
|
return true;
|
|
|
|
case BitstreamEntry::EndBlock:
|
2012-02-06 22:30:29 +00:00
|
|
|
return GlobalCleanup();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::SubBlock:
|
|
|
|
switch (Entry.ID) {
|
2007-04-22 06:23:29 +00:00
|
|
|
default: // Skip unknown content.
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Malformed block record");
|
|
|
|
break;
|
2007-05-05 18:57:30 +00:00
|
|
|
case bitc::BLOCKINFO_BLOCK_ID:
|
|
|
|
if (Stream.ReadBlockInfoBlock())
|
|
|
|
return Error("Malformed BlockInfoBlock");
|
|
|
|
break;
|
2007-05-04 03:30:17 +00:00
|
|
|
case bitc::PARAMATTR_BLOCK_ID:
|
2008-09-25 21:00:45 +00:00
|
|
|
if (ParseAttributeBlock())
|
2007-05-04 03:30:17 +00:00
|
|
|
return true;
|
|
|
|
break;
|
2013-02-10 23:24:25 +00:00
|
|
|
case bitc::PARAMATTR_GROUP_BLOCK_ID:
|
|
|
|
if (ParseAttributeGroupBlock())
|
|
|
|
return true;
|
|
|
|
break;
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
case bitc::TYPE_BLOCK_ID_NEW:
|
2007-05-01 05:01:34 +00:00
|
|
|
if (ParseTypeTable())
|
2007-04-22 06:23:29 +00:00
|
|
|
return true;
|
|
|
|
break;
|
2007-04-23 21:26:05 +00:00
|
|
|
case bitc::VALUE_SYMTAB_BLOCK_ID:
|
2007-05-01 05:01:34 +00:00
|
|
|
if (ParseValueSymbolTable())
|
2007-04-23 21:26:05 +00:00
|
|
|
return true;
|
2012-02-06 22:30:29 +00:00
|
|
|
SeenValueSymbolTable = true;
|
2007-04-23 21:26:05 +00:00
|
|
|
break;
|
2007-04-24 03:30:34 +00:00
|
|
|
case bitc::CONSTANTS_BLOCK_ID:
|
2007-05-01 05:01:34 +00:00
|
|
|
if (ParseConstants() || ResolveGlobalAndAliasInits())
|
2007-04-24 03:30:34 +00:00
|
|
|
return true;
|
|
|
|
break;
|
2009-07-22 17:43:22 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
|
|
|
if (ParseMetadata())
|
|
|
|
return true;
|
|
|
|
break;
|
2007-05-01 04:59:48 +00:00
|
|
|
case bitc::FUNCTION_BLOCK_ID:
|
|
|
|
// If this is the first function body we've seen, reverse the
|
|
|
|
// FunctionsWithBodies list.
|
2012-02-06 22:30:29 +00:00
|
|
|
if (!SeenFirstFunctionBody) {
|
2007-05-01 04:59:48 +00:00
|
|
|
std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
|
2012-02-06 22:30:29 +00:00
|
|
|
if (GlobalCleanup())
|
|
|
|
return true;
|
|
|
|
SeenFirstFunctionBody = true;
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
if (RememberAndSkipFunctionBody())
|
2007-05-01 04:59:48 +00:00
|
|
|
return true;
|
2012-02-06 22:30:29 +00:00
|
|
|
// For streaming bitcode, suspend parsing when we reach the function
|
|
|
|
// bodies. Subsequent materialization calls will resume it when
|
|
|
|
// necessary. For streaming, the function bodies must be at the end of
|
|
|
|
// the bitcode. If the bitcode file is old, the symbol table will be
|
|
|
|
// at the end instead and will not have been seen yet. In this case,
|
|
|
|
// just finish the parse now.
|
|
|
|
if (LazyStreamer && SeenValueSymbolTable) {
|
|
|
|
NextUnreadBit = Stream.GetCurrentBitNo();
|
|
|
|
return false;
|
|
|
|
}
|
2007-05-01 04:59:48 +00:00
|
|
|
break;
|
2011-12-07 21:44:12 +00:00
|
|
|
case bitc::USELIST_BLOCK_ID:
|
|
|
|
if (ParseUseLists())
|
|
|
|
return true;
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
continue;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// Read a record.
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2007-04-22 06:23:29 +00:00
|
|
|
default: break; // Default behavior, ignore unknown content.
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
case bitc::MODULE_CODE_VERSION: { // VERSION: [version#]
|
2007-04-22 06:23:29 +00:00
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Malformed MODULE_CODE_VERSION");
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// Only version #0 and #1 are supported so far.
|
|
|
|
unsigned module_version = Record[0];
|
|
|
|
switch (module_version) {
|
|
|
|
default: return Error("Unknown bitstream version!");
|
|
|
|
case 0:
|
|
|
|
UseRelativeIDs = false;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
UseRelativeIDs = true;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
}
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
|
2007-04-22 06:23:29 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_TRIPLE record");
|
|
|
|
TheModule->setTargetTriple(S);
|
|
|
|
break;
|
|
|
|
}
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
|
2007-04-22 06:23:29 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_DATALAYOUT record");
|
|
|
|
TheModule->setDataLayout(S);
|
|
|
|
break;
|
|
|
|
}
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
|
2007-04-22 06:23:29 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_ASM record");
|
|
|
|
TheModule->setModuleInlineAsm(S);
|
|
|
|
break;
|
|
|
|
}
|
2012-11-28 08:41:48 +00:00
|
|
|
case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
|
|
|
|
// FIXME: Remove in 4.0.
|
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_DEPLIB record");
|
|
|
|
// Ignore value.
|
|
|
|
break;
|
|
|
|
}
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
|
2007-04-22 06:23:29 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_SECTIONNAME record");
|
|
|
|
SectionTable.push_back(S);
|
|
|
|
break;
|
|
|
|
}
|
2008-08-17 18:44:35 +00:00
|
|
|
case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
|
2007-12-10 03:18:06 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
2008-08-17 18:44:35 +00:00
|
|
|
return Error("Invalid MODULE_CODE_GCNAME record");
|
|
|
|
GCTable.push_back(S);
|
2007-12-10 03:18:06 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-12-11 08:59:05 +00:00
|
|
|
// GLOBALVAR: [pointer type, isconst, initid,
|
2011-01-08 16:42:36 +00:00
|
|
|
// linkage, alignment, section, visibility, threadlocal,
|
|
|
|
// unnamed_addr]
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::MODULE_CODE_GLOBALVAR: {
|
2007-04-23 16:04:05 +00:00
|
|
|
if (Record.size() < 6)
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Invalid MODULE_CODE_GLOBALVAR record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2010-10-28 15:47:26 +00:00
|
|
|
if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record");
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Global not a pointer type!");
|
2007-12-11 08:59:05 +00:00
|
|
|
unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
|
2007-04-22 06:23:29 +00:00
|
|
|
Ty = cast<PointerType>(Ty)->getElementType();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
bool isConstant = Record[1];
|
|
|
|
GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
|
|
|
|
unsigned Alignment = (1 << Record[4]) >> 1;
|
|
|
|
std::string Section;
|
|
|
|
if (Record[5]) {
|
|
|
|
if (Record[5]-1 >= SectionTable.size())
|
|
|
|
return Error("Invalid section ID");
|
|
|
|
Section = SectionTable[Record[5]-1];
|
|
|
|
}
|
2007-04-23 16:04:05 +00:00
|
|
|
GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
|
2007-05-06 19:27:46 +00:00
|
|
|
if (Record.size() > 6)
|
|
|
|
Visibility = GetDecodedVisibility(Record[6]);
|
2012-06-23 11:37:03 +00:00
|
|
|
|
|
|
|
GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;
|
2007-05-06 19:27:46 +00:00
|
|
|
if (Record.size() > 7)
|
2012-06-23 11:37:03 +00:00
|
|
|
TLM = GetDecodedThreadLocalMode(Record[7]);
|
2007-04-22 06:23:29 +00:00
|
|
|
|
2011-01-08 16:42:36 +00:00
|
|
|
bool UnnamedAddr = false;
|
|
|
|
if (Record.size() > 8)
|
|
|
|
UnnamedAddr = Record[8];
|
|
|
|
|
2013-02-05 05:57:38 +00:00
|
|
|
bool ExternallyInitialized = false;
|
|
|
|
if (Record.size() > 9)
|
|
|
|
ExternallyInitialized = Record[9];
|
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
GlobalVariable *NewGV =
|
2009-09-20 02:20:51 +00:00
|
|
|
new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0,
|
2013-02-05 05:57:38 +00:00
|
|
|
TLM, AddressSpace, ExternallyInitialized);
|
2007-04-22 06:23:29 +00:00
|
|
|
NewGV->setAlignment(Alignment);
|
|
|
|
if (!Section.empty())
|
|
|
|
NewGV->setSection(Section);
|
|
|
|
NewGV->setVisibility(Visibility);
|
2011-01-08 16:42:36 +00:00
|
|
|
NewGV->setUnnamedAddr(UnnamedAddr);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-23 21:26:05 +00:00
|
|
|
ValueList.push_back(NewGV);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 00:18:21 +00:00
|
|
|
// Remember which value to use for the global initializer.
|
|
|
|
if (unsigned InitID = Record[2])
|
|
|
|
GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-08 05:38:01 +00:00
|
|
|
// FUNCTION: [type, callingconv, isproto, linkage, paramattr,
|
2011-01-08 16:42:36 +00:00
|
|
|
// alignment, section, visibility, gc, unnamed_addr]
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::MODULE_CODE_FUNCTION: {
|
2007-05-08 05:38:01 +00:00
|
|
|
if (Record.size() < 8)
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Invalid MODULE_CODE_FUNCTION record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2010-10-28 15:47:26 +00:00
|
|
|
if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record");
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Function not a pointer type!");
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FTy =
|
2007-04-22 06:23:29 +00:00
|
|
|
dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
|
|
|
|
if (!FTy)
|
|
|
|
return Error("Function not a pointer to function type!");
|
|
|
|
|
2008-04-06 20:25:17 +00:00
|
|
|
Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
|
|
|
|
"", TheModule);
|
2007-04-22 06:23:29 +00:00
|
|
|
|
2009-09-02 08:44:58 +00:00
|
|
|
Func->setCallingConv(static_cast<CallingConv::ID>(Record[1]));
|
2007-05-01 04:59:48 +00:00
|
|
|
bool isProto = Record[2];
|
2007-04-22 06:23:29 +00:00
|
|
|
Func->setLinkage(GetDecodedLinkage(Record[3]));
|
2008-09-25 21:00:45 +00:00
|
|
|
Func->setAttributes(getAttributes(Record[4]));
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-08 05:38:01 +00:00
|
|
|
Func->setAlignment((1 << Record[5]) >> 1);
|
|
|
|
if (Record[6]) {
|
|
|
|
if (Record[6]-1 >= SectionTable.size())
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Invalid section ID");
|
2007-05-08 05:38:01 +00:00
|
|
|
Func->setSection(SectionTable[Record[6]-1]);
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
2007-05-08 05:38:01 +00:00
|
|
|
Func->setVisibility(GetDecodedVisibility(Record[7]));
|
2007-12-10 03:18:06 +00:00
|
|
|
if (Record.size() > 8 && Record[8]) {
|
2008-08-17 18:44:35 +00:00
|
|
|
if (Record[8]-1 > GCTable.size())
|
|
|
|
return Error("Invalid GC ID");
|
|
|
|
Func->setGC(GCTable[Record[8]-1].c_str());
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
2011-01-08 16:42:36 +00:00
|
|
|
bool UnnamedAddr = false;
|
|
|
|
if (Record.size() > 9)
|
|
|
|
UnnamedAddr = Record[9];
|
|
|
|
Func->setUnnamedAddr(UnnamedAddr);
|
2013-09-16 01:08:15 +00:00
|
|
|
if (Record.size() > 10 && Record[10] != 0)
|
|
|
|
FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1));
|
2007-04-23 21:26:05 +00:00
|
|
|
ValueList.push_back(Func);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// If this is a function with a body, remember the prototype we are
|
|
|
|
// creating now, so that we can match up the body with them later.
|
2012-02-06 22:30:29 +00:00
|
|
|
if (!isProto) {
|
2007-05-01 04:59:48 +00:00
|
|
|
FunctionsWithBodies.push_back(Func);
|
2012-02-06 22:30:29 +00:00
|
|
|
if (LazyStreamer) DeferredFunctionInfo[Func] = 0;
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-03-12 00:49:19 +00:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage]
|
2008-03-11 21:40:17 +00:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage, visibility]
|
2007-04-26 03:27:58 +00:00
|
|
|
case bitc::MODULE_CODE_ALIAS: {
|
2007-04-26 02:46:40 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error("Invalid MODULE_ALIAS record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2010-10-28 15:47:26 +00:00
|
|
|
if (!Ty) return Error("Invalid MODULE_ALIAS record");
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2007-04-26 02:46:40 +00:00
|
|
|
return Error("Function not a pointer type!");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
|
|
|
|
"", 0, TheModule);
|
2008-03-12 00:49:19 +00:00
|
|
|
// Old bitcode files didn't have visibility field.
|
|
|
|
if (Record.size() > 3)
|
|
|
|
NewGA->setVisibility(GetDecodedVisibility(Record[3]));
|
2007-04-26 02:46:40 +00:00
|
|
|
ValueList.push_back(NewGA);
|
|
|
|
AliasInits.push_back(std::make_pair(NewGA, Record[1]));
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
2007-04-26 03:27:58 +00:00
|
|
|
/// MODULE_CODE_PURGEVALS: [numvals]
|
|
|
|
case bitc::MODULE_CODE_PURGEVALS:
|
|
|
|
// Trim down the value list to the specified size.
|
|
|
|
if (Record.size() < 1 || Record[0] > ValueList.size())
|
|
|
|
return Error("Invalid MODULE_PURGEVALS record");
|
|
|
|
ValueList.shrinkTo(Record[0]);
|
|
|
|
break;
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
bool BitcodeReader::ParseBitcodeInto(Module *M) {
|
2007-04-22 06:23:29 +00:00
|
|
|
TheModule = 0;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
if (InitStream()) return true;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// Sniff for the signature.
|
|
|
|
if (Stream.Read(8) != 'B' ||
|
|
|
|
Stream.Read(8) != 'C' ||
|
|
|
|
Stream.Read(4) != 0x0 ||
|
|
|
|
Stream.Read(4) != 0xC ||
|
|
|
|
Stream.Read(4) != 0xE ||
|
|
|
|
Stream.Read(4) != 0xD)
|
|
|
|
return Error("Invalid bitcode signature");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// We expect a number of well-defined blocks, though we don't necessarily
|
|
|
|
// need to understand them all.
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
if (Stream.AtEndOfStream())
|
|
|
|
return false;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry =
|
|
|
|
Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
Error("malformed module file");
|
|
|
|
return true;
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
return false;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::SubBlock:
|
|
|
|
switch (Entry.ID) {
|
|
|
|
case bitc::BLOCKINFO_BLOCK_ID:
|
|
|
|
if (Stream.ReadBlockInfoBlock())
|
|
|
|
return Error("Malformed BlockInfoBlock");
|
|
|
|
break;
|
|
|
|
case bitc::MODULE_BLOCK_ID:
|
|
|
|
// Reject multiple MODULE_BLOCK's in a single bitstream.
|
|
|
|
if (TheModule)
|
|
|
|
return Error("Multiple MODULE_BLOCKs in same stream");
|
|
|
|
TheModule = M;
|
|
|
|
if (ParseModule(false))
|
|
|
|
return true;
|
|
|
|
if (LazyStreamer) return false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Malformed block record");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// There should be no records in the top-level of blocks.
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
// The ranlib in Xcode 4 will align archive members by appending newlines
|
2011-08-09 22:23:40 +00:00
|
|
|
// to the end of them. If this file size is a multiple of 4 but not 8, we
|
|
|
|
// have to read and ignore these final 4 bytes :-(
|
2013-01-20 02:13:19 +00:00
|
|
|
if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&
|
2011-05-26 18:59:54 +00:00
|
|
|
Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
|
2012-07-19 00:15:11 +00:00
|
|
|
Stream.AtEndOfStream())
|
2011-05-26 18:59:54 +00:00
|
|
|
return false;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
return Error("Invalid record at top-level");
|
2011-05-26 18:59:54 +00:00
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-29 07:54:31 +00:00
|
|
|
|
2010-10-06 01:22:42 +00:00
|
|
|
bool BitcodeReader::ParseModuleTriple(std::string &Triple) {
|
|
|
|
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
|
|
|
return Error("Malformed block record");
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
|
|
|
|
// Read all the records for this module.
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("malformed module block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
2010-10-06 01:22:42 +00:00
|
|
|
return false;
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2010-10-06 01:22:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read a record.
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2010-10-06 01:22:42 +00:00
|
|
|
default: break; // Default behavior, ignore unknown content.
|
|
|
|
case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
|
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
|
|
|
return Error("Invalid MODULE_CODE_TRIPLE record");
|
|
|
|
Triple = S;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitcodeReader::ParseTriple(std::string &Triple) {
|
2012-02-06 22:30:29 +00:00
|
|
|
if (InitStream()) return true;
|
2010-10-06 01:22:42 +00:00
|
|
|
|
|
|
|
// Sniff for the signature.
|
|
|
|
if (Stream.Read(8) != 'B' ||
|
|
|
|
Stream.Read(8) != 'C' ||
|
|
|
|
Stream.Read(4) != 0x0 ||
|
|
|
|
Stream.Read(4) != 0xC ||
|
|
|
|
Stream.Read(4) != 0xE ||
|
|
|
|
Stream.Read(4) != 0xD)
|
|
|
|
return Error("Invalid bitcode signature");
|
|
|
|
|
|
|
|
// We expect a number of well-defined blocks, though we don't necessarily
|
|
|
|
// need to understand them all.
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advance();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
Error("malformed module file");
|
|
|
|
return true;
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
return false;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::SubBlock:
|
|
|
|
if (Entry.ID == bitc::MODULE_BLOCK_ID)
|
|
|
|
return ParseModuleTriple(Triple);
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
// Ignore other sub-blocks.
|
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("malformed block record in AST file");
|
2010-10-06 01:22:42 +00:00
|
|
|
return true;
|
2013-01-20 02:13:19 +00:00
|
|
|
}
|
|
|
|
continue;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
Stream.skipRecord(Entry.ID);
|
|
|
|
continue;
|
2010-10-06 01:22:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
/// ParseMetadataAttachment - Parse metadata attachments.
|
|
|
|
bool BitcodeReader::ParseMetadataAttachment() {
|
|
|
|
if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
|
|
|
|
return Error("Malformed block record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("malformed metadata block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
return false;
|
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
2009-09-18 19:26:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-01-20 02:13:19 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
// Read a metadata attachment record.
|
|
|
|
Record.clear();
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2009-09-18 19:26:43 +00:00
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
2011-06-17 17:50:30 +00:00
|
|
|
case bitc::METADATA_ATTACHMENT: {
|
2009-09-18 19:26:43 +00:00
|
|
|
unsigned RecordLength = Record.size();
|
|
|
|
if (Record.empty() || (RecordLength - 1) % 2 == 1)
|
2009-09-20 02:20:51 +00:00
|
|
|
return Error ("Invalid METADATA_ATTACHMENT reader!");
|
2009-09-18 19:26:43 +00:00
|
|
|
Instruction *Inst = InstructionList[Record[0]];
|
|
|
|
for (unsigned i = 1; i != RecordLength; i = i+2) {
|
2009-09-28 21:14:55 +00:00
|
|
|
unsigned Kind = Record[i];
|
2010-07-20 21:42:28 +00:00
|
|
|
DenseMap<unsigned, unsigned>::iterator I =
|
|
|
|
MDKindMap.find(Kind);
|
|
|
|
if (I == MDKindMap.end())
|
|
|
|
return Error("Invalid metadata kind ID");
|
2009-09-20 02:20:51 +00:00
|
|
|
Value *Node = MDValueList.getValueFwdRef(Record[i+1]);
|
2010-07-20 21:42:28 +00:00
|
|
|
Inst->setMetadata(I->second, cast<MDNode>(Node));
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-05-01 04:59:48 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
/// ParseFunctionBody - Lazily parse the specified function body block.
|
|
|
|
bool BitcodeReader::ParseFunctionBody(Function *F) {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
|
2007-05-01 05:52:21 +00:00
|
|
|
return Error("Malformed block record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-02-25 08:30:17 +00:00
|
|
|
InstructionList.clear();
|
2007-05-01 05:52:21 +00:00
|
|
|
unsigned ModuleValueListSize = ValueList.size();
|
2010-08-25 20:22:53 +00:00
|
|
|
unsigned ModuleMDValueListSize = MDValueList.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
// Add all the function arguments to the value table.
|
|
|
|
for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
|
|
|
|
ValueList.push_back(I);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
unsigned NextValueNo = ValueList.size();
|
2007-05-02 04:27:25 +00:00
|
|
|
BasicBlock *CurBB = 0;
|
|
|
|
unsigned CurBBNo = 0;
|
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
DebugLoc LastLoc;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
// Read all the records.
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
while (1) {
|
2013-01-20 02:13:19 +00:00
|
|
|
BitstreamEntry Entry = Stream.advance();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::Error:
|
|
|
|
return Error("Bitcode error in function block");
|
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
goto OutOfRecordLoop;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::SubBlock:
|
|
|
|
switch (Entry.ID) {
|
2007-05-01 05:52:21 +00:00
|
|
|
default: // Skip unknown content.
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Malformed block record");
|
|
|
|
break;
|
|
|
|
case bitc::CONSTANTS_BLOCK_ID:
|
|
|
|
if (ParseConstants()) return true;
|
2007-05-01 07:01:57 +00:00
|
|
|
NextValueNo = ValueList.size();
|
2007-05-01 05:52:21 +00:00
|
|
|
break;
|
|
|
|
case bitc::VALUE_SYMTAB_BLOCK_ID:
|
|
|
|
if (ParseValueSymbolTable()) return true;
|
|
|
|
break;
|
2009-09-18 19:26:43 +00:00
|
|
|
case bitc::METADATA_ATTACHMENT_ID:
|
2009-09-20 02:20:51 +00:00
|
|
|
if (ParseMetadataAttachment()) return true;
|
|
|
|
break;
|
2010-01-13 19:34:08 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
|
|
|
if (ParseMetadata()) return true;
|
|
|
|
break;
|
2007-05-01 05:52:21 +00:00
|
|
|
}
|
|
|
|
continue;
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::Record:
|
|
|
|
// The interesting case.
|
|
|
|
break;
|
2007-05-01 05:52:21 +00:00
|
|
|
}
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
2007-05-01 07:01:57 +00:00
|
|
|
Instruction *I = 0;
|
2013-01-20 02:13:19 +00:00
|
|
|
unsigned BitCode = Stream.readRecord(Entry.ID, Record);
|
2009-07-20 21:19:07 +00:00
|
|
|
switch (BitCode) {
|
2007-05-01 07:01:57 +00:00
|
|
|
default: // Default behavior: reject
|
|
|
|
return Error("Unknown instruction");
|
2007-05-01 05:52:21 +00:00
|
|
|
case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks]
|
2007-05-01 07:01:57 +00:00
|
|
|
if (Record.size() < 1 || Record[0] == 0)
|
|
|
|
return Error("Invalid DECLAREBLOCKS record");
|
2007-05-01 05:52:21 +00:00
|
|
|
// Create all the basic blocks for the function.
|
2007-05-03 22:09:51 +00:00
|
|
|
FunctionBBs.resize(Record[0]);
|
2007-05-01 05:52:21 +00:00
|
|
|
for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
|
2009-08-13 21:58:54 +00:00
|
|
|
FunctionBBs[i] = BasicBlock::Create(Context, "", F);
|
2007-05-01 07:01:57 +00:00
|
|
|
CurBB = FunctionBBs[0];
|
|
|
|
continue;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN
|
|
|
|
// This record indicates that the last instruction is at the same
|
|
|
|
// location as the previous instruction with a location.
|
|
|
|
I = 0;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
// Get the last instruction emitted.
|
|
|
|
if (CurBB && !CurBB->empty())
|
|
|
|
I = &CurBB->back();
|
|
|
|
else if (CurBBNo && FunctionBBs[CurBBNo-1] &&
|
|
|
|
!FunctionBBs[CurBBNo-1]->empty())
|
|
|
|
I = &FunctionBBs[CurBBNo-1]->back();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record");
|
|
|
|
I->setDebugLoc(LastLoc);
|
|
|
|
I = 0;
|
|
|
|
continue;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-06-17 18:17:37 +00:00
|
|
|
case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
|
2010-04-03 02:17:50 +00:00
|
|
|
I = 0; // Get the last instruction emitted.
|
|
|
|
if (CurBB && !CurBB->empty())
|
|
|
|
I = &CurBB->back();
|
|
|
|
else if (CurBBNo && FunctionBBs[CurBBNo-1] &&
|
|
|
|
!FunctionBBs[CurBBNo-1]->empty())
|
|
|
|
I = &FunctionBBs[CurBBNo-1]->back();
|
|
|
|
if (I == 0 || Record.size() < 4)
|
|
|
|
return Error("Invalid FUNC_CODE_DEBUG_LOC record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
unsigned Line = Record[0], Col = Record[1];
|
|
|
|
unsigned ScopeID = Record[2], IAID = Record[3];
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
MDNode *Scope = 0, *IA = 0;
|
|
|
|
if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1));
|
|
|
|
if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1));
|
|
|
|
LastLoc = DebugLoc::get(Line, Col, Scope, IA);
|
|
|
|
I->setDebugLoc(LastLoc);
|
|
|
|
I = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *LHS, *RHS;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
|
2009-07-20 21:19:07 +00:00
|
|
|
OpNum+1 > Record.size())
|
2007-05-06 00:21:25 +00:00
|
|
|
return Error("Invalid BINOP record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-20 21:19:07 +00:00
|
|
|
int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
|
2007-05-06 00:21:25 +00:00
|
|
|
if (Opc == -1) return Error("Invalid BINOP record");
|
2008-05-16 19:29:10 +00:00
|
|
|
I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-09-07 23:54:19 +00:00
|
|
|
if (OpNum < Record.size()) {
|
|
|
|
if (Opc == Instruction::Add ||
|
|
|
|
Opc == Instruction::Sub ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::Mul ||
|
|
|
|
Opc == Instruction::Shl) {
|
2010-01-25 21:55:39 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
|
2010-01-25 21:55:39 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
|
2011-02-06 21:44:57 +00:00
|
|
|
} else if (Opc == Instruction::SDiv ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::UDiv ||
|
|
|
|
Opc == Instruction::LShr ||
|
|
|
|
Opc == Instruction::AShr) {
|
2011-02-06 21:44:57 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::PEO_EXACT))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setIsExact(true);
|
2012-11-27 00:43:38 +00:00
|
|
|
} else if (isa<FPMathOperator>(I)) {
|
|
|
|
FastMathFlags FMF;
|
2012-12-09 21:12:04 +00:00
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::UnsafeAlgebra))
|
|
|
|
FMF.setUnsafeAlgebra();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoNaNs))
|
|
|
|
FMF.setNoNaNs();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoInfs))
|
|
|
|
FMF.setNoInfs();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoSignedZeros))
|
|
|
|
FMF.setNoSignedZeros();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::AllowReciprocal))
|
|
|
|
FMF.setAllowReciprocal();
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FMF.any())
|
|
|
|
I->setFastMathFlags(FMF);
|
2009-09-07 23:54:19 +00:00
|
|
|
}
|
2012-11-27 00:43:38 +00:00
|
|
|
|
2009-09-07 23:54:19 +00:00
|
|
|
}
|
2007-05-01 07:01:57 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
|
|
|
|
OpNum+2 != Record.size())
|
|
|
|
return Error("Invalid CAST record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ResTy = getTypeByID(Record[OpNum]);
|
2007-05-06 00:21:25 +00:00
|
|
|
int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
|
|
|
|
if (Opc == -1 || ResTy == 0)
|
2007-05-02 04:27:25 +00:00
|
|
|
return Error("Invalid CAST record");
|
2008-05-16 19:29:10 +00:00
|
|
|
I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 04:27:25 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-27 21:53:46 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INBOUNDS_GEP:
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
|
2007-05-06 00:00:00 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *BasePtr;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid GEP record");
|
|
|
|
|
2007-05-02 05:46:45 +00:00
|
|
|
SmallVector<Value*, 16> GEPIdx;
|
2007-05-06 00:00:00 +00:00
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid GEP record");
|
2007-05-06 00:00:00 +00:00
|
|
|
GEPIdx.push_back(Op);
|
2007-05-02 05:16:49 +00:00
|
|
|
}
|
|
|
|
|
2011-07-25 09:48:08 +00:00
|
|
|
I = GetElementPtrInst::Create(BasePtr, GEPIdx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-07-27 21:53:46 +00:00
|
|
|
if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP)
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<GetElementPtrInst>(I)->setIsInBounds(true);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
case bitc::FUNC_CODE_INST_EXTRACTVAL: {
|
|
|
|
// EXTRACTVAL: [opty, opval, n x indices]
|
2008-05-23 01:55:30 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Agg;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
|
|
|
|
return Error("Invalid EXTRACTVAL record");
|
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
SmallVector<unsigned, 4> EXTRACTVALIdx;
|
|
|
|
for (unsigned RecSize = Record.size();
|
|
|
|
OpNum != RecSize; ++OpNum) {
|
|
|
|
uint64_t Index = Record[OpNum];
|
|
|
|
if ((unsigned)Index != Index)
|
|
|
|
return Error("Invalid EXTRACTVAL index");
|
|
|
|
EXTRACTVALIdx.push_back((unsigned)Index);
|
2008-05-23 01:55:30 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 10:26:04 +00:00
|
|
|
I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-05-23 01:55:30 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INSERTVAL: {
|
|
|
|
// INSERTVAL: [opty, opval, opty, opval, n x indices]
|
2008-05-23 01:55:30 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Agg;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
|
|
|
|
return Error("Invalid INSERTVAL record");
|
|
|
|
Value *Val;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
|
|
|
|
return Error("Invalid INSERTVAL record");
|
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
SmallVector<unsigned, 4> INSERTVALIdx;
|
|
|
|
for (unsigned RecSize = Record.size();
|
|
|
|
OpNum != RecSize; ++OpNum) {
|
|
|
|
uint64_t Index = Record[OpNum];
|
|
|
|
if ((unsigned)Index != Index)
|
|
|
|
return Error("Invalid INSERTVAL index");
|
|
|
|
INSERTVALIdx.push_back((unsigned)Index);
|
2008-05-23 01:55:30 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 10:26:04 +00:00
|
|
|
I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-05-23 01:55:30 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
|
2008-09-16 01:01:33 +00:00
|
|
|
// obsolete form of select
|
|
|
|
// handles select i1 ... in old bitcode
|
2007-05-06 00:21:25 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *TrueVal, *FalseVal, *Cond;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
|
|
|
|
popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid SELECT record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-16 01:01:33 +00:00
|
|
|
I = SelectInst::Create(Cond, TrueVal, FalseVal);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-09-16 01:01:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-16 01:01:33 +00:00
|
|
|
case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
|
|
|
|
// new form of select
|
|
|
|
// handles select i1 or select [N x i1]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *TrueVal, *FalseVal, *Cond;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
|
2008-09-16 01:01:33 +00:00
|
|
|
getValueTypePair(Record, OpNum, NextValueNo, Cond))
|
|
|
|
return Error("Invalid SELECT record");
|
2008-09-09 01:02:47 +00:00
|
|
|
|
|
|
|
// select condition can be either i1 or [N x i1]
|
2011-07-18 04:54:35 +00:00
|
|
|
if (VectorType* vector_type =
|
|
|
|
dyn_cast<VectorType>(Cond->getType())) {
|
2008-09-09 01:02:47 +00:00
|
|
|
// expect <n x i1>
|
2009-09-20 02:20:51 +00:00
|
|
|
if (vector_type->getElementType() != Type::getInt1Ty(Context))
|
2008-09-09 01:02:47 +00:00
|
|
|
return Error("Invalid SELECT condition type");
|
|
|
|
} else {
|
|
|
|
// expect i1
|
2009-09-20 02:20:51 +00:00
|
|
|
if (Cond->getType() != Type::getInt1Ty(Context))
|
2008-09-09 01:02:47 +00:00
|
|
|
return Error("Invalid SELECT condition type");
|
2009-09-20 02:20:51 +00:00
|
|
|
}
|
|
|
|
|
2008-04-06 20:25:17 +00:00
|
|
|
I = SelectInst::Create(Cond, TrueVal, FalseVal);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-02 05:16:49 +00:00
|
|
|
case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
|
2007-05-06 00:21:25 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Vec, *Idx;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid EXTRACTELT record");
|
2009-07-25 02:28:41 +00:00
|
|
|
I = ExtractElementInst::Create(Vec, Idx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-02 05:16:49 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
|
2007-05-06 00:21:25 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Vec, *Elt, *Idx;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2007-05-06 00:21:25 +00:00
|
|
|
cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid INSERTELT record");
|
2008-04-06 20:25:17 +00:00
|
|
|
I = InsertElementInst::Create(Vec, Elt, Idx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Vec1, *Vec2, *Mask;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
|
2007-05-06 00:21:25 +00:00
|
|
|
return Error("Invalid SHUFFLEVEC record");
|
|
|
|
|
2008-11-10 04:46:22 +00:00
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
|
2007-05-02 05:16:49 +00:00
|
|
|
return Error("Invalid SHUFFLEVEC record");
|
|
|
|
I = new ShuffleVectorInst(Vec1, Vec2, Mask);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-11-10 04:46:22 +00:00
|
|
|
|
2009-07-08 03:04:38 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
|
|
|
|
// Old form of ICmp/FCmp returning bool
|
|
|
|
// Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
|
|
|
|
// both legal on vectors but had different behaviour.
|
2008-09-16 01:01:33 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
|
2009-07-08 03:04:38 +00:00
|
|
|
// FCmp/ICmp returning bool or vector of bool
|
|
|
|
|
2008-09-09 01:02:47 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *LHS, *RHS;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
|
2008-09-09 01:02:47 +00:00
|
|
|
OpNum+1 != Record.size())
|
2009-07-08 03:04:38 +00:00
|
|
|
return Error("Invalid CMP record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
if (LHS->getType()->isFPOrFPVectorTy())
|
2009-08-25 23:17:54 +00:00
|
|
|
I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
|
2009-07-08 03:04:38 +00:00
|
|
|
else
|
2009-08-25 23:17:54 +00:00
|
|
|
I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-09-09 01:02:47 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-08 03:04:38 +00:00
|
|
|
|
2007-05-02 04:27:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
|
2008-02-26 01:29:32 +00:00
|
|
|
{
|
|
|
|
unsigned Size = Record.size();
|
|
|
|
if (Size == 0) {
|
2009-08-13 21:58:54 +00:00
|
|
|
I = ReturnInst::Create(Context);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-02-26 01:29:32 +00:00
|
|
|
break;
|
2008-07-23 00:34:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned OpNum = 0;
|
2011-06-17 18:09:11 +00:00
|
|
|
Value *Op = NULL;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
|
|
|
return Error("Invalid RET record");
|
|
|
|
if (OpNum != Record.size())
|
|
|
|
return Error("Invalid RET record");
|
2008-07-23 00:34:11 +00:00
|
|
|
|
2011-06-17 18:09:11 +00:00
|
|
|
I = ReturnInst::Create(Context, Op);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-07-23 00:34:11 +00:00
|
|
|
break;
|
2007-05-02 04:27:25 +00:00
|
|
|
}
|
2007-05-02 05:46:45 +00:00
|
|
|
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
|
2007-05-03 22:09:51 +00:00
|
|
|
if (Record.size() != 1 && Record.size() != 3)
|
2007-05-02 05:46:45 +00:00
|
|
|
return Error("Invalid BR record");
|
|
|
|
BasicBlock *TrueDest = getBasicBlock(Record[0]);
|
|
|
|
if (TrueDest == 0)
|
|
|
|
return Error("Invalid BR record");
|
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
if (Record.size() == 1) {
|
2008-04-06 20:25:17 +00:00
|
|
|
I = BranchInst::Create(TrueDest);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
2007-05-02 05:46:45 +00:00
|
|
|
else {
|
|
|
|
BasicBlock *FalseDest = getBasicBlock(Record[1]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Cond = getValue(Record, 2, NextValueNo,
|
|
|
|
Type::getInt1Ty(Context));
|
2007-05-02 05:46:45 +00:00
|
|
|
if (FalseDest == 0 || Cond == 0)
|
|
|
|
return Error("Invalid BR record");
|
2008-04-06 20:25:17 +00:00
|
|
|
I = BranchInst::Create(TrueDest, FalseDest, Cond);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-10-27 19:13:16 +00:00
|
|
|
case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
|
2012-11-15 22:34:00 +00:00
|
|
|
// Check magic
|
2012-05-12 10:48:17 +00:00
|
|
|
if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
// "New" SwitchInst format with case ranges. The changes to write this
|
|
|
|
// format were reverted but we still recognize bitcode that uses it.
|
|
|
|
// Hopefully someday we will have support for case ranges and can use
|
|
|
|
// this format again.
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[1]);
|
|
|
|
unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
|
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
|
2012-05-12 10:48:17 +00:00
|
|
|
BasicBlock *Default = getBasicBlock(Record[3]);
|
|
|
|
if (OpTy == 0 || Cond == 0 || Default == 0)
|
|
|
|
return Error("Invalid SWITCH record");
|
|
|
|
|
|
|
|
unsigned NumCases = Record[4];
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
|
|
|
|
InstructionList.push_back(SI);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
unsigned CurIdx = 5;
|
|
|
|
for (unsigned i = 0; i != NumCases; ++i) {
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
SmallVector<ConstantInt*, 1> CaseVals;
|
2012-05-12 10:48:17 +00:00
|
|
|
unsigned NumItems = Record[CurIdx++];
|
|
|
|
for (unsigned ci = 0; ci != NumItems; ++ci) {
|
|
|
|
bool isSingleNumber = Record[CurIdx++];
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
APInt Low;
|
|
|
|
unsigned ActiveWords = 1;
|
|
|
|
if (ValueBitWidth > 64)
|
|
|
|
ActiveWords = Record[CurIdx++];
|
2012-05-28 14:10:31 +00:00
|
|
|
Low = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
|
|
|
|
ValueBitWidth);
|
2012-05-12 10:48:17 +00:00
|
|
|
CurIdx += ActiveWords;
|
2012-05-28 12:39:09 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
if (!isSingleNumber) {
|
|
|
|
ActiveWords = 1;
|
|
|
|
if (ValueBitWidth > 64)
|
|
|
|
ActiveWords = Record[CurIdx++];
|
|
|
|
APInt High =
|
2012-05-28 14:10:31 +00:00
|
|
|
ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
|
|
|
|
ValueBitWidth);
|
2012-05-12 10:48:17 +00:00
|
|
|
CurIdx += ActiveWords;
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
|
|
|
|
// FIXME: It is not clear whether values in the range should be
|
|
|
|
// compared as signed or unsigned values. The partially
|
|
|
|
// implemented changes that used this format in the past used
|
|
|
|
// unsigned comparisons.
|
|
|
|
for ( ; Low.ule(High); ++Low)
|
|
|
|
CaseVals.push_back(ConstantInt::get(Context, Low));
|
2012-05-12 10:48:17 +00:00
|
|
|
} else
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
CaseVals.push_back(ConstantInt::get(Context, Low));
|
2012-05-12 10:48:17 +00:00
|
|
|
}
|
|
|
|
BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
|
|
|
|
cve = CaseVals.end(); cvi != cve; ++cvi)
|
|
|
|
SI->addCase(*cvi, DestBB);
|
2012-05-12 10:48:17 +00:00
|
|
|
}
|
|
|
|
I = SI;
|
|
|
|
break;
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
// Old SwitchInst format without case ranges.
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-05-02 05:46:45 +00:00
|
|
|
if (Record.size() < 3 || (Record.size() & 1) == 0)
|
|
|
|
return Error("Invalid SWITCH record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
|
2007-05-02 05:46:45 +00:00
|
|
|
BasicBlock *Default = getBasicBlock(Record[2]);
|
|
|
|
if (OpTy == 0 || Cond == 0 || Default == 0)
|
|
|
|
return Error("Invalid SWITCH record");
|
|
|
|
unsigned NumCases = (Record.size()-3)/2;
|
2008-04-06 20:25:17 +00:00
|
|
|
SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(SI);
|
2007-05-02 05:46:45 +00:00
|
|
|
for (unsigned i = 0, e = NumCases; i != e; ++i) {
|
2009-09-20 02:20:51 +00:00
|
|
|
ConstantInt *CaseVal =
|
2007-05-02 05:46:45 +00:00
|
|
|
dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
|
|
|
|
BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
|
|
|
|
if (CaseVal == 0 || DestBB == 0) {
|
|
|
|
delete SI;
|
|
|
|
return Error("Invalid SWITCH record!");
|
|
|
|
}
|
|
|
|
SI->addCase(CaseVal, DestBB);
|
|
|
|
}
|
|
|
|
I = SI;
|
|
|
|
break;
|
|
|
|
}
|
2009-10-28 00:19:10 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
|
2009-10-27 19:13:16 +00:00
|
|
|
if (Record.size() < 2)
|
2009-10-28 00:19:10 +00:00
|
|
|
return Error("Invalid INDIRECTBR record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Address = getValue(Record, 1, NextValueNo, OpTy);
|
2009-10-27 19:13:16 +00:00
|
|
|
if (OpTy == 0 || Address == 0)
|
2009-10-28 00:19:10 +00:00
|
|
|
return Error("Invalid INDIRECTBR record");
|
2009-10-27 19:13:16 +00:00
|
|
|
unsigned NumDests = Record.size()-2;
|
2009-10-28 00:19:10 +00:00
|
|
|
IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
|
2009-10-27 19:13:16 +00:00
|
|
|
InstructionList.push_back(IBI);
|
|
|
|
for (unsigned i = 0, e = NumDests; i != e; ++i) {
|
|
|
|
if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
|
|
|
|
IBI->addDestination(DestBB);
|
|
|
|
} else {
|
|
|
|
delete IBI;
|
2009-10-28 00:19:10 +00:00
|
|
|
return Error("Invalid INDIRECTBR record!");
|
2009-10-27 19:13:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
I = IBI;
|
|
|
|
break;
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-11-27 13:23:08 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INVOKE: {
|
|
|
|
// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
|
2007-05-08 05:38:01 +00:00
|
|
|
if (Record.size() < 4) return Error("Invalid INVOKE record");
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet PAL = getAttributes(Record[0]);
|
2007-05-08 05:38:01 +00:00
|
|
|
unsigned CCInfo = Record[1];
|
|
|
|
BasicBlock *NormalBB = getBasicBlock(Record[2]);
|
|
|
|
BasicBlock *UnwindBB = getBasicBlock(Record[3]);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-08 05:38:01 +00:00
|
|
|
unsigned OpNum = 4;
|
2007-05-06 00:00:00 +00:00
|
|
|
Value *Callee;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
|
2007-05-02 05:46:45 +00:00
|
|
|
return Error("Invalid INVOKE record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
|
|
|
|
FunctionType *FTy = !CalleeTy ? 0 :
|
2007-05-02 05:46:45 +00:00
|
|
|
dyn_cast<FunctionType>(CalleeTy->getElementType());
|
|
|
|
|
|
|
|
// Check that the right number of fixed parameters are here.
|
2007-05-06 00:00:00 +00:00
|
|
|
if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 ||
|
|
|
|
Record.size() < OpNum+FTy->getNumParams())
|
2007-05-02 05:46:45 +00:00
|
|
|
return Error("Invalid INVOKE record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-02 05:46:45 +00:00
|
|
|
SmallVector<Value*, 16> Ops;
|
2007-05-06 00:00:00 +00:00
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Ops.push_back(getValue(Record, OpNum, NextValueNo,
|
|
|
|
FTy->getParamType(i)));
|
2007-05-06 00:00:00 +00:00
|
|
|
if (Ops.back() == 0) return Error("Invalid INVOKE record");
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
if (!FTy->isVarArg()) {
|
|
|
|
if (Record.size() != OpNum)
|
2007-05-02 05:46:45 +00:00
|
|
|
return Error("Invalid INVOKE record");
|
2007-05-06 00:00:00 +00:00
|
|
|
} else {
|
|
|
|
// Read type/value pairs for varargs params.
|
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
2007-05-02 05:46:45 +00:00
|
|
|
return Error("Invalid INVOKE record");
|
2007-05-06 00:00:00 +00:00
|
|
|
Ops.push_back(Op);
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-15 08:37:34 +00:00
|
|
|
I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-09-02 08:44:58 +00:00
|
|
|
cast<InvokeInst>(I)->setCallingConv(
|
|
|
|
static_cast<CallingConv::ID>(CCInfo));
|
2008-09-25 21:00:45 +00:00
|
|
|
cast<InvokeInst>(I)->setAttributes(PAL);
|
2007-05-02 05:46:45 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-07-31 06:30:59 +00:00
|
|
|
case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
|
|
|
|
unsigned Idx = 0;
|
|
|
|
Value *Val = 0;
|
|
|
|
if (getValueTypePair(Record, Idx, NextValueNo, Val))
|
|
|
|
return Error("Invalid RESUME record");
|
|
|
|
I = ResumeInst::Create(Val);
|
2011-09-01 00:50:20 +00:00
|
|
|
InstructionList.push_back(I);
|
2011-07-31 06:30:59 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-02 04:27:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
|
2009-08-13 21:58:54 +00:00
|
|
|
I = new UnreachableInst(Context);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 04:27:25 +00:00
|
|
|
break;
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
|
2007-05-04 19:11:41 +00:00
|
|
|
if (Record.size() < 1 || ((Record.size()-1)&1))
|
2007-05-03 18:58:09 +00:00
|
|
|
return Error("Invalid PHI record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2007-05-03 18:58:09 +00:00
|
|
|
if (!Ty) return Error("Invalid PHI record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-03-30 11:28:46 +00:00
|
|
|
PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(PN);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *V;
|
|
|
|
// With the new function encoding, it is possible that operands have
|
|
|
|
// negative IDs (for forward references). Use a signed VBR
|
|
|
|
// representation to keep the encoding small.
|
|
|
|
if (UseRelativeIDs)
|
|
|
|
V = getValueSigned(Record, 1+i, NextValueNo, Ty);
|
|
|
|
else
|
|
|
|
V = getValue(Record, 1+i, NextValueNo, Ty);
|
2007-05-04 19:11:41 +00:00
|
|
|
BasicBlock *BB = getBasicBlock(Record[2+i]);
|
2007-05-03 18:58:09 +00:00
|
|
|
if (!V || !BB) return Error("Invalid PHI record");
|
|
|
|
PN->addIncoming(V, BB);
|
|
|
|
}
|
|
|
|
I = PN;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
case bitc::FUNC_CODE_INST_LANDINGPAD: {
|
|
|
|
// LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
|
|
|
|
unsigned Idx = 0;
|
|
|
|
if (Record.size() < 4)
|
|
|
|
return Error("Invalid LANDINGPAD record");
|
|
|
|
Type *Ty = getTypeByID(Record[Idx++]);
|
|
|
|
if (!Ty) return Error("Invalid LANDINGPAD record");
|
|
|
|
Value *PersFn = 0;
|
|
|
|
if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
|
|
|
|
return Error("Invalid LANDINGPAD record");
|
|
|
|
|
|
|
|
bool IsCleanup = !!Record[Idx++];
|
|
|
|
unsigned NumClauses = Record[Idx++];
|
|
|
|
LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses);
|
|
|
|
LP->setCleanup(IsCleanup);
|
|
|
|
for (unsigned J = 0; J != NumClauses; ++J) {
|
|
|
|
LandingPadInst::ClauseType CT =
|
|
|
|
LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
|
|
|
|
Value *Val;
|
|
|
|
|
|
|
|
if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
|
|
|
|
delete LP;
|
|
|
|
return Error("Invalid LANDINGPAD record");
|
|
|
|
}
|
|
|
|
|
|
|
|
assert((CT != LandingPadInst::Catch ||
|
|
|
|
!isa<ArrayType>(Val->getType())) &&
|
|
|
|
"Catch clause has a invalid type!");
|
|
|
|
assert((CT != LandingPadInst::Filter ||
|
|
|
|
isa<ArrayType>(Val->getType())) &&
|
|
|
|
"Filter clause has invalid type!");
|
|
|
|
LP->addClause(Val);
|
|
|
|
}
|
|
|
|
|
|
|
|
I = LP;
|
2011-09-01 00:50:20 +00:00
|
|
|
InstructionList.push_back(I);
|
2011-08-12 20:24:12 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-05-28 01:38:28 +00:00
|
|
|
case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
|
2011-06-17 18:09:11 +00:00
|
|
|
if (Record.size() != 4)
|
2007-05-03 18:58:09 +00:00
|
|
|
return Error("Invalid ALLOCA record");
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *Ty =
|
2011-06-17 18:09:11 +00:00
|
|
|
dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[1]);
|
2011-06-17 18:09:11 +00:00
|
|
|
Value *Size = getFnValueByID(Record[2], OpTy);
|
|
|
|
unsigned Align = Record[3];
|
2007-05-03 18:58:09 +00:00
|
|
|
if (!Ty || !Size) return Error("Invalid ALLOCA record");
|
2009-07-15 23:53:25 +00:00
|
|
|
I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-03 18:58:09 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-03 22:04:19 +00:00
|
|
|
case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
|
2007-05-06 00:00:00 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
|
|
|
|
OpNum+2 != Record.size())
|
2007-05-06 00:21:25 +00:00
|
|
|
return Error("Invalid LOAD record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-03 22:04:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-08-09 23:02:53 +00:00
|
|
|
case bitc::FUNC_CODE_INST_LOADATOMIC: {
|
|
|
|
// LOADATOMIC: [opty, op, align, vol, ordering, synchscope]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
|
|
|
|
OpNum+4 != Record.size())
|
|
|
|
return Error("Invalid LOADATOMIC record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-08-09 23:02:53 +00:00
|
|
|
|
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
|
|
|
|
if (Ordering == NotAtomic || Ordering == Release ||
|
|
|
|
Ordering == AcquireRelease)
|
|
|
|
return Error("Invalid LOADATOMIC record");
|
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
|
|
|
return Error("Invalid LOADATOMIC record");
|
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
|
|
|
|
I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1,
|
|
|
|
Ordering, SynchScope);
|
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2011-06-17 18:17:37 +00:00
|
|
|
case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol]
|
2007-12-11 08:59:05 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Val, *Ptr;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2007-12-11 08:59:05 +00:00
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
|
|
|
|
OpNum+2 != Record.size())
|
|
|
|
return Error("Invalid STORE record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-12-11 08:59:05 +00:00
|
|
|
I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-12-11 08:59:05 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-08-09 23:02:53 +00:00
|
|
|
case bitc::FUNC_CODE_INST_STOREATOMIC: {
|
|
|
|
// STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Val, *Ptr;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2011-08-09 23:02:53 +00:00
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
|
|
|
|
OpNum+4 != Record.size())
|
|
|
|
return Error("Invalid STOREATOMIC record");
|
|
|
|
|
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
|
2011-09-19 19:41:28 +00:00
|
|
|
if (Ordering == NotAtomic || Ordering == Acquire ||
|
2011-08-09 23:02:53 +00:00
|
|
|
Ordering == AcquireRelease)
|
|
|
|
return Error("Invalid STOREATOMIC record");
|
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
|
|
|
return Error("Invalid STOREATOMIC record");
|
|
|
|
|
|
|
|
I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1,
|
|
|
|
Ordering, SynchScope);
|
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2011-07-28 21:48:00 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CMPXCHG: {
|
|
|
|
// CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Ptr, *Cmp, *New;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2011-07-28 21:48:00 +00:00
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(), Cmp) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2011-07-28 21:48:00 +00:00
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(), New) ||
|
|
|
|
OpNum+3 != Record.size())
|
|
|
|
return Error("Invalid CMPXCHG record");
|
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered)
|
2011-07-28 21:48:00 +00:00
|
|
|
return Error("Invalid CMPXCHG record");
|
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]);
|
|
|
|
I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope);
|
|
|
|
cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
|
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::FUNC_CODE_INST_ATOMICRMW: {
|
|
|
|
// ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Ptr, *Val;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo,
|
2011-07-28 21:48:00 +00:00
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
|
|
|
|
OpNum+4 != Record.size())
|
|
|
|
return Error("Invalid ATOMICRMW record");
|
|
|
|
AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]);
|
|
|
|
if (Operation < AtomicRMWInst::FIRST_BINOP ||
|
|
|
|
Operation > AtomicRMWInst::LAST_BINOP)
|
|
|
|
return Error("Invalid ATOMICRMW record");
|
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered)
|
2011-07-28 21:48:00 +00:00
|
|
|
return Error("Invalid ATOMICRMW record");
|
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope);
|
|
|
|
cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
|
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2011-07-25 23:16:38 +00:00
|
|
|
case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope]
|
|
|
|
if (2 != Record.size())
|
|
|
|
return Error("Invalid FENCE record");
|
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[0]);
|
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered ||
|
|
|
|
Ordering == Monotonic)
|
|
|
|
return Error("Invalid FENCE record");
|
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]);
|
|
|
|
I = new FenceInst(Context, Ordering, SynchScope);
|
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2011-06-17 18:17:37 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CALL: {
|
2007-11-27 13:23:08 +00:00
|
|
|
// CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
|
|
|
|
if (Record.size() < 3)
|
2007-05-03 22:04:19 +00:00
|
|
|
return Error("Invalid CALL record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet PAL = getAttributes(Record[0]);
|
2007-05-08 05:38:01 +00:00
|
|
|
unsigned CCInfo = Record[1];
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-08 05:38:01 +00:00
|
|
|
unsigned OpNum = 2;
|
2007-05-06 00:00:00 +00:00
|
|
|
Value *Callee;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
|
|
|
|
return Error("Invalid CALL record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
|
|
|
|
FunctionType *FTy = 0;
|
2007-05-03 22:04:19 +00:00
|
|
|
if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
|
2007-05-06 00:00:00 +00:00
|
|
|
if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
|
2007-05-03 22:04:19 +00:00
|
|
|
return Error("Invalid CALL record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-03 22:04:19 +00:00
|
|
|
SmallVector<Value*, 16> Args;
|
|
|
|
// Read the fixed params.
|
2007-05-06 00:00:00 +00:00
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (FTy->getParamType(i)->isLabelTy())
|
2007-11-05 21:20:28 +00:00
|
|
|
Args.push_back(getBasicBlock(Record[OpNum]));
|
2010-09-13 18:00:48 +00:00
|
|
|
else
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Args.push_back(getValue(Record, OpNum, NextValueNo,
|
|
|
|
FTy->getParamType(i)));
|
2007-05-03 22:04:19 +00:00
|
|
|
if (Args.back() == 0) return Error("Invalid CALL record");
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-03 22:04:19 +00:00
|
|
|
// Read type/value pairs for varargs params.
|
|
|
|
if (!FTy->isVarArg()) {
|
2007-05-06 00:00:00 +00:00
|
|
|
if (OpNum != Record.size())
|
2007-05-03 22:04:19 +00:00
|
|
|
return Error("Invalid CALL record");
|
|
|
|
} else {
|
2007-05-06 00:00:00 +00:00
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
|
|
|
return Error("Invalid CALL record");
|
|
|
|
Args.push_back(Op);
|
2007-05-03 22:04:19 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-15 08:37:34 +00:00
|
|
|
I = CallInst::Create(Callee, Args);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-09-02 08:44:58 +00:00
|
|
|
cast<CallInst>(I)->setCallingConv(
|
|
|
|
static_cast<CallingConv::ID>(CCInfo>>1));
|
2007-05-03 22:34:03 +00:00
|
|
|
cast<CallInst>(I)->setTailCall(CCInfo & 1);
|
2008-09-25 21:00:45 +00:00
|
|
|
cast<CallInst>(I)->setAttributes(PAL);
|
2007-05-03 22:04:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
|
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error("Invalid VAARG record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Op = getValue(Record, 1, NextValueNo, OpTy);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ResTy = getTypeByID(Record[2]);
|
2007-05-03 22:04:19 +00:00
|
|
|
if (!OpTy || !Op || !ResTy)
|
|
|
|
return Error("Invalid VAARG record");
|
|
|
|
I = new VAArgInst(Op, ResTy);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-03 22:04:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-01 07:01:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add instruction to end of current BB. If there is no current BB, reject
|
|
|
|
// this file.
|
|
|
|
if (CurBB == 0) {
|
|
|
|
delete I;
|
|
|
|
return Error("Invalid instruction with no BB");
|
|
|
|
}
|
|
|
|
CurBB->getInstList().push_back(I);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
// If this was a terminator instruction, move to the next block.
|
|
|
|
if (isa<TerminatorInst>(I)) {
|
|
|
|
++CurBBNo;
|
|
|
|
CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
|
2007-05-01 05:52:21 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
// Non-void values get registered in the value table for future use.
|
2010-01-05 13:12:22 +00:00
|
|
|
if (I && !I->getType()->isVoidTy())
|
2007-05-01 07:01:57 +00:00
|
|
|
ValueList.AssignValue(I, NextValueNo++);
|
2007-05-01 05:52:21 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
OutOfRecordLoop:
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
// Check the function list for unresolved values.
|
|
|
|
if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
|
|
|
|
if (A->getParent() == 0) {
|
|
|
|
// We found at least one unresolved value. Nuke them all to avoid leaks.
|
|
|
|
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
|
2010-08-25 20:20:21 +00:00
|
|
|
if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) {
|
2009-07-30 23:03:37 +00:00
|
|
|
A->replaceAllUsesWith(UndefValue::get(A->getType()));
|
2007-05-01 07:01:57 +00:00
|
|
|
delete A;
|
|
|
|
}
|
|
|
|
}
|
2007-05-04 03:50:29 +00:00
|
|
|
return Error("Never resolved value found in function!");
|
2007-05-01 07:01:57 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-08-25 20:23:38 +00:00
|
|
|
// FIXME: Check for unresolved forward-declared metadata references
|
|
|
|
// and clean up leaks.
|
|
|
|
|
2009-10-28 05:53:48 +00:00
|
|
|
// See if anything took the address of blocks in this function. If so,
|
|
|
|
// resolve them now.
|
|
|
|
DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI =
|
|
|
|
BlockAddrFwdRefs.find(F);
|
|
|
|
if (BAFRI != BlockAddrFwdRefs.end()) {
|
|
|
|
std::vector<BlockAddrRefTy> &RefList = BAFRI->second;
|
|
|
|
for (unsigned i = 0, e = RefList.size(); i != e; ++i) {
|
|
|
|
unsigned BlockIdx = RefList[i].first;
|
2009-11-01 01:27:45 +00:00
|
|
|
if (BlockIdx >= FunctionBBs.size())
|
2009-10-28 05:53:48 +00:00
|
|
|
return Error("Invalid blockaddress block #");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-10-28 05:53:48 +00:00
|
|
|
GlobalVariable *FwdRef = RefList[i].second;
|
2009-11-01 01:27:45 +00:00
|
|
|
FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx]));
|
2009-10-28 05:53:48 +00:00
|
|
|
FwdRef->eraseFromParent();
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-10-28 05:53:48 +00:00
|
|
|
BlockAddrFwdRefs.erase(BAFRI);
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
// Trim the value list down to the size it was before we parsed this function.
|
|
|
|
ValueList.shrinkTo(ModuleValueListSize);
|
2010-08-25 20:22:53 +00:00
|
|
|
MDValueList.shrinkTo(ModuleMDValueListSize);
|
2007-05-01 05:52:21 +00:00
|
|
|
std::vector<BasicBlock*>().swap(FunctionBBs);
|
2007-05-01 04:59:48 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
/// FindFunctionInStream - Find the function body in the bitcode stream
|
|
|
|
bool BitcodeReader::FindFunctionInStream(Function *F,
|
|
|
|
DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) {
|
|
|
|
while (DeferredFunctionInfoIterator->second == 0) {
|
|
|
|
if (Stream.AtEndOfStream())
|
|
|
|
return Error("Could not find Function in stream");
|
|
|
|
// ParseModule will parse the next body in the stream and set its
|
|
|
|
// position in the DeferredFunctionInfo map.
|
|
|
|
if (ParseModule(true)) return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-01-27 20:34:15 +00:00
|
|
|
// GVMaterializer implementation
|
2007-05-18 04:02:46 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
bool BitcodeReader::isMaterializable(const GlobalValue *GV) const {
|
|
|
|
if (const Function *F = dyn_cast<Function>(GV)) {
|
|
|
|
return F->isDeclaration() &&
|
|
|
|
DeferredFunctionInfo.count(const_cast<Function*>(F));
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) {
|
|
|
|
Function *F = dyn_cast<Function>(GV);
|
|
|
|
// If it's not a function or is already material, ignore the request.
|
|
|
|
if (!F || !F->isMaterializable()) return false;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
|
2007-05-18 04:02:46 +00:00
|
|
|
assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
|
2012-02-06 22:30:29 +00:00
|
|
|
// If its position is recorded as 0, its body is somewhere in the stream
|
|
|
|
// but we haven't seen it yet.
|
|
|
|
if (DFII->second == 0)
|
|
|
|
if (LazyStreamer && FindFunctionInStream(F, DFII)) return true;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
// Move the bit stream to the saved position of the deferred function body.
|
|
|
|
Stream.JumpToBit(DFII->second);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
if (ParseFunctionBody(F)) {
|
|
|
|
if (ErrInfo) *ErrInfo = ErrorString;
|
|
|
|
return true;
|
|
|
|
}
|
2007-08-04 01:51:18 +00:00
|
|
|
|
|
|
|
// Upgrade any old intrinsic calls in the function.
|
|
|
|
for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
|
|
|
|
E = UpgradedIntrinsics.end(); I != E; ++I) {
|
|
|
|
if (I->first != I->second) {
|
|
|
|
for (Value::use_iterator UI = I->first->use_begin(),
|
|
|
|
UE = I->first->use_end(); UI != UE; ) {
|
|
|
|
if (CallInst* CI = dyn_cast<CallInst>(*UI++))
|
|
|
|
UpgradeIntrinsicCall(CI, I->second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
bool BitcodeReader::isDematerializable(const GlobalValue *GV) const {
|
|
|
|
const Function *F = dyn_cast<Function>(GV);
|
|
|
|
if (!F || F->isDeclaration())
|
|
|
|
return false;
|
|
|
|
return DeferredFunctionInfo.count(const_cast<Function*>(F));
|
|
|
|
}
|
|
|
|
|
|
|
|
void BitcodeReader::Dematerialize(GlobalValue *GV) {
|
|
|
|
Function *F = dyn_cast<Function>(GV);
|
|
|
|
// If this function isn't dematerializable, this is a noop.
|
|
|
|
if (!F || !isDematerializable(F))
|
2007-05-18 04:02:46 +00:00
|
|
|
return;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
// Just forget the function body, we can remat it later.
|
|
|
|
F->deleteBody();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) {
|
|
|
|
assert(M == TheModule &&
|
|
|
|
"Can only Materialize the Module this BitcodeReader is attached to.");
|
2009-06-16 05:15:21 +00:00
|
|
|
// Iterate over the module, deserializing any functions that are still on
|
|
|
|
// disk.
|
|
|
|
for (Module::iterator F = TheModule->begin(), E = TheModule->end();
|
|
|
|
F != E; ++F)
|
2010-01-27 20:34:15 +00:00
|
|
|
if (F->isMaterializable() &&
|
|
|
|
Materialize(F, ErrInfo))
|
|
|
|
return true;
|
2007-08-04 01:51:18 +00:00
|
|
|
|
2012-02-29 00:07:09 +00:00
|
|
|
// At this point, if there are any function bodies, the current bit is
|
|
|
|
// pointing to the END_BLOCK record after them. Now make sure the rest
|
|
|
|
// of the bits in the module have been read.
|
|
|
|
if (NextUnreadBit)
|
|
|
|
ParseModule(true);
|
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
// Upgrade any intrinsic calls that slipped through (should not happen!) and
|
|
|
|
// delete the old functions to clean up. We can't do this unless the entire
|
|
|
|
// module is materialized because there could always be another function body
|
2007-08-04 01:51:18 +00:00
|
|
|
// with calls to the old function.
|
|
|
|
for (std::vector<std::pair<Function*, Function*> >::iterator I =
|
|
|
|
UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) {
|
|
|
|
if (I->first != I->second) {
|
|
|
|
for (Value::use_iterator UI = I->first->use_begin(),
|
|
|
|
UE = I->first->use_end(); UI != UE; ) {
|
|
|
|
if (CallInst* CI = dyn_cast<CallInst>(*UI++))
|
|
|
|
UpgradeIntrinsicCall(CI, I->second);
|
|
|
|
}
|
2009-04-01 01:43:03 +00:00
|
|
|
if (!I->first->use_empty())
|
|
|
|
I->first->replaceAllUsesWith(I->second);
|
2007-08-04 01:51:18 +00:00
|
|
|
I->first->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics);
|
2009-08-28 23:24:31 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
return false;
|
2007-05-18 04:02:46 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
bool BitcodeReader::InitStream() {
|
|
|
|
if (LazyStreamer) return InitLazyStream();
|
|
|
|
return InitStreamFromBuffer();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitcodeReader::InitStreamFromBuffer() {
|
2012-09-06 15:42:13 +00:00
|
|
|
const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart();
|
2012-02-06 22:30:29 +00:00
|
|
|
const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
|
|
|
|
|
|
|
|
if (Buffer->getBufferSize() & 3) {
|
|
|
|
if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd))
|
|
|
|
return Error("Invalid bitcode signature");
|
|
|
|
else
|
|
|
|
return Error("Bitcode stream should be a multiple of 4 bytes in length");
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we have a wrapper header, parse it and ignore the non-bc file contents.
|
|
|
|
// The magic number is 0x0B17C0DE stored in little endian.
|
|
|
|
if (isBitcodeWrapper(BufPtr, BufEnd))
|
|
|
|
if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
|
|
|
|
return Error("Invalid bitcode wrapper header");
|
|
|
|
|
|
|
|
StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
|
|
|
|
Stream.init(*StreamFile);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitcodeReader::InitLazyStream() {
|
|
|
|
// Check and strip off the bitcode wrapper; BitstreamReader expects never to
|
|
|
|
// see it.
|
|
|
|
StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer);
|
|
|
|
StreamFile.reset(new BitstreamReader(Bytes));
|
|
|
|
Stream.init(*StreamFile);
|
|
|
|
|
|
|
|
unsigned char buf[16];
|
2013-05-24 10:54:58 +00:00
|
|
|
if (Bytes->readBytes(0, 16, buf) == -1)
|
2012-02-06 22:30:29 +00:00
|
|
|
return Error("Bitcode stream must be at least 16 bytes in length");
|
|
|
|
|
|
|
|
if (!isBitcode(buf, buf + 16))
|
|
|
|
return Error("Invalid bitcode signature");
|
|
|
|
|
|
|
|
if (isBitcodeWrapper(buf, buf + 4)) {
|
|
|
|
const unsigned char *bitcodeStart = buf;
|
|
|
|
const unsigned char *bitcodeEnd = buf + 16;
|
|
|
|
SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
|
|
|
|
Bytes->dropLeadingBytes(bitcodeStart - buf);
|
|
|
|
Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2007-05-01 04:59:48 +00:00
|
|
|
|
2007-04-29 07:54:31 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// External interface
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
/// getLazyBitcodeModule - lazy function-at-a-time loading from a file.
|
2007-04-29 07:54:31 +00:00
|
|
|
///
|
2010-01-27 20:34:15 +00:00
|
|
|
Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
|
|
|
|
LLVMContext& Context,
|
|
|
|
std::string *ErrMsg) {
|
|
|
|
Module *M = new Module(Buffer->getBufferIdentifier(), Context);
|
2009-07-01 16:58:40 +00:00
|
|
|
BitcodeReader *R = new BitcodeReader(Buffer, Context);
|
2010-01-27 20:34:15 +00:00
|
|
|
M->setMaterializer(R);
|
|
|
|
if (R->ParseBitcodeInto(M)) {
|
2007-04-29 07:54:31 +00:00
|
|
|
if (ErrMsg)
|
|
|
|
*ErrMsg = R->getErrorString();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
delete M; // Also deletes R.
|
2007-04-29 07:54:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-01-27 20:34:15 +00:00
|
|
|
// Have the BitcodeReader dtor delete 'Buffer'.
|
|
|
|
R->setBufferOwned(true);
|
2012-01-02 07:49:53 +00:00
|
|
|
|
|
|
|
R->materializeForwardReferencedFunctions();
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
return M;
|
2007-04-29 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
Module *llvm::getStreamedBitcodeModule(const std::string &name,
|
|
|
|
DataStreamer *streamer,
|
|
|
|
LLVMContext &Context,
|
|
|
|
std::string *ErrMsg) {
|
|
|
|
Module *M = new Module(name, Context);
|
|
|
|
BitcodeReader *R = new BitcodeReader(streamer, Context);
|
|
|
|
M->setMaterializer(R);
|
|
|
|
if (R->ParseBitcodeInto(M)) {
|
|
|
|
if (ErrMsg)
|
|
|
|
*ErrMsg = R->getErrorString();
|
|
|
|
delete M; // Also deletes R.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
R->setBufferOwned(false); // no buffer to delete
|
|
|
|
return M;
|
|
|
|
}
|
|
|
|
|
2007-04-29 07:54:31 +00:00
|
|
|
/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
|
|
|
|
/// If an error occurs, return null and fill in *ErrMsg if non-null.
|
2009-09-20 02:20:51 +00:00
|
|
|
Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context,
|
2009-07-01 16:58:40 +00:00
|
|
|
std::string *ErrMsg){
|
2010-01-27 20:34:15 +00:00
|
|
|
Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg);
|
|
|
|
if (!M) return 0;
|
2007-05-18 04:02:46 +00:00
|
|
|
|
|
|
|
// Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
|
|
|
|
// there was an error.
|
2010-01-27 20:34:15 +00:00
|
|
|
static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
// Read in the entire module, and destroy the BitcodeReader.
|
|
|
|
if (M->MaterializeAllPermanently(ErrMsg)) {
|
|
|
|
delete M;
|
2010-10-06 01:22:42 +00:00
|
|
|
return 0;
|
2010-01-27 20:34:15 +00:00
|
|
|
}
|
2010-10-06 01:22:42 +00:00
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
// TODO: Restore the use-lists to the in-memory state when the bitcode was
|
|
|
|
// written. We must defer until the Module has been fully materialized.
|
|
|
|
|
2007-04-29 07:54:31 +00:00
|
|
|
return M;
|
|
|
|
}
|
2010-10-06 01:22:42 +00:00
|
|
|
|
|
|
|
std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer,
|
|
|
|
LLVMContext& Context,
|
|
|
|
std::string *ErrMsg) {
|
|
|
|
BitcodeReader *R = new BitcodeReader(Buffer, Context);
|
|
|
|
// Don't let the BitcodeReader dtor delete 'Buffer'.
|
|
|
|
R->setBufferOwned(false);
|
|
|
|
|
|
|
|
std::string Triple("");
|
|
|
|
if (R->ParseTriple(Triple))
|
|
|
|
if (ErrMsg)
|
|
|
|
*ErrMsg = R->getErrorString();
|
|
|
|
|
|
|
|
delete R;
|
|
|
|
return Triple;
|
|
|
|
}
|