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"
|
2013-07-26 04:16:55 +00:00
|
|
|
#include "llvm/Bitcode/LLVMBitCodes.h"
|
2014-03-05 10:34:14 +00:00
|
|
|
#include "llvm/IR/AutoUpgrade.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"
|
2013-09-28 00:22:27 +00:00
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#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;
|
2014-04-15 06:32:26 +00:00
|
|
|
Buffer = nullptr;
|
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;
|
2014-01-14 15:22:47 +00:00
|
|
|
case 5: return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage
|
|
|
|
case 6: return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage
|
2009-07-20 01:03:30 +00:00
|
|
|
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;
|
Remove the linker_private and linker_private_weak linkages.
These linkages were introduced some time ago, but it was never very
clear what exactly their semantics were or what they should be used
for. Some investigation found these uses:
* utf-16 strings in clang.
* non-unnamed_addr strings produced by the sanitizers.
It turns out they were just working around a more fundamental problem.
For some sections a MachO linker needs a symbol in order to split the
section into atoms, and llvm had no idea that was the case. I fixed
that in r201700 and it is now safe to use the private linkage. When
the object ends up in a section that requires symbols, llvm will use a
'l' prefix instead of a 'L' prefix and things just work.
With that, these linkages were already dead, but there was a potential
future user in the objc metadata information. I am still looking at
CGObjcMac.cpp, but at this point I am convinced that linker_private
and linker_private_weak are not what they need.
The objc uses are currently split in
* Regular symbols (no '\01' prefix). LLVM already directly provides
whatever semantics they need.
* Uses of a private name (start with "\01L" or "\01l") and private
linkage. We can drop the "\01L" and "\01l" prefixes as soon as llvm
agrees with clang on L being ok or not for a given section. I have two
patches in code review for this.
* Uses of private name and weak linkage.
The last case is the one that one could think would fit one of these
linkages. That is not the case. The semantics are
* the linker will merge these symbol by *name*.
* the linker will hide them in the final DSO.
Given that the merging is done by name, any of the private (or
internal) linkages would be a bad match. They allow llvm to rename the
symbols, and that is really not what we want. From the llvm point of
view, these objects should really be (linkonce|weak)(_odr)?.
For now, just keeping the "\01l" prefix is probably the best for these
symbols. If we one day want to have a more direct support in llvm,
IMHO what we should add is not a linkage, it is just a hidden_symbol
attribute. It would be applicable to multiple linkages. For example,
on weak it would produce the current behavior we have for objc
metadata. On internal, it would be equivalent to private (and we
should then remove private).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203866 91177308-0d34-0410-b5e6-96231b3b80d8
2014-03-13 23:18:37 +00:00
|
|
|
case 13:
|
|
|
|
return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage
|
|
|
|
case 14:
|
|
|
|
return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-14 15:22:47 +00:00
|
|
|
static GlobalValue::DLLStorageClassTypes
|
|
|
|
GetDecodedDLLStorageClass(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: // Map unknown values to default.
|
|
|
|
case 0: return GlobalValue::DefaultStorageClass;
|
|
|
|
case 1: return GlobalValue::DLLImportStorageClass;
|
|
|
|
case 2: return GlobalValue::DLLExportStorageClass;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2013-11-18 02:51:33 +00:00
|
|
|
case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-14 15:22:47 +00:00
|
|
|
static void UpgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
|
|
|
|
case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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];
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OldV) {
|
2009-03-31 22:55:09 +00:00
|
|
|
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]) {
|
2014-04-15 06:32:26 +00:00
|
|
|
assert((!Ty || Ty == V->getType()) && "Type mismatch in value table!");
|
2007-05-01 07:01:57 +00:00
|
|
|
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.
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!Ty) return nullptr;
|
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()) {
|
2014-03-09 03:16:01 +00:00
|
|
|
auto UI = Placeholder->user_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];
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OldV) {
|
2009-08-04 06:00:18 +00:00
|
|
|
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())
|
2014-04-15 06:32:26 +00:00
|
|
|
return nullptr;
|
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));
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseAttributeBlock() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-26 22:53:05 +00:00
|
|
|
if (!MAttributes.empty())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidMultipleBlocks);
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-04 03:30:17 +00:00
|
|
|
|
|
|
|
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-11-12 01:31:00 +00:00
|
|
|
// Returns Attribute::None on unrecognized codes.
|
|
|
|
static Attribute::AttrKind GetAttrFromCode(uint64_t Code) {
|
2013-07-26 04:16:55 +00:00
|
|
|
switch (Code) {
|
2013-11-12 01:31:00 +00:00
|
|
|
default:
|
|
|
|
return Attribute::None;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_ALIGNMENT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Alignment;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_ALWAYS_INLINE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::AlwaysInline;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_BUILTIN:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Builtin;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_BY_VAL:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::ByVal;
|
2013-12-19 02:14:12 +00:00
|
|
|
case bitc::ATTR_KIND_IN_ALLOCA:
|
|
|
|
return Attribute::InAlloca;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_COLD:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Cold;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_INLINE_HINT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::InlineHint;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_IN_REG:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::InReg;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_MIN_SIZE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::MinSize;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NAKED:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Naked;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NEST:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Nest;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_ALIAS:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoAlias;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_BUILTIN:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoBuiltin;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_CAPTURE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoCapture;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_DUPLICATE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoDuplicate;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoImplicitFloat;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_INLINE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoInline;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NON_LAZY_BIND:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NonLazyBind;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_RED_ZONE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoRedZone;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_RETURN:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoReturn;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_NO_UNWIND:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::NoUnwind;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::OptimizeForSize;
|
2013-08-23 11:53:55 +00:00
|
|
|
case bitc::ATTR_KIND_OPTIMIZE_NONE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::OptimizeNone;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_READ_NONE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::ReadNone;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_READ_ONLY:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::ReadOnly;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_RETURNED:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::Returned;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_RETURNS_TWICE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::ReturnsTwice;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_S_EXT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::SExt;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_STACK_ALIGNMENT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::StackAlignment;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::StackProtect;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT_REQ:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::StackProtectReq;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_STACK_PROTECT_STRONG:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::StackProtectStrong;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_STRUCT_RET:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::StructRet;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_SANITIZE_ADDRESS:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::SanitizeAddress;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_SANITIZE_THREAD:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::SanitizeThread;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_SANITIZE_MEMORY:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::SanitizeMemory;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_UW_TABLE:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::UWTable;
|
2013-07-26 04:16:55 +00:00
|
|
|
case bitc::ATTR_KIND_Z_EXT:
|
2013-11-12 01:31:00 +00:00
|
|
|
return Attribute::ZExt;
|
2013-07-26 04:16:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-12 01:31:00 +00:00
|
|
|
error_code BitcodeReader::ParseAttrKind(uint64_t Code,
|
|
|
|
Attribute::AttrKind *Kind) {
|
|
|
|
*Kind = GetAttrFromCode(Code);
|
|
|
|
if (*Kind == Attribute::None)
|
|
|
|
return Error(InvalidValue);
|
|
|
|
return error_code::success();
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseAttributeGroupBlock() {
|
2013-02-10 23:24:25 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2013-02-10 23:24:25 +00:00
|
|
|
|
|
|
|
if (!MAttributeGroups.empty())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidMultipleBlocks);
|
2013-02-10 23:24:25 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-02-10 23:24:25 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2013-02-10 23:24:25 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2013-02-10 23:24:25 +00:00
|
|
|
|
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;
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseAttrKind(Record[++i], &Kind))
|
|
|
|
return EC;
|
2013-07-26 04:16:55 +00:00
|
|
|
|
|
|
|
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;
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseAttrKind(Record[++i], &Kind))
|
|
|
|
return EC;
|
2013-07-26 04:16:55 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseTypeTableBody() {
|
2007-04-22 06:23:29 +00:00
|
|
|
if (!TypeList.empty())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidMultipleBlocks);
|
2007-04-22 06:23:29 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2007-04-22 06:23:29 +00:00
|
|
|
if (NumRecords != TypeList.size())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
|
|
|
return error_code::success();
|
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();
|
2014-04-15 06:32:26 +00:00
|
|
|
Type *ResultTy = nullptr;
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Stream.readRecord(Entry.ID, Record)) {
|
2013-11-04 16:16:24 +00:00
|
|
|
default:
|
|
|
|
return Error(InvalidValue);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!ResultTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
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 = 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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2012-05-23 15:19:39 +00:00
|
|
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!ResultTy || ArgTys.size() < Record.size()-3)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
2012-05-23 15:19:39 +00:00
|
|
|
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!ResultTy || ArgTys.size() < Record.size()-2)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
2011-11-03 00:14:01 +00:00
|
|
|
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
|
|
continue;
|
|
|
|
|
|
|
|
case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
|
|
|
|
if (Record.size() < 1)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTYPETable);
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
TypeList[NumRecords] = nullptr;
|
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
|
|
|
} 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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
|
|
Res->setBody(EltTys, Record[0]);
|
|
|
|
ResultTy = Res;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
|
|
|
|
if (Record.size() != 1)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTYPETable);
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
TypeList[NumRecords] = nullptr;
|
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
|
|
|
} 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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
|
|
|
|
if (Record.size() < 2)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidType);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTYPETable);
|
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
|
|
|
assert(ResultTy && "Didn't read a type?");
|
2014-04-15 06:32:26 +00:00
|
|
|
assert(!TypeList[NumRecords] && "Already read type?");
|
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[NumRecords++] = ResultTy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseValueSymbolTable() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-23 21:26:05 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-23 21:26:05 +00:00
|
|
|
unsigned ValueID = Record[0];
|
2014-03-27 12:08:23 +00:00
|
|
|
if (ValueID >= ValueList.size() || !ValueList[ValueID])
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-23 21:26:05 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-03 22:18:21 +00:00
|
|
|
BasicBlock *BB = getBasicBlock(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!BB)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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) {
|
2014-03-27 12:08:23 +00:00
|
|
|
MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i]));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!MD)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
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
|
2014-04-15 06:32:26 +00:00
|
|
|
Elts.push_back(nullptr);
|
2009-07-23 01:07:34 +00:00
|
|
|
}
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(ConflictingMETADATA_KINDRecords);
|
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.
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ResolveGlobalAndAliasInits() {
|
2007-04-26 02:46:40 +00:00
|
|
|
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 {
|
2014-03-27 12:08:23 +00:00
|
|
|
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
|
2007-04-26 02:46:40 +00:00
|
|
|
GlobalInitWorklist.back().first->setInitializer(C);
|
|
|
|
else
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(ExpectedConstant);
|
2007-04-26 02:46:40 +00:00
|
|
|
}
|
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 {
|
2014-03-27 12:08:23 +00:00
|
|
|
if (Constant *C = dyn_cast_or_null<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
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(ExpectedConstant);
|
2007-04-26 02:46:40 +00:00
|
|
|
}
|
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 {
|
2014-03-27 12:08:23 +00:00
|
|
|
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
|
2013-09-16 01:08:15 +00:00
|
|
|
FunctionPrefixWorklist.back().first->setPrefixData(C);
|
|
|
|
else
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(ExpectedConstant);
|
2013-09-16 01:08:15 +00:00
|
|
|
}
|
|
|
|
FunctionPrefixWorklist.pop_back();
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2007-04-26 02:46:40 +00:00
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseConstants() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-24 03:30:34 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
if (NextCstNo != ValueList.size())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidConstantReference);
|
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();
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2013-01-20 02:13:19 +00:00
|
|
|
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();
|
2014-04-15 06:32:26 +00:00
|
|
|
Value *V = nullptr;
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2014-03-27 12:08:23 +00:00
|
|
|
if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-24 03:30:34 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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 {
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
2012-01-30 00:51:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!OpTy)
|
|
|
|
return Error(InvalidRecord);
|
2007-04-24 18:15:21 +00:00
|
|
|
Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
|
2013-11-15 01:34:59 +00:00
|
|
|
V = UpgradeBitCastExpr(Opc, Op, CurTy);
|
|
|
|
if (!V) 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]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() & 1)
|
|
|
|
return Error(InvalidRecord);
|
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]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!ElTy)
|
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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#]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error(InvalidRecord);
|
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]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error(InvalidRecord);
|
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]));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Record.size() < 3 || !OpTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Record.size() < 3 || !OpTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Record.size() < 4 || !RTy || !OpTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-02-12 21:28:33 +00:00
|
|
|
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]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 4)
|
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-24 07:07:11 +00:00
|
|
|
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: {
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 2)
|
|
|
|
return Error(InvalidRecord);
|
2007-05-06 01:58:20 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-06 01:58:20 +00:00
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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: {
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 2)
|
|
|
|
return Error(InvalidRecord);
|
2012-09-05 00:56:20 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2012-09-05 00:56:20 +00:00
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2012-09-05 00:56: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];
|
|
|
|
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:{
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FnTy = getTypeByID(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!FnTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-10-28 05:53:48 +00:00
|
|
|
Function *Fn =
|
|
|
|
dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!Fn)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
2012-09-21 14:34:31 +00:00
|
|
|
++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,
|
2014-04-15 06:32:26 +00:00
|
|
|
nullptr, "");
|
2012-09-21 14:34:31 +00:00
|
|
|
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
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseUseLists() {
|
2011-12-07 21:44:12 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-12-07 21:44:12 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-12-07 21:44:12 +00:00
|
|
|
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.
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::RememberAndSkipFunctionBody() {
|
2007-05-01 04:59:48 +00:00
|
|
|
// Get the function we are talking about.
|
|
|
|
if (FunctionsWithBodies.empty())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InsufficientFunctionProtos);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
|
|
|
return error_code::success();
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::GlobalCleanup() {
|
2012-02-06 22:30:29 +00:00
|
|
|
// Patch the initializers for globals and aliases up.
|
|
|
|
ResolveGlobalAndAliasInits();
|
|
|
|
if (!GlobalInits.empty() || !AliasInits.empty())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedGlobalInitializerSet);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
// 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);
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseModule(bool Resume) {
|
2012-02-06 22:30:29 +00:00
|
|
|
if (Resume)
|
|
|
|
Stream.JumpToBit(NextUnreadBit);
|
|
|
|
else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2007-05-05 18:57:30 +00:00
|
|
|
case bitc::BLOCKINFO_BLOCK_ID:
|
|
|
|
if (Stream.ReadBlockInfoBlock())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2007-05-05 18:57:30 +00:00
|
|
|
break;
|
2007-05-04 03:30:17 +00:00
|
|
|
case bitc::PARAMATTR_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseAttributeBlock())
|
|
|
|
return EC;
|
2007-05-04 03:30:17 +00:00
|
|
|
break;
|
2013-02-10 23:24:25 +00:00
|
|
|
case bitc::PARAMATTR_GROUP_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseAttributeGroupBlock())
|
|
|
|
return EC;
|
2013-02-10 23:24:25 +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_BLOCK_ID_NEW:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseTypeTable())
|
|
|
|
return EC;
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2007-04-23 21:26:05 +00:00
|
|
|
case bitc::VALUE_SYMTAB_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseValueSymbolTable())
|
|
|
|
return EC;
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseConstants())
|
|
|
|
return EC;
|
|
|
|
if (error_code EC = ResolveGlobalAndAliasInits())
|
|
|
|
return EC;
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
2009-07-22 17:43:22 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseMetadata())
|
|
|
|
return EC;
|
2009-07-22 17:43:22 +00:00
|
|
|
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());
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = GlobalCleanup())
|
|
|
|
return EC;
|
2012-02-06 22:30:29 +00:00
|
|
|
SeenFirstFunctionBody = true;
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = RememberAndSkipFunctionBody())
|
|
|
|
return EC;
|
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();
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
2007-05-01 04:59:48 +00:00
|
|
|
break;
|
2011-12-07 21:44:12 +00:00
|
|
|
case bitc::USELIST_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseUseLists())
|
|
|
|
return EC;
|
2011-12-07 21:44:12 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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) {
|
2013-11-04 16:16:24 +00:00
|
|
|
default:
|
|
|
|
return Error(InvalidValue);
|
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 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2012-11-28 08:41:48 +00:00
|
|
|
// 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-22 06:23:29 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2008-08-17 18:44:35 +00:00
|
|
|
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,
|
2014-01-14 15:22:47 +00:00
|
|
|
// unnamed_addr, dllstorageclass]
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
2007-04-22 06:23:29 +00:00
|
|
|
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 =
|
2014-04-15 06:32:26 +00:00
|
|
|
new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr,
|
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
|
|
|
|
2014-01-14 15:22:47 +00:00
|
|
|
if (Record.size() > 10)
|
|
|
|
NewGV->setDLLStorageClass(GetDecodedDLLStorageClass(Record[10]));
|
|
|
|
else
|
|
|
|
UpgradeDLLImportExportLinkage(NewGV, Record[3]);
|
|
|
|
|
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,
|
2014-01-14 15:22:47 +00:00
|
|
|
// alignment, section, visibility, gc, unnamed_addr,
|
|
|
|
// dllstorageclass]
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
2007-04-22 06:23:29 +00:00
|
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
2008-08-17 18:44:35 +00:00
|
|
|
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));
|
2014-01-14 15:22:47 +00:00
|
|
|
|
|
|
|
if (Record.size() > 11)
|
|
|
|
Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11]));
|
|
|
|
else
|
|
|
|
UpgradeDLLImportExportLinkage(Func, Record[3]);
|
|
|
|
|
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]
|
2014-01-14 15:22:47 +00:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass]
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
|
2014-04-15 06:32:26 +00:00
|
|
|
"", nullptr, 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]));
|
2014-01-14 15:22:47 +00:00
|
|
|
if (Record.size() > 4)
|
|
|
|
NewGA->setDLLStorageClass(GetDecodedDLLStorageClass(Record[4]));
|
|
|
|
else
|
|
|
|
UpgradeDLLImportExportLinkage(NewGA, Record[2]);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-04-26 03:27:58 +00:00
|
|
|
ValueList.shrinkTo(Record[0]);
|
|
|
|
break;
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseBitcodeInto(Module *M) {
|
2014-04-15 06:32:26 +00:00
|
|
|
TheModule = nullptr;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = InitStream())
|
|
|
|
return EC;
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidBitcodeSignature);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
break;
|
|
|
|
case bitc::MODULE_BLOCK_ID:
|
|
|
|
// Reject multiple MODULE_BLOCK's in a single bitstream.
|
|
|
|
if (TheModule)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidMultipleBlocks);
|
2013-01-20 02:13:19 +00:00
|
|
|
TheModule = M;
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseModule(false))
|
|
|
|
return EC;
|
|
|
|
if (LazyStreamer)
|
|
|
|
return error_code::success();
|
2013-01-20 02:13:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (Stream.SkipBlock())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2013-01-20 02:13:19 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-05-26 18:59:54 +00:00
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-29 07:54:31 +00:00
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseModuleTriple(std::string &Triple) {
|
2010-10-06 01:22:42 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2010-10-06 01:22:42 +00:00
|
|
|
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2010-10-06 01:22:42 +00:00
|
|
|
Triple = S;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseTriple(std::string &Triple) {
|
|
|
|
if (error_code EC = InitStream())
|
|
|
|
return EC;
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidBitcodeSignature);
|
2010-10-06 01:22:42 +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) {
|
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
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.
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error(MalformedBlock);
|
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.
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseMetadataAttachment() {
|
2009-09-18 19:26:43 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2013-01-20 02:13:19 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
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));
|
2013-09-28 00:22:27 +00:00
|
|
|
if (I->second == LLVMContext::MD_tbaa)
|
|
|
|
InstsWithTBAATag.push_back(Inst);
|
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.
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::ParseFunctionBody(Function *F) {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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();
|
2014-04-15 06:32:26 +00:00
|
|
|
BasicBlock *CurBB = nullptr;
|
2007-05-02 04:27:25 +00:00
|
|
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(MalformedBlock);
|
2013-01-20 02:13:19 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-01 05:52:21 +00:00
|
|
|
break;
|
|
|
|
case bitc::CONSTANTS_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseConstants())
|
|
|
|
return EC;
|
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:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseValueSymbolTable())
|
|
|
|
return EC;
|
2007-05-01 05:52:21 +00:00
|
|
|
break;
|
2009-09-18 19:26:43 +00:00
|
|
|
case bitc::METADATA_ATTACHMENT_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseMetadataAttachment())
|
|
|
|
return EC;
|
2009-09-20 02:20:51 +00:00
|
|
|
break;
|
2010-01-13 19:34:08 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = ParseMetadata())
|
|
|
|
return EC;
|
2010-01-13 19:34:08 +00:00
|
|
|
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();
|
2014-04-15 06:32:26 +00:00
|
|
|
Instruction *I = nullptr;
|
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
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidValue);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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.
|
2014-04-15 06:32:26 +00:00
|
|
|
I = nullptr;
|
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
|
|
|
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!I)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2010-04-03 02:17:50 +00:00
|
|
|
I->setDebugLoc(LastLoc);
|
2014-04-15 06:32:26 +00:00
|
|
|
I = nullptr;
|
2010-04-03 02:17:50 +00:00
|
|
|
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]
|
2014-04-15 06:32:26 +00:00
|
|
|
I = nullptr; // Get the last instruction emitted.
|
2010-04-03 02:17:50 +00:00
|
|
|
if (CurBB && !CurBB->empty())
|
|
|
|
I = &CurBB->back();
|
|
|
|
else if (CurBBNo && FunctionBBs[CurBBNo-1] &&
|
|
|
|
!FunctionBBs[CurBBNo-1]->empty())
|
|
|
|
I = &FunctionBBs[CurBBNo-1]->back();
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!I || Record.size() < 4)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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
|
|
|
|
2014-04-15 06:32:26 +00:00
|
|
|
MDNode *Scope = nullptr, *IA = nullptr;
|
2010-04-03 02:17:50 +00:00
|
|
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
I = nullptr;
|
2010-04-03 02:17:50 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-20 21:19:07 +00:00
|
|
|
int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Opc == -1)
|
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Opc == -1 || !ResTy)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2014-04-15 06:32:26 +00:00
|
|
|
Instruction *Temp = nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
|
|
|
|
if (Temp) {
|
|
|
|
InstructionList.push_back(Temp);
|
|
|
|
CurBB->getInstList().push_back(Temp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:16:49 +00:00
|
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2008-05-23 01:55:30 +00:00
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidValue);
|
2008-05-31 00:58:22 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2008-05-23 01:55:30 +00:00
|
|
|
Value *Val;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2008-05-23 01:55:30 +00:00
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidValue);
|
2008-05-31 00:58:22 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
2008-09-09 01:02:47 +00:00
|
|
|
} else {
|
|
|
|
// expect i1
|
2009-09-20 02:20:51 +00:00
|
|
|
if (Cond->getType() != Type::getInt1Ty(Context))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidTypeForValue);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-06 00:21:25 +00:00
|
|
|
|
2008-11-10 04:46:22 +00:00
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:16:49 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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;
|
2014-04-15 06:32:26 +00:00
|
|
|
Value *Op = nullptr;
|
2011-06-17 18:09:11 +00:00
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-06-17 18:09:11 +00:00
|
|
|
if (OpNum != Record.size())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:46:45 +00:00
|
|
|
BasicBlock *TrueDest = getBasicBlock(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!TrueDest)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:46:45 +00:00
|
|
|
|
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));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!FalseDest || !Cond)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Cond || !Default)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2012-05-12 10:48:17 +00:00
|
|
|
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Cond || !Default)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:46:45 +00:00
|
|
|
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]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!CaseVal || !DestBB) {
|
2007-05-02 05:46:45 +00:00
|
|
|
delete SI;
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Address)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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;
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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, ...]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 4)
|
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
|
2014-04-15 06:32:26 +00:00
|
|
|
FunctionType *FTy = !CalleeTy ? nullptr :
|
2007-05-02 05:46:45 +00:00
|
|
|
dyn_cast<FunctionType>(CalleeTy->getElementType());
|
|
|
|
|
|
|
|
// Check that the right number of fixed parameters are here.
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!FTy || !NormalBB || !UnwindBB ||
|
2007-05-06 00:00:00 +00:00
|
|
|
Record.size() < OpNum+FTy->getNumParams())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!Ops.back())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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;
|
2014-04-15 06:32:26 +00:00
|
|
|
Value *Val = nullptr;
|
2011-07-31 06:30:59 +00:00
|
|
|
if (getValueTypePair(Record, Idx, NextValueNo, Val))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-31 06:30:59 +00:00
|
|
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
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]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!V || !BB)
|
|
|
|
return Error(InvalidRecord);
|
2007-05-03 18:58:09 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-12 20:24:12 +00:00
|
|
|
Type *Ty = getTypeByID(Record[Idx++]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
|
|
|
return Error(InvalidRecord);
|
2014-04-15 06:32:26 +00:00
|
|
|
Value *PersFn = nullptr;
|
2011-08-12 20:24:12 +00:00
|
|
|
if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-12 20:24:12 +00:00
|
|
|
|
|
|
|
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;
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-12 20:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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];
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty || !Size)
|
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-09 23:02:53 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-09 23:02:53 +00:00
|
|
|
|
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-09 23:02:53 +00:00
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-08-09 23:02:53 +00:00
|
|
|
|
|
|
|
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: {
|
2014-03-11 10:48:52 +00:00
|
|
|
// CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, synchscope,
|
|
|
|
// failureordering]
|
2011-07-28 21:48:00 +00:00
|
|
|
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) ||
|
2014-03-11 10:48:52 +00:00
|
|
|
(OpNum + 3 != Record.size() && OpNum + 4 != Record.size()))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2014-03-11 10:48:52 +00:00
|
|
|
AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]);
|
|
|
|
if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-28 21:48:00 +00:00
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]);
|
2014-03-11 10:48:52 +00:00
|
|
|
|
|
|
|
AtomicOrdering FailureOrdering;
|
|
|
|
if (Record.size() < 7)
|
|
|
|
FailureOrdering =
|
|
|
|
AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering);
|
|
|
|
else
|
|
|
|
FailureOrdering = GetDecodedOrdering(Record[OpNum+3]);
|
|
|
|
|
|
|
|
I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering,
|
|
|
|
SynchScope);
|
2011-07-28 21:48:00 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-28 21:48:00 +00:00
|
|
|
AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]);
|
|
|
|
if (Operation < AtomicRMWInst::FIRST_BINOP ||
|
|
|
|
Operation > AtomicRMWInst::LAST_BINOP)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-28 21:48:00 +00:00
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-28 21:48:00 +00:00
|
|
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-25 23:16:38 +00:00
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[0]);
|
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered ||
|
|
|
|
Ordering == Monotonic)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2011-07-25 23:16:38 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
|
2014-04-15 06:32:26 +00:00
|
|
|
FunctionType *FTy = nullptr;
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!Args.back())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-03 22:04:19 +00:00
|
|
|
}
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-03 22:04:19 +00:00
|
|
|
} else {
|
2007-05-06 00:00:00 +00:00
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-06 00:00:00 +00:00
|
|
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidRecord);
|
2007-05-03 22:04:19 +00:00
|
|
|
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.
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!CurBB) {
|
2007-05-01 07:01:57 +00:00
|
|
|
delete I;
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidInstructionWithNoBB);
|
2007-05-01 07:01:57 +00:00
|
|
|
}
|
|
|
|
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;
|
2014-04-15 06:32:26 +00:00
|
|
|
CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
|
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())) {
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!A->getParent()) {
|
2007-05-01 07:01:57 +00:00
|
|
|
// We found at least one unresolved value. Nuke them all to avoid leaks.
|
|
|
|
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
|
2014-04-15 06:32:26 +00:00
|
|
|
if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
|
2009-07-30 23:03:37 +00:00
|
|
|
A->replaceAllUsesWith(UndefValue::get(A->getType()));
|
2007-05-01 07:01:57 +00:00
|
|
|
delete A;
|
|
|
|
}
|
|
|
|
}
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(NeverResolvedValueFoundInFunction);
|
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())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidID);
|
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);
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
|
|
|
|
2013-11-05 17:16:08 +00:00
|
|
|
/// Find the function body in the bitcode stream
|
|
|
|
error_code BitcodeReader::FindFunctionInStream(Function *F,
|
2012-02-06 22:30:29 +00:00
|
|
|
DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) {
|
|
|
|
while (DeferredFunctionInfoIterator->second == 0) {
|
|
|
|
if (Stream.AtEndOfStream())
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(CouldNotFindFunctionInStream);
|
2012-02-06 22:30:29 +00:00
|
|
|
// ParseModule will parse the next body in the stream and set its
|
|
|
|
// position in the DeferredFunctionInfo map.
|
2013-11-05 17:16:08 +00:00
|
|
|
if (error_code EC = ParseModule(true))
|
|
|
|
return EC;
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
2013-11-05 17:16:08 +00:00
|
|
|
return error_code::success();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-11-05 19:36:34 +00:00
|
|
|
error_code BitcodeReader::Materialize(GlobalValue *GV) {
|
2010-01-27 20:34:15 +00:00
|
|
|
Function *F = dyn_cast<Function>(GV);
|
|
|
|
// If it's not a function or is already material, ignore the request.
|
2013-11-05 19:36:34 +00:00
|
|
|
if (!F || !F->isMaterializable())
|
|
|
|
return error_code::success();
|
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.
|
2013-11-05 19:36:34 +00:00
|
|
|
if (DFII->second == 0 && LazyStreamer)
|
|
|
|
if (error_code EC = FindFunctionInStream(F, DFII))
|
|
|
|
return EC;
|
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
|
|
|
|
2013-11-05 19:36:34 +00:00
|
|
|
if (error_code EC = ParseFunctionBody(F))
|
|
|
|
return EC;
|
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) {
|
2014-03-09 03:16:01 +00:00
|
|
|
for (auto UI = I->first->user_begin(), UE = I->first->user_end();
|
|
|
|
UI != UE;) {
|
2007-08-04 01:51:18 +00:00
|
|
|
if (CallInst* CI = dyn_cast<CallInst>(*UI++))
|
|
|
|
UpgradeIntrinsicCall(CI, I->second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-11-05 19:36:34 +00:00
|
|
|
return error_code::success();
|
2007-05-18 04:02:46 +00:00
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-05 19:36:34 +00:00
|
|
|
error_code BitcodeReader::MaterializeModule(Module *M) {
|
2010-01-27 20:34:15 +00:00
|
|
|
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();
|
2013-11-05 19:36:34 +00:00
|
|
|
F != E; ++F) {
|
|
|
|
if (F->isMaterializable()) {
|
|
|
|
if (error_code EC = Materialize(F))
|
|
|
|
return EC;
|
|
|
|
}
|
|
|
|
}
|
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) {
|
2014-03-09 03:16:01 +00:00
|
|
|
for (auto UI = I->first->user_begin(), UE = I->first->user_end();
|
|
|
|
UI != UE;) {
|
2007-08-04 01:51:18 +00:00
|
|
|
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
|
|
|
|
2013-09-28 00:22:27 +00:00
|
|
|
for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
|
|
|
|
UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
|
|
|
|
|
2013-12-02 21:29:56 +00:00
|
|
|
UpgradeDebugInfo(*M);
|
2013-11-05 19:36:34 +00:00
|
|
|
return error_code::success();
|
2007-05-18 04:02:46 +00:00
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::InitStream() {
|
|
|
|
if (LazyStreamer)
|
|
|
|
return InitLazyStream();
|
2012-02-06 22:30:29 +00:00
|
|
|
return InitStreamFromBuffer();
|
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidBitcodeSignature);
|
2012-02-06 22:30:29 +00:00
|
|
|
else
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(BitcodeStreamInvalidSize);
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidBitcodeWrapperHeader);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
|
|
|
|
Stream.init(*StreamFile);
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
2013-11-04 16:16:24 +00:00
|
|
|
error_code BitcodeReader::InitLazyStream() {
|
2012-02-06 22:30:29 +00:00
|
|
|
// 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)
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(BitcodeStreamInvalidSize);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
if (!isBitcode(buf, buf + 16))
|
2013-11-04 16:16:24 +00:00
|
|
|
return Error(InvalidBitcodeSignature);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2013-11-04 16:16:24 +00:00
|
|
|
return error_code::success();
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
2014-03-15 04:05:59 +00:00
|
|
|
class BitcodeErrorCategoryType : public error_category {
|
2014-03-02 09:09:27 +00:00
|
|
|
const char *name() const override {
|
2013-11-04 16:16:24 +00:00
|
|
|
return "llvm.bitcode";
|
|
|
|
}
|
2014-03-02 09:09:27 +00:00
|
|
|
std::string message(int IE) const override {
|
2013-11-04 16:16:24 +00:00
|
|
|
BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE);
|
|
|
|
switch (E) {
|
|
|
|
case BitcodeReader::BitcodeStreamInvalidSize:
|
|
|
|
return "Bitcode stream length should be >= 16 bytes and a multiple of 4";
|
|
|
|
case BitcodeReader::ConflictingMETADATA_KINDRecords:
|
|
|
|
return "Conflicting METADATA_KIND records";
|
|
|
|
case BitcodeReader::CouldNotFindFunctionInStream:
|
|
|
|
return "Could not find function in stream";
|
|
|
|
case BitcodeReader::ExpectedConstant:
|
|
|
|
return "Expected a constant";
|
|
|
|
case BitcodeReader::InsufficientFunctionProtos:
|
|
|
|
return "Insufficient function protos";
|
|
|
|
case BitcodeReader::InvalidBitcodeSignature:
|
|
|
|
return "Invalid bitcode signature";
|
|
|
|
case BitcodeReader::InvalidBitcodeWrapperHeader:
|
|
|
|
return "Invalid bitcode wrapper header";
|
|
|
|
case BitcodeReader::InvalidConstantReference:
|
|
|
|
return "Invalid ronstant reference";
|
|
|
|
case BitcodeReader::InvalidID:
|
|
|
|
return "Invalid ID";
|
|
|
|
case BitcodeReader::InvalidInstructionWithNoBB:
|
|
|
|
return "Invalid instruction with no BB";
|
|
|
|
case BitcodeReader::InvalidRecord:
|
|
|
|
return "Invalid record";
|
|
|
|
case BitcodeReader::InvalidTypeForValue:
|
|
|
|
return "Invalid type for value";
|
|
|
|
case BitcodeReader::InvalidTYPETable:
|
|
|
|
return "Invalid TYPE table";
|
|
|
|
case BitcodeReader::InvalidType:
|
|
|
|
return "Invalid type";
|
|
|
|
case BitcodeReader::MalformedBlock:
|
|
|
|
return "Malformed block";
|
|
|
|
case BitcodeReader::MalformedGlobalInitializerSet:
|
|
|
|
return "Malformed global initializer set";
|
|
|
|
case BitcodeReader::InvalidMultipleBlocks:
|
|
|
|
return "Invalid multiple blocks";
|
|
|
|
case BitcodeReader::NeverResolvedValueFoundInFunction:
|
|
|
|
return "Never resolved value found in function";
|
|
|
|
case BitcodeReader::InvalidValue:
|
|
|
|
return "Invalid value";
|
|
|
|
}
|
2013-11-05 13:45:09 +00:00
|
|
|
llvm_unreachable("Unknown error type!");
|
2013-11-04 16:16:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
const error_category &BitcodeReader::BitcodeErrorCategory() {
|
|
|
|
static BitcodeErrorCategoryType O;
|
|
|
|
return O;
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
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
|
|
|
///
|
2014-01-13 18:31:04 +00:00
|
|
|
ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
|
|
|
|
LLVMContext &Context) {
|
2010-01-27 20:34:15 +00:00
|
|
|
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);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = R->ParseBitcodeInto(M)) {
|
2010-01-27 20:34:15 +00:00
|
|
|
delete M; // Also deletes R.
|
2014-01-13 18:31:04 +00:00
|
|
|
return EC;
|
2007-04-29 07:54:31 +00:00
|
|
|
}
|
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);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = R->ParseBitcodeInto(M)) {
|
2012-02-06 22:30:29 +00:00
|
|
|
if (ErrMsg)
|
2013-11-04 16:16:24 +00:00
|
|
|
*ErrMsg = EC.message();
|
2012-02-06 22:30:29 +00:00
|
|
|
delete M; // Also deletes R.
|
2014-04-15 06:32:26 +00:00
|
|
|
return nullptr;
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
R->setBufferOwned(false); // no buffer to delete
|
|
|
|
return M;
|
|
|
|
}
|
|
|
|
|
2014-01-15 01:08:23 +00:00
|
|
|
ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer,
|
|
|
|
LLVMContext &Context) {
|
2014-01-13 18:31:04 +00:00
|
|
|
ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context);
|
2014-01-15 01:08:23 +00:00
|
|
|
if (!ModuleOrErr)
|
|
|
|
return ModuleOrErr;
|
2014-01-13 18:31:04 +00:00
|
|
|
Module *M = ModuleOrErr.get();
|
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.
|
2014-01-14 23:51:27 +00:00
|
|
|
if (error_code EC = M->materializeAllPermanently()) {
|
2010-01-27 20:34:15 +00:00
|
|
|
delete M;
|
2014-01-15 01:08:23 +00:00
|
|
|
return EC;
|
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("");
|
2013-11-04 16:16:24 +00:00
|
|
|
if (error_code EC = R->ParseTriple(Triple))
|
2010-10-06 01:22:42 +00:00
|
|
|
if (ErrMsg)
|
2013-11-04 16:16:24 +00:00
|
|
|
*ErrMsg = EC.message();
|
2010-10-06 01:22:42 +00:00
|
|
|
|
|
|
|
delete R;
|
|
|
|
return Triple;
|
|
|
|
}
|