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"
|
2015-03-01 21:28:53 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2015-01-20 05:58:07 +00:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2015-03-17 20:40:24 +00:00
|
|
|
#include "llvm/Bitcode/BitstreamReader.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"
|
2015-03-30 21:36:43 +00:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2015-02-02 18:53:21 +00:00
|
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2015-01-10 00:07:30 +00:00
|
|
|
#include "llvm/IR/DiagnosticPrinter.h"
|
2015-03-17 20:40:24 +00:00
|
|
|
#include "llvm/IR/GVMaterializer.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#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"
|
2015-03-17 20:40:24 +00:00
|
|
|
#include "llvm/IR/ValueHandle.h"
|
2012-02-06 22:30:29 +00:00
|
|
|
#include "llvm/Support/DataStream.h"
|
2015-01-14 11:23:27 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.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"
|
2015-03-17 20:40:24 +00:00
|
|
|
#include <deque>
|
2007-04-22 06:23:29 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2015-03-17 20:40:24 +00:00
|
|
|
namespace {
|
2012-05-12 10:48:17 +00:00
|
|
|
enum {
|
|
|
|
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
|
|
|
|
};
|
|
|
|
|
2015-03-17 20:40:24 +00:00
|
|
|
class BitcodeReaderValueList {
|
|
|
|
std::vector<WeakVH> ValuePtrs;
|
|
|
|
|
|
|
|
/// ResolveConstants - As we resolve forward-referenced constants, we add
|
|
|
|
/// information about them to this vector. This allows us to resolve them in
|
|
|
|
/// bulk instead of resolving each reference at a time. See the code in
|
|
|
|
/// ResolveConstantForwardRefs for more information about this.
|
|
|
|
///
|
|
|
|
/// The key of this vector is the placeholder constant, the value is the slot
|
|
|
|
/// number that holds the resolved value.
|
|
|
|
typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy;
|
|
|
|
ResolveConstantsTy ResolveConstants;
|
|
|
|
LLVMContext &Context;
|
|
|
|
public:
|
|
|
|
BitcodeReaderValueList(LLVMContext &C) : Context(C) {}
|
|
|
|
~BitcodeReaderValueList() {
|
|
|
|
assert(ResolveConstants.empty() && "Constants not resolved?");
|
|
|
|
}
|
|
|
|
|
|
|
|
// vector compatibility methods
|
|
|
|
unsigned size() const { return ValuePtrs.size(); }
|
|
|
|
void resize(unsigned N) { ValuePtrs.resize(N); }
|
2015-05-29 19:43:39 +00:00
|
|
|
void push_back(Value *V) { ValuePtrs.emplace_back(V); }
|
2015-03-17 20:40:24 +00:00
|
|
|
|
|
|
|
void clear() {
|
|
|
|
assert(ResolveConstants.empty() && "Constants not resolved?");
|
|
|
|
ValuePtrs.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *operator[](unsigned i) const {
|
|
|
|
assert(i < ValuePtrs.size());
|
|
|
|
return ValuePtrs[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *back() const { return ValuePtrs.back(); }
|
|
|
|
void pop_back() { ValuePtrs.pop_back(); }
|
|
|
|
bool empty() const { return ValuePtrs.empty(); }
|
|
|
|
void shrinkTo(unsigned N) {
|
|
|
|
assert(N <= size() && "Invalid shrinkTo request!");
|
|
|
|
ValuePtrs.resize(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
|
|
|
|
Value *getValueFwdRef(unsigned Idx, Type *Ty);
|
|
|
|
|
|
|
|
void AssignValue(Value *V, unsigned Idx);
|
|
|
|
|
|
|
|
/// ResolveConstantForwardRefs - Once all constants are read, this method bulk
|
|
|
|
/// resolves any forward references.
|
|
|
|
void ResolveConstantForwardRefs();
|
|
|
|
};
|
|
|
|
|
|
|
|
class BitcodeReaderMDValueList {
|
|
|
|
unsigned NumFwdRefs;
|
|
|
|
bool AnyFwdRefs;
|
|
|
|
unsigned MinFwdRef;
|
|
|
|
unsigned MaxFwdRef;
|
|
|
|
std::vector<TrackingMDRef> MDValuePtrs;
|
|
|
|
|
|
|
|
LLVMContext &Context;
|
|
|
|
public:
|
|
|
|
BitcodeReaderMDValueList(LLVMContext &C)
|
|
|
|
: NumFwdRefs(0), AnyFwdRefs(false), Context(C) {}
|
|
|
|
|
|
|
|
// vector compatibility methods
|
|
|
|
unsigned size() const { return MDValuePtrs.size(); }
|
|
|
|
void resize(unsigned N) { MDValuePtrs.resize(N); }
|
|
|
|
void push_back(Metadata *MD) { MDValuePtrs.emplace_back(MD); }
|
|
|
|
void clear() { MDValuePtrs.clear(); }
|
|
|
|
Metadata *back() const { return MDValuePtrs.back(); }
|
|
|
|
void pop_back() { MDValuePtrs.pop_back(); }
|
|
|
|
bool empty() const { return MDValuePtrs.empty(); }
|
|
|
|
|
|
|
|
Metadata *operator[](unsigned i) const {
|
|
|
|
assert(i < MDValuePtrs.size());
|
|
|
|
return MDValuePtrs[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
void shrinkTo(unsigned N) {
|
|
|
|
assert(N <= size() && "Invalid shrinkTo request!");
|
|
|
|
MDValuePtrs.resize(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
Metadata *getValueFwdRef(unsigned Idx);
|
|
|
|
void AssignValue(Metadata *MD, unsigned Idx);
|
|
|
|
void tryToResolveCycles();
|
|
|
|
};
|
|
|
|
|
|
|
|
class BitcodeReader : public GVMaterializer {
|
|
|
|
LLVMContext &Context;
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler;
|
|
|
|
Module *TheModule;
|
|
|
|
std::unique_ptr<MemoryBuffer> Buffer;
|
|
|
|
std::unique_ptr<BitstreamReader> StreamFile;
|
|
|
|
BitstreamCursor Stream;
|
|
|
|
DataStreamer *LazyStreamer;
|
|
|
|
uint64_t NextUnreadBit;
|
|
|
|
bool SeenValueSymbolTable;
|
|
|
|
|
|
|
|
std::vector<Type*> TypeList;
|
|
|
|
BitcodeReaderValueList ValueList;
|
|
|
|
BitcodeReaderMDValueList MDValueList;
|
|
|
|
std::vector<Comdat *> ComdatList;
|
|
|
|
SmallVector<Instruction *, 64> InstructionList;
|
|
|
|
|
|
|
|
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
|
|
|
|
std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
|
|
|
|
std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
|
|
|
|
std::vector<std::pair<Function*, unsigned> > FunctionPrologues;
|
|
|
|
|
|
|
|
SmallVector<Instruction*, 64> InstsWithTBAATag;
|
|
|
|
|
|
|
|
/// MAttributes - The set of attributes by index. Index zero in the
|
|
|
|
/// file is for null, and is thus not represented here. As such all indices
|
|
|
|
/// are off by one.
|
|
|
|
std::vector<AttributeSet> MAttributes;
|
|
|
|
|
|
|
|
/// \brief The set of attribute groups.
|
|
|
|
std::map<unsigned, AttributeSet> MAttributeGroups;
|
|
|
|
|
|
|
|
/// FunctionBBs - While parsing a function body, this is a list of the basic
|
|
|
|
/// blocks for the function.
|
|
|
|
std::vector<BasicBlock*> FunctionBBs;
|
|
|
|
|
|
|
|
// When reading the module header, this list is populated with functions that
|
|
|
|
// have bodies later in the file.
|
|
|
|
std::vector<Function*> FunctionsWithBodies;
|
|
|
|
|
|
|
|
// When intrinsic functions are encountered which require upgrading they are
|
|
|
|
// stored here with their replacement function.
|
|
|
|
typedef std::vector<std::pair<Function*, Function*> > UpgradedIntrinsicMap;
|
|
|
|
UpgradedIntrinsicMap UpgradedIntrinsics;
|
|
|
|
|
|
|
|
// Map the bitcode's custom MDKind ID to the Module's MDKind ID.
|
|
|
|
DenseMap<unsigned, unsigned> MDKindMap;
|
|
|
|
|
|
|
|
// Several operations happen after the module header has been read, but
|
|
|
|
// before function bodies are processed. This keeps track of whether
|
|
|
|
// we've done this yet.
|
|
|
|
bool SeenFirstFunctionBody;
|
|
|
|
|
|
|
|
/// DeferredFunctionInfo - When function bodies are initially scanned, this
|
|
|
|
/// map contains info about where to find deferred function body in the
|
|
|
|
/// stream.
|
|
|
|
DenseMap<Function*, uint64_t> DeferredFunctionInfo;
|
|
|
|
|
|
|
|
/// When Metadata block is initially scanned when parsing the module, we may
|
|
|
|
/// choose to defer parsing of the metadata. This vector contains info about
|
|
|
|
/// which Metadata blocks are deferred.
|
|
|
|
std::vector<uint64_t> DeferredMetadataInfo;
|
|
|
|
|
|
|
|
/// These are basic blocks forward-referenced by block addresses. They are
|
|
|
|
/// inserted lazily into functions when they're loaded. The basic block ID is
|
|
|
|
/// its index into the vector.
|
|
|
|
DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
|
|
|
|
std::deque<Function *> BasicBlockFwdRefQueue;
|
|
|
|
|
|
|
|
/// UseRelativeIDs - Indicates that we are using a new encoding for
|
|
|
|
/// instruction operands where most operands in the current
|
|
|
|
/// FUNCTION_BLOCK are encoded relative to the instruction number,
|
|
|
|
/// for a more compact encoding. Some instruction operands are not
|
|
|
|
/// relative to the instruction ID: basic block numbers, and types.
|
|
|
|
/// Once the old style function blocks have been phased out, we would
|
|
|
|
/// not need this flag.
|
|
|
|
bool UseRelativeIDs;
|
|
|
|
|
|
|
|
/// True if all functions will be materialized, negating the need to process
|
|
|
|
/// (e.g.) blockaddress forward references.
|
|
|
|
bool WillMaterializeAllForwardRefs;
|
|
|
|
|
|
|
|
/// Functions that have block addresses taken. This is usually empty.
|
|
|
|
SmallPtrSet<const Function *, 4> BlockAddressesTaken;
|
|
|
|
|
|
|
|
/// True if any Metadata block has been materialized.
|
|
|
|
bool IsMetadataMaterialized;
|
|
|
|
|
2015-03-30 21:36:43 +00:00
|
|
|
bool StripDebugInfo = false;
|
|
|
|
|
2015-03-17 20:40:24 +00:00
|
|
|
public:
|
|
|
|
std::error_code Error(BitcodeError E, const Twine &Message);
|
|
|
|
std::error_code Error(BitcodeError E);
|
|
|
|
std::error_code Error(const Twine &Message);
|
|
|
|
|
|
|
|
explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler);
|
|
|
|
explicit BitcodeReader(DataStreamer *streamer, LLVMContext &C,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler);
|
2015-04-11 02:11:45 +00:00
|
|
|
~BitcodeReader() override { FreeState(); }
|
2015-03-17 20:40:24 +00:00
|
|
|
|
|
|
|
std::error_code materializeForwardReferencedFunctions();
|
|
|
|
|
|
|
|
void FreeState();
|
|
|
|
|
|
|
|
void releaseBuffer();
|
|
|
|
|
|
|
|
bool isDematerializable(const GlobalValue *GV) const override;
|
|
|
|
std::error_code materialize(GlobalValue *GV) override;
|
2015-05-15 18:20:14 +00:00
|
|
|
std::error_code materializeModule(Module *M) override;
|
2015-03-17 20:40:24 +00:00
|
|
|
std::vector<StructType *> getIdentifiedStructTypes() const override;
|
2015-05-15 18:20:14 +00:00
|
|
|
void dematerialize(GlobalValue *GV) override;
|
2015-03-17 20:40:24 +00:00
|
|
|
|
|
|
|
/// @brief Main interface to parsing a bitcode buffer.
|
|
|
|
/// @returns true if an error occurred.
|
|
|
|
std::error_code ParseBitcodeInto(Module *M,
|
|
|
|
bool ShouldLazyLoadMetadata = false);
|
|
|
|
|
|
|
|
/// @brief Cheap mechanism to just extract module triple
|
|
|
|
/// @returns true if an error occurred.
|
|
|
|
ErrorOr<std::string> parseTriple();
|
|
|
|
|
|
|
|
static uint64_t decodeSignRotatedValue(uint64_t V);
|
|
|
|
|
|
|
|
/// Materialize any deferred Metadata block.
|
|
|
|
std::error_code materializeMetadata() override;
|
|
|
|
|
2015-03-30 21:36:43 +00:00
|
|
|
void setStripDebugInfo() override;
|
|
|
|
|
2015-03-17 20:40:24 +00:00
|
|
|
private:
|
|
|
|
std::vector<StructType *> IdentifiedStructTypes;
|
|
|
|
StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
|
|
|
|
StructType *createIdentifiedStructType(LLVMContext &Context);
|
|
|
|
|
|
|
|
Type *getTypeByID(unsigned ID);
|
|
|
|
Value *getFnValueByID(unsigned ID, Type *Ty) {
|
|
|
|
if (Ty && Ty->isMetadataTy())
|
|
|
|
return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
|
|
|
|
return ValueList.getValueFwdRef(ID, Ty);
|
|
|
|
}
|
|
|
|
Metadata *getFnMetadataByID(unsigned ID) {
|
|
|
|
return MDValueList.getValueFwdRef(ID);
|
|
|
|
}
|
|
|
|
BasicBlock *getBasicBlock(unsigned ID) const {
|
|
|
|
if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
|
|
|
|
return FunctionBBs[ID];
|
|
|
|
}
|
|
|
|
AttributeSet getAttributes(unsigned i) const {
|
|
|
|
if (i-1 < MAttributes.size())
|
|
|
|
return MAttributes[i-1];
|
|
|
|
return AttributeSet();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getValueTypePair - Read a value/type pair out of the specified record from
|
|
|
|
/// slot 'Slot'. Increment Slot past the number of slots used in the record.
|
|
|
|
/// Return true on failure.
|
|
|
|
bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
|
|
|
|
unsigned InstNum, Value *&ResVal) {
|
|
|
|
if (Slot == Record.size()) return true;
|
|
|
|
unsigned ValNo = (unsigned)Record[Slot++];
|
|
|
|
// Adjust the ValNo, if it was encoded relative to the InstNum.
|
|
|
|
if (UseRelativeIDs)
|
|
|
|
ValNo = InstNum - ValNo;
|
|
|
|
if (ValNo < InstNum) {
|
|
|
|
// If this is not a forward reference, just return the value we already
|
|
|
|
// have.
|
|
|
|
ResVal = getFnValueByID(ValNo, nullptr);
|
|
|
|
return ResVal == nullptr;
|
|
|
|
}
|
2015-04-17 06:40:14 +00:00
|
|
|
if (Slot == Record.size())
|
|
|
|
return true;
|
2015-03-17 20:40:24 +00:00
|
|
|
|
|
|
|
unsigned TypeNo = (unsigned)Record[Slot++];
|
|
|
|
ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
|
|
|
|
return ResVal == nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// popValue - Read a value out of the specified record from slot 'Slot'.
|
|
|
|
/// Increment Slot past the number of slots used by the value in the record.
|
|
|
|
/// Return true if there is an error.
|
|
|
|
bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
|
|
|
|
unsigned InstNum, Type *Ty, Value *&ResVal) {
|
|
|
|
if (getValue(Record, Slot, InstNum, Ty, ResVal))
|
|
|
|
return true;
|
|
|
|
// All values currently take a single record slot.
|
|
|
|
++Slot;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getValue -- Like popValue, but does not increment the Slot number.
|
|
|
|
bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
|
|
|
|
unsigned InstNum, Type *Ty, Value *&ResVal) {
|
|
|
|
ResVal = getValue(Record, Slot, InstNum, Ty);
|
|
|
|
return ResVal == nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getValue -- Version of getValue that returns ResVal directly,
|
|
|
|
/// or 0 if there is an error.
|
|
|
|
Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
|
|
|
|
unsigned InstNum, Type *Ty) {
|
|
|
|
if (Slot == Record.size()) return nullptr;
|
|
|
|
unsigned ValNo = (unsigned)Record[Slot];
|
|
|
|
// Adjust the ValNo, if it was encoded relative to the InstNum.
|
|
|
|
if (UseRelativeIDs)
|
|
|
|
ValNo = InstNum - ValNo;
|
|
|
|
return getFnValueByID(ValNo, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getValueSigned -- Like getValue, but decodes signed VBRs.
|
|
|
|
Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
|
|
|
|
unsigned InstNum, Type *Ty) {
|
|
|
|
if (Slot == Record.size()) return nullptr;
|
|
|
|
unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
|
|
|
|
// Adjust the ValNo, if it was encoded relative to the InstNum.
|
|
|
|
if (UseRelativeIDs)
|
|
|
|
ValNo = InstNum - ValNo;
|
|
|
|
return getFnValueByID(ValNo, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Converts alignment exponent (i.e. power of two (or zero)) to the
|
|
|
|
/// corresponding alignment to use. If alignment is too large, returns
|
|
|
|
/// a corresponding error code.
|
|
|
|
std::error_code parseAlignmentValue(uint64_t Exponent, unsigned &Alignment);
|
|
|
|
std::error_code ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
|
|
|
|
std::error_code ParseModule(bool Resume, bool ShouldLazyLoadMetadata = false);
|
|
|
|
std::error_code ParseAttributeBlock();
|
|
|
|
std::error_code ParseAttributeGroupBlock();
|
|
|
|
std::error_code ParseTypeTable();
|
|
|
|
std::error_code ParseTypeTableBody();
|
|
|
|
|
|
|
|
std::error_code ParseValueSymbolTable();
|
|
|
|
std::error_code ParseConstants();
|
|
|
|
std::error_code RememberAndSkipFunctionBody();
|
|
|
|
/// Save the positions of the Metadata blocks and skip parsing the blocks.
|
|
|
|
std::error_code rememberAndSkipMetadata();
|
|
|
|
std::error_code ParseFunctionBody(Function *F);
|
|
|
|
std::error_code GlobalCleanup();
|
|
|
|
std::error_code ResolveGlobalAndAliasInits();
|
|
|
|
std::error_code ParseMetadata();
|
2015-04-24 22:04:41 +00:00
|
|
|
std::error_code ParseMetadataAttachment(Function &F);
|
2015-03-17 20:40:24 +00:00
|
|
|
ErrorOr<std::string> parseModuleTriple();
|
|
|
|
std::error_code ParseUseLists();
|
|
|
|
std::error_code InitStream();
|
|
|
|
std::error_code InitStreamFromBuffer();
|
|
|
|
std::error_code InitLazyStream();
|
|
|
|
std::error_code FindFunctionInStream(
|
|
|
|
Function *F,
|
|
|
|
DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
2015-01-10 00:07:30 +00:00
|
|
|
BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,
|
|
|
|
DiagnosticSeverity Severity,
|
|
|
|
const Twine &Msg)
|
|
|
|
: DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}
|
|
|
|
|
|
|
|
void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
|
|
|
|
|
|
|
|
static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler,
|
|
|
|
std::error_code EC, const Twine &Message) {
|
|
|
|
BitcodeDiagnosticInfo DI(EC, DS_Error, Message);
|
|
|
|
DiagnosticHandler(DI);
|
|
|
|
return EC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler,
|
|
|
|
std::error_code EC) {
|
|
|
|
return Error(DiagnosticHandler, EC, EC.message());
|
|
|
|
}
|
|
|
|
|
2015-05-18 21:48:55 +00:00
|
|
|
static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler,
|
|
|
|
const Twine &Message) {
|
|
|
|
return Error(DiagnosticHandler,
|
|
|
|
make_error_code(BitcodeError::CorruptedBitcode), Message);
|
|
|
|
}
|
|
|
|
|
2015-01-10 00:07:30 +00:00
|
|
|
std::error_code BitcodeReader::Error(BitcodeError E, const Twine &Message) {
|
|
|
|
return ::Error(DiagnosticHandler, make_error_code(E), Message);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::error_code BitcodeReader::Error(const Twine &Message) {
|
|
|
|
return ::Error(DiagnosticHandler,
|
|
|
|
make_error_code(BitcodeError::CorruptedBitcode), Message);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::error_code BitcodeReader::Error(BitcodeError E) {
|
|
|
|
return ::Error(DiagnosticHandler, make_error_code(E));
|
|
|
|
}
|
|
|
|
|
|
|
|
static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F,
|
|
|
|
LLVMContext &C) {
|
|
|
|
if (F)
|
|
|
|
return F;
|
|
|
|
return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); };
|
|
|
|
}
|
|
|
|
|
|
|
|
BitcodeReader::BitcodeReader(MemoryBuffer *buffer, LLVMContext &C,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler)
|
|
|
|
: Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
|
|
|
|
TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
|
|
|
|
NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
|
|
|
|
MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
|
2015-03-13 19:24:30 +00:00
|
|
|
WillMaterializeAllForwardRefs(false), IsMetadataMaterialized(false) {}
|
2015-01-10 00:07:30 +00:00
|
|
|
|
|
|
|
BitcodeReader::BitcodeReader(DataStreamer *streamer, LLVMContext &C,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler)
|
|
|
|
: Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
|
|
|
|
TheModule(nullptr), Buffer(nullptr), LazyStreamer(streamer),
|
|
|
|
NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
|
|
|
|
MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
|
2015-03-13 19:24:30 +00:00
|
|
|
WillMaterializeAllForwardRefs(false), IsMetadataMaterialized(false) {}
|
2015-01-10 00:07:30 +00:00
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
|
|
|
|
if (WillMaterializeAllForwardRefs)
|
|
|
|
return std::error_code();
|
|
|
|
|
|
|
|
// Prevent recursion.
|
|
|
|
WillMaterializeAllForwardRefs = true;
|
|
|
|
|
2014-08-05 17:49:48 +00:00
|
|
|
while (!BasicBlockFwdRefQueue.empty()) {
|
|
|
|
Function *F = BasicBlockFwdRefQueue.front();
|
|
|
|
BasicBlockFwdRefQueue.pop_front();
|
2014-08-01 21:11:34 +00:00
|
|
|
assert(F && "Expected valid function");
|
2014-08-05 17:49:48 +00:00
|
|
|
if (!BasicBlockFwdRefs.count(F))
|
|
|
|
// Already materialized.
|
|
|
|
continue;
|
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
// Check for a function that isn't materializable to prevent an infinite
|
|
|
|
// loop. When parsing a blockaddress stored in a global variable, there
|
|
|
|
// isn't a trivial way to check if a function will have a body without a
|
|
|
|
// linear search through FunctionsWithBodies, so just check it here.
|
|
|
|
if (!F->isMaterializable())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Never resolved function from blockaddress");
|
2014-08-01 21:11:34 +00:00
|
|
|
|
|
|
|
// Try to materialize F.
|
2014-10-24 22:50:48 +00:00
|
|
|
if (std::error_code EC = materialize(F))
|
2014-08-01 21:11:34 +00:00
|
|
|
return EC;
|
2012-01-02 07:49:53 +00:00
|
|
|
}
|
2014-08-05 17:49:48 +00:00
|
|
|
assert(BasicBlockFwdRefs.empty() && "Function missing from queue");
|
2014-08-01 21:11:34 +00:00
|
|
|
|
|
|
|
// Reset state.
|
|
|
|
WillMaterializeAllForwardRefs = false;
|
|
|
|
return std::error_code();
|
2012-01-02 07:49:53 +00:00
|
|
|
}
|
|
|
|
|
2007-05-18 04:02:46 +00:00
|
|
|
void BitcodeReader::FreeState() {
|
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();
|
2014-06-27 18:19:56 +00:00
|
|
|
std::vector<Comdat *>().swap(ComdatList);
|
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();
|
2015-03-13 19:24:30 +00:00
|
|
|
DeferredMetadataInfo.clear();
|
2010-07-20 21:42:28 +00:00
|
|
|
MDKindMap.clear();
|
2012-09-21 14:34:31 +00:00
|
|
|
|
2014-08-01 21:51:52 +00:00
|
|
|
assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references");
|
2014-08-05 17:49:48 +00:00
|
|
|
BasicBlockFwdRefQueue.clear();
|
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;
|
|
|
|
}
|
|
|
|
|
2015-01-19 15:16:06 +00:00
|
|
|
static bool hasImplicitComdat(size_t Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
case 1: // Old WeakAnyLinkage
|
|
|
|
case 4: // Old LinkOnceAnyLinkage
|
|
|
|
case 10: // Old WeakODRLinkage
|
|
|
|
case 11: // Old LinkOnceODRLinkage
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-08 15:36:32 +00:00
|
|
|
static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) {
|
2007-04-22 06:23:29 +00:00
|
|
|
switch (Val) {
|
|
|
|
default: // Map unknown/new linkages to external
|
2015-01-08 15:36:32 +00:00
|
|
|
case 0:
|
|
|
|
return GlobalValue::ExternalLinkage;
|
|
|
|
case 2:
|
|
|
|
return GlobalValue::AppendingLinkage;
|
|
|
|
case 3:
|
|
|
|
return GlobalValue::InternalLinkage;
|
|
|
|
case 5:
|
|
|
|
return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage
|
|
|
|
case 6:
|
|
|
|
return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage
|
|
|
|
case 7:
|
|
|
|
return GlobalValue::ExternalWeakLinkage;
|
|
|
|
case 8:
|
|
|
|
return GlobalValue::CommonLinkage;
|
|
|
|
case 9:
|
|
|
|
return GlobalValue::PrivateLinkage;
|
|
|
|
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
|
2015-01-08 15:39:50 +00:00
|
|
|
case 15:
|
|
|
|
return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage
|
2015-01-19 15:16:06 +00:00
|
|
|
case 1: // Old value with implicit comdat.
|
|
|
|
case 16:
|
|
|
|
return GlobalValue::WeakAnyLinkage;
|
|
|
|
case 10: // Old value with implicit comdat.
|
|
|
|
case 17:
|
|
|
|
return GlobalValue::WeakODRLinkage;
|
|
|
|
case 4: // Old value with implicit comdat.
|
|
|
|
case 18:
|
|
|
|
return GlobalValue::LinkOnceAnyLinkage;
|
|
|
|
case 11: // Old value with implicit comdat.
|
|
|
|
case 19:
|
|
|
|
return GlobalValue::LinkOnceODRLinkage;
|
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
|
|
|
}
|
|
|
|
}
|
2015-04-22 09:06:21 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) {
|
2015-04-22 09:06:21 +00:00
|
|
|
bool IsFP = Ty->isFPOrFPVectorTy();
|
|
|
|
// BinOps are only valid for int/fp or vector of int/fp types
|
|
|
|
if (!IsFP && !Ty->isIntOrIntVectorTy())
|
|
|
|
return -1;
|
|
|
|
|
2007-04-24 07:07:11 +00:00
|
|
|
switch (Val) {
|
2015-04-22 09:06:21 +00:00
|
|
|
default:
|
|
|
|
return -1;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_ADD:
|
2015-04-22 09:06:21 +00:00
|
|
|
return IsFP ? Instruction::FAdd : Instruction::Add;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_SUB:
|
2015-04-22 09:06:21 +00:00
|
|
|
return IsFP ? Instruction::FSub : Instruction::Sub;
|
2009-06-04 22:49:04 +00:00
|
|
|
case bitc::BINOP_MUL:
|
2015-04-22 09:06:21 +00:00
|
|
|
return IsFP ? Instruction::FMul : Instruction::Mul;
|
|
|
|
case bitc::BINOP_UDIV:
|
|
|
|
return IsFP ? -1 : Instruction::UDiv;
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::BINOP_SDIV:
|
2015-04-22 09:06:21 +00:00
|
|
|
return IsFP ? Instruction::FDiv : Instruction::SDiv;
|
|
|
|
case bitc::BINOP_UREM:
|
|
|
|
return IsFP ? -1 : Instruction::URem;
|
2007-04-24 07:07:11 +00:00
|
|
|
case bitc::BINOP_SREM:
|
2015-04-22 09:06:21 +00:00
|
|
|
return IsFP ? Instruction::FRem : Instruction::SRem;
|
|
|
|
case bitc::BINOP_SHL:
|
|
|
|
return IsFP ? -1 : Instruction::Shl;
|
|
|
|
case bitc::BINOP_LSHR:
|
|
|
|
return IsFP ? -1 : Instruction::LShr;
|
|
|
|
case bitc::BINOP_ASHR:
|
|
|
|
return IsFP ? -1 : Instruction::AShr;
|
|
|
|
case bitc::BINOP_AND:
|
|
|
|
return IsFP ? -1 : Instruction::And;
|
|
|
|
case bitc::BINOP_OR:
|
|
|
|
return IsFP ? -1 : Instruction::Or;
|
|
|
|
case bitc::BINOP_XOR:
|
|
|
|
return IsFP ? -1 : Instruction::Xor;
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-06-27 18:19:56 +00:00
|
|
|
static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
|
|
|
|
switch (Val) {
|
|
|
|
default: // Map unknown selection kinds to any.
|
|
|
|
case bitc::COMDAT_SELECTION_KIND_ANY:
|
|
|
|
return Comdat::Any;
|
|
|
|
case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH:
|
|
|
|
return Comdat::ExactMatch;
|
|
|
|
case bitc::COMDAT_SELECTION_KIND_LARGEST:
|
|
|
|
return Comdat::Largest;
|
|
|
|
case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES:
|
|
|
|
return Comdat::NoDuplicates;
|
|
|
|
case bitc::COMDAT_SELECTION_KIND_SAME_SIZE:
|
|
|
|
return Comdat::SameSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 {
|
2015-02-15 22:54:22 +00:00
|
|
|
void operator=(const ConstantPlaceHolder &) = delete;
|
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
|
2014-11-21 02:42:08 +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
|
|
|
};
|
2014-11-21 02:42:08 +00:00
|
|
|
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value)
|
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]) {
|
2015-05-27 01:05:40 +00:00
|
|
|
if (Ty != V->getType())
|
|
|
|
report_fatal_error("Type mismatch in constant table!");
|
2007-05-01 07:01:57 +00:00
|
|
|
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) {
|
2015-04-30 00:52:42 +00:00
|
|
|
// Bail out for a clearly invalid value. This would make us call resize(0)
|
|
|
|
if (Idx == UINT_MAX)
|
|
|
|
return nullptr;
|
|
|
|
|
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]) {
|
2015-04-28 20:18:47 +00:00
|
|
|
// If the types don't match, it's invalid.
|
|
|
|
if (Ty && Ty != V->getType())
|
|
|
|
return nullptr;
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
void BitcodeReaderMDValueList::AssignValue(Metadata *MD, unsigned Idx) {
|
2009-08-04 06:00:18 +00:00
|
|
|
if (Idx == size()) {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
push_back(MD);
|
2009-08-04 06:00:18 +00:00
|
|
|
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
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
TrackingMDRef &OldMD = MDValuePtrs[Idx];
|
|
|
|
if (!OldMD) {
|
|
|
|
OldMD.reset(MD);
|
2009-08-04 06:00:18 +00:00
|
|
|
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.
|
2015-01-19 21:30:18 +00:00
|
|
|
TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
PrevMD->replaceAllUsesWith(MD);
|
|
|
|
--NumFwdRefs;
|
2009-08-04 06:00:18 +00:00
|
|
|
}
|
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) {
|
2009-08-04 06:00:18 +00:00
|
|
|
if (Idx >= size())
|
|
|
|
resize(Idx + 1);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
if (Metadata *MD = MDValuePtrs[Idx])
|
|
|
|
return MD;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-02-16 19:18:01 +00:00
|
|
|
// Track forward refs to be resolved later.
|
|
|
|
if (AnyFwdRefs) {
|
|
|
|
MinFwdRef = std::min(MinFwdRef, Idx);
|
|
|
|
MaxFwdRef = std::max(MaxFwdRef, Idx);
|
|
|
|
} else {
|
|
|
|
AnyFwdRefs = true;
|
|
|
|
MinFwdRef = MaxFwdRef = Idx;
|
|
|
|
}
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
++NumFwdRefs;
|
2015-02-16 19:18:01 +00:00
|
|
|
|
|
|
|
// Create and return a placeholder, which will later be RAUW'd.
|
2015-01-19 21:30:18 +00:00
|
|
|
Metadata *MD = MDNode::getTemporary(Context, None).release();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
MDValuePtrs[Idx].reset(MD);
|
|
|
|
return MD;
|
|
|
|
}
|
|
|
|
|
|
|
|
void BitcodeReaderMDValueList::tryToResolveCycles() {
|
|
|
|
if (!AnyFwdRefs)
|
|
|
|
// Nothing to do.
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (NumFwdRefs)
|
|
|
|
// Still forward references... can't resolve cycles.
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Resolve any cycles.
|
2015-02-16 19:18:01 +00:00
|
|
|
for (unsigned I = MinFwdRef, E = MaxFwdRef + 1; I != E; ++I) {
|
|
|
|
auto &MD = MDValuePtrs[I];
|
2015-01-19 23:13:14 +00:00
|
|
|
auto *N = dyn_cast_or_null<MDNode>(MD);
|
IR: Remove MDNodeFwdDecl
Remove `MDNodeFwdDecl` (as promised in r226481). Aside from API
changes, there's no real functionality change here.
`MDNode::getTemporary()` now forwards to `MDTuple::getTemporary()`,
which returns a tuple with `isTemporary()` equal to true.
The main point is that we can now add temporaries of other `MDNode`
subclasses, needed for PR22235 (I introduced `MDNodeFwdDecl` in the
first place because I didn't recognize this need, and thought they were
only needed to handle forward references).
A few things left out of (or highlighted by) this commit:
- I've had to remove the (few) uses of `std::unique_ptr<>` to deal
with temporaries, since the destructor is no longer public.
`getTemporary()` should probably return the equivalent of
`std::unique_ptr<T, MDNode::deleteTemporary>`.
- `MDLocation::getTemporary()` doesn't exist yet (worse, it actually
does exist, but does the wrong thing: `MDNode::getTemporary()` is
inherited and returns an `MDTuple`).
- `MDNode` now only has one subclass, `UniquableMDNode`, and the
distinction between them is actually somewhat confusing.
I'll fix those up next.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226501 91177308-0d34-0410-b5e6-96231b3b80d8
2015-01-19 20:36:39 +00:00
|
|
|
if (!N)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
assert(!N->isTemporary() && "Unexpected forward reference");
|
|
|
|
N->resolveCycles();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
}
|
2015-02-16 19:18:01 +00:00
|
|
|
|
|
|
|
// Make sure we return early again until there's another forward ref.
|
|
|
|
AnyFwdRefs = false;
|
2009-08-04 06:00:18 +00:00
|
|
|
}
|
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.
|
Ask the module for its the identified types.
When lazy reading a module, the types used in a function will not be visible to
a TypeFinder until the body is read.
This patch fixes that by asking the module for its identified struct types.
If a materializer is present, the module asks it. If not, it uses a TypeFinder.
This fixes pr21374.
I will be the first to say that this is ugly, but it was the best I could find.
Some of the options I looked at:
* Asking the LLVMContext. This could be made to work for gold, but not currently
for ld64. ld64 will load multiple modules into a single context before merging
them. This causes us to see types from future merges. Unfortunately,
MappedTypes is not just a cache when it comes to opaque types. Once the
mapping has been made, we have to remember it for as long as the key may
be used. This would mean moving MappedTypes to the Linker class and having
to drop the Linker::LinkModules static methods, which are visible from C.
* Adding an option to ignore function bodies in the TypeFinder. This would
fix the PR by picking the worst result. It would work, but unfortunately
we are currently quite dependent on the upfront type merging. I will
try to reduce our dependency, but it is not clear that we will be able
to get rid of it for now.
The only clean solution I could think of is making the Module own the types.
This would have other advantages, but it is a much bigger change. I will
propose it, but it is nice to have this fixed while that is discussed.
With the gold plugin, this patch takes the number of types in the LTO clang
binary from 52817 to 49669.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223215 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-03 07:18:23 +00:00
|
|
|
return TypeList[ID] = createIdentifiedStructType(Context);
|
|
|
|
}
|
|
|
|
|
|
|
|
StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,
|
|
|
|
StringRef Name) {
|
|
|
|
auto *Ret = StructType::create(Context, Name);
|
|
|
|
IdentifiedStructTypes.push_back(Ret);
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {
|
|
|
|
auto *Ret = StructType::create(Context);
|
|
|
|
IdentifiedStructTypes.push_back(Ret);
|
|
|
|
return Ret;
|
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));
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseAttributeBlock() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-26 22:53:05 +00:00
|
|
|
if (!MAttributes.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid multiple blocks");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
2015-05-26 23:48:40 +00:00
|
|
|
case bitc::ATTR_KIND_CONVERGENT:
|
|
|
|
return Attribute::Convergent;
|
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;
|
2014-06-05 19:29:43 +00:00
|
|
|
case bitc::ATTR_KIND_JUMP_TABLE:
|
|
|
|
return Attribute::JumpTable;
|
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;
|
2014-05-20 01:23:40 +00:00
|
|
|
case bitc::ATTR_KIND_NON_NULL:
|
|
|
|
return Attribute::NonNull;
|
2014-07-18 15:51:28 +00:00
|
|
|
case bitc::ATTR_KIND_DEREFERENCEABLE:
|
|
|
|
return Attribute::Dereferenceable;
|
2015-04-16 20:29:50 +00:00
|
|
|
case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL:
|
|
|
|
return Attribute::DereferenceableOrNull;
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-22 19:32:03 +00:00
|
|
|
std::error_code BitcodeReader::parseAlignmentValue(uint64_t Exponent,
|
|
|
|
unsigned &Alignment) {
|
|
|
|
// Note: Alignment in bitcode files is incremented by 1, so that zero
|
|
|
|
// can be used for default alignment.
|
|
|
|
if (Exponent > Value::MaxAlignmentExponent + 1)
|
|
|
|
return Error("Invalid alignment value");
|
|
|
|
Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
|
|
|
|
return std::error_code();
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseAttrKind(uint64_t Code,
|
|
|
|
Attribute::AttrKind *Kind) {
|
2013-11-12 01:31:00 +00:00
|
|
|
*Kind = GetAttrFromCode(Code);
|
|
|
|
if (*Kind == Attribute::None)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error(BitcodeError::CorruptedBitcode,
|
|
|
|
"Unknown attribute kind (" + Twine(Code) + ")");
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2013-11-12 01:31:00 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseAttributeGroupBlock() {
|
2013-02-10 23:24:25 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2013-02-10 23:24:25 +00:00
|
|
|
|
|
|
|
if (!MAttributeGroups.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid multiple blocks");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-02-10 23:24:25 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseAttrKind(Record[++i], &Kind))
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2013-07-26 04:16:55 +00:00
|
|
|
|
|
|
|
B.addAttribute(Kind);
|
2014-07-18 06:51:55 +00:00
|
|
|
} else if (Record[i] == 1) { // Integer attribute
|
2013-07-26 04:16:55 +00:00
|
|
|
Attribute::AttrKind Kind;
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseAttrKind(Record[++i], &Kind))
|
2013-11-04 16:16:24 +00:00
|
|
|
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]);
|
2014-07-18 15:51:28 +00:00
|
|
|
else if (Kind == Attribute::StackAlignment)
|
2013-02-10 23:24:25 +00:00
|
|
|
B.addStackAlignmentAttr(Record[++i]);
|
2014-07-18 15:51:28 +00:00
|
|
|
else if (Kind == Attribute::Dereferenceable)
|
|
|
|
B.addDereferenceableAttr(Record[++i]);
|
2015-04-16 20:29:50 +00:00
|
|
|
else if (Kind == Attribute::DereferenceableOrNull)
|
|
|
|
B.addDereferenceableOrNullAttr(Record[++i]);
|
2013-02-10 23:24:25 +00:00
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-02-06 19:03:04 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
return ParseTypeTableBody();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseTypeTableBody() {
|
2007-04-22 06:23:29 +00:00
|
|
|
if (!TypeList.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid multiple blocks");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2007-04-22 06:23:29 +00:00
|
|
|
if (NumRecords != TypeList.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid value");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
TypeList.resize(Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
continue;
|
|
|
|
case bitc::TYPE_CODE_VOID: // VOID
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getVoidTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2011-12-17 00:04:22 +00:00
|
|
|
case bitc::TYPE_CODE_HALF: // HALF
|
|
|
|
ResultTy = Type::getHalfTy(Context);
|
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_FLOAT: // FLOAT
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getFloatTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_DOUBLE: // DOUBLE
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getDoubleTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2007-08-03 01:03:46 +00:00
|
|
|
case bitc::TYPE_CODE_X86_FP80: // X86_FP80
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getX86_FP80Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_FP128: // FP128
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getFP128Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getPPC_FP128Ty(Context);
|
2007-08-03 01:03:46 +00:00
|
|
|
break;
|
2007-04-22 06:23:29 +00:00
|
|
|
case bitc::TYPE_CODE_LABEL: // LABEL
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getLabelTy(Context);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2009-05-30 05:06:04 +00:00
|
|
|
case bitc::TYPE_CODE_METADATA: // METADATA
|
2009-08-13 21:58:54 +00:00
|
|
|
ResultTy = Type::getMetadataTy(Context);
|
2009-05-30 05:06:04 +00:00
|
|
|
break;
|
2010-09-10 20:55:01 +00:00
|
|
|
case bitc::TYPE_CODE_X86_MMX: // X86_MMX
|
|
|
|
ResultTy = Type::getX86_MMXTy(Context);
|
|
|
|
break;
|
2015-01-30 18:13:50 +00:00
|
|
|
case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
|
2007-04-22 06:23:29 +00:00
|
|
|
if (Record.size() < 1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-01-30 18:13:50 +00:00
|
|
|
uint64_t NumBits = Record[0];
|
|
|
|
if (NumBits < IntegerType::MIN_INT_BITS ||
|
|
|
|
NumBits > IntegerType::MAX_INT_BITS)
|
|
|
|
return Error("Bitwidth for integer type out of range");
|
|
|
|
ResultTy = IntegerType::get(Context, NumBits);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
2015-01-30 18:13:50 +00:00
|
|
|
}
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-12-11 08:59:05 +00:00
|
|
|
unsigned AddressSpace = 0;
|
|
|
|
if (Record.size() == 2)
|
|
|
|
AddressSpace = Record[1];
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
ResultTy = getTypeByID(Record[0]);
|
2015-04-29 02:27:28 +00:00
|
|
|
if (!ResultTy ||
|
|
|
|
!PointerType::isValidElementType(ResultTy))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid 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
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Type*, 8> ArgTys;
|
2011-11-03 00:14:01 +00:00
|
|
|
for (unsigned i = 2, e = Record.size(); i != e; ++i) {
|
2015-05-19 01:21:06 +00:00
|
|
|
if (Type *T = getTypeByID(Record[i])) {
|
|
|
|
if (!FunctionType::isValidArgumentType(T))
|
|
|
|
return Error("Invalid function argument type");
|
2011-11-03 00:14:01 +00:00
|
|
|
ArgTys.push_back(T);
|
2015-05-19 01:21:06 +00:00
|
|
|
}
|
2011-11-03 00:14:01 +00:00
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Type*, 8> EltTys;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
for (unsigned i = 1, e = Record.size(); i != e; ++i) {
|
|
|
|
if (Type *T = getTypeByID(Record[i]))
|
|
|
|
EltTys.push_back(T);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (EltTys.size() != Record.size()-1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type");
|
2009-08-05 23:16:16 +00:00
|
|
|
ResultTy = StructType::get(Context, EltTys, Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
}
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
|
|
|
|
if (ConvertToString(Record, 0, TypeName))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
|
|
|
|
if (Record.size() < 1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (NumRecords >= TypeList.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid TYPE table");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Check to see if this was forward referenced, if so fill in the temp.
|
|
|
|
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
|
|
|
|
if (Res) {
|
|
|
|
Res->setName(TypeName);
|
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.
|
Ask the module for its the identified types.
When lazy reading a module, the types used in a function will not be visible to
a TypeFinder until the body is read.
This patch fixes that by asking the module for its identified struct types.
If a materializer is present, the module asks it. If not, it uses a TypeFinder.
This fixes pr21374.
I will be the first to say that this is ugly, but it was the best I could find.
Some of the options I looked at:
* Asking the LLVMContext. This could be made to work for gold, but not currently
for ld64. ld64 will load multiple modules into a single context before merging
them. This causes us to see types from future merges. Unfortunately,
MappedTypes is not just a cache when it comes to opaque types. Once the
mapping has been made, we have to remember it for as long as the key may
be used. This would mean moving MappedTypes to the Linker class and having
to drop the Linker::LinkModules static methods, which are visible from C.
* Adding an option to ignore function bodies in the TypeFinder. This would
fix the PR by picking the worst result. It would work, but unfortunately
we are currently quite dependent on the upfront type merging. I will
try to reduce our dependency, but it is not clear that we will be able
to get rid of it for now.
The only clean solution I could think of is making the Module own the types.
This would have other advantages, but it is a much bigger change. I will
propose it, but it is nice to have this fixed while that is discussed.
With the gold plugin, this patch takes the number of types in the LTO clang
binary from 52817 to 49669.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223215 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-03 07:18:23 +00:00
|
|
|
Res = createIdentifiedStructType(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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Res->setBody(EltTys, Record[0]);
|
|
|
|
ResultTy = Res;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
|
|
|
|
if (Record.size() != 1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
|
|
|
|
if (NumRecords >= TypeList.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid TYPE table");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Check to see if this was forward referenced, if so fill in the temp.
|
|
|
|
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
|
|
|
|
if (Res) {
|
|
|
|
Res->setName(TypeName);
|
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.
|
Ask the module for its the identified types.
When lazy reading a module, the types used in a function will not be visible to
a TypeFinder until the body is read.
This patch fixes that by asking the module for its identified struct types.
If a materializer is present, the module asks it. If not, it uses a TypeFinder.
This fixes pr21374.
I will be the first to say that this is ugly, but it was the best I could find.
Some of the options I looked at:
* Asking the LLVMContext. This could be made to work for gold, but not currently
for ld64. ld64 will load multiple modules into a single context before merging
them. This causes us to see types from future merges. Unfortunately,
MappedTypes is not just a cache when it comes to opaque types. Once the
mapping has been made, we have to remember it for as long as the key may
be used. This would mean moving MappedTypes to the Linker class and having
to drop the Linker::LinkModules static methods, which are visible from C.
* Adding an option to ignore function bodies in the TypeFinder. This would
fix the PR by picking the worst result. It would work, but unfortunately
we are currently quite dependent on the upfront type merging. I will
try to reduce our dependency, but it is not clear that we will be able
to get rid of it for now.
The only clean solution I could think of is making the Module own the types.
This would have other advantages, but it is a much bigger change. I will
propose it, but it is nice to have this fixed while that is discussed.
With the gold plugin, this patch takes the number of types in the LTO clang
binary from 52817 to 49669.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223215 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-03 07:18:23 +00:00
|
|
|
Res = createIdentifiedStructType(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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-29 02:36:08 +00:00
|
|
|
ResultTy = getTypeByID(Record[1]);
|
|
|
|
if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type");
|
2015-04-29 02:36:08 +00:00
|
|
|
ResultTy = ArrayType::get(ResultTy, Record[0]);
|
2007-04-22 06:23:29 +00:00
|
|
|
break;
|
|
|
|
case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
|
|
|
|
if (Record.size() < 2)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-06-03 00:05:30 +00:00
|
|
|
if (Record[0] == 0)
|
|
|
|
return Error("Invalid vector length");
|
2015-04-29 02:36:08 +00:00
|
|
|
ResultTy = getTypeByID(Record[1]);
|
|
|
|
if (!ResultTy || !StructType::isValidElementType(ResultTy))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type");
|
2015-04-29 02:36:08 +00:00
|
|
|
ResultTy = VectorType::get(ResultTy, Record[0]);
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid TYPE table");
|
2015-01-30 10:57:58 +00:00
|
|
|
if (TypeList[NumRecords])
|
|
|
|
return Error(
|
|
|
|
"Invalid TYPE table: Only named structs can be forward referenced");
|
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?");
|
|
|
|
TypeList[NumRecords++] = ResultTy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseValueSymbolTable() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-04-23 21:26:05 +00:00
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-01-20 05:58:07 +00:00
|
|
|
Triple TT(TheModule->getTargetTriple());
|
|
|
|
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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])
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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()));
|
2015-01-19 15:16:06 +00:00
|
|
|
if (auto *GO = dyn_cast<GlobalObject>(V)) {
|
2015-01-20 05:58:07 +00:00
|
|
|
if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
|
|
|
|
if (TT.isOSBinFormatMachO())
|
|
|
|
GO->setComdat(nullptr);
|
|
|
|
else
|
|
|
|
GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
|
|
|
|
}
|
2015-01-19 15:16:06 +00:00
|
|
|
}
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-03 22:18:21 +00:00
|
|
|
BasicBlock *BB = getBasicBlock(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!BB)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-26 00:34:27 +00:00
|
|
|
BB->setName(StringRef(ValueName.data(), ValueName.size()));
|
2007-05-03 22:18:21 +00:00
|
|
|
ValueName.clear();
|
|
|
|
break;
|
2007-04-23 21:26:05 +00:00
|
|
|
}
|
2007-05-04 01:43:33 +00:00
|
|
|
}
|
2007-04-23 21:26:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-13 01:10:38 +00:00
|
|
|
static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseMetadata() {
|
2015-03-13 19:24:30 +00:00
|
|
|
IsMetadataMaterialized = true;
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-22 17:43:22 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-02-13 01:20:38 +00:00
|
|
|
auto getMD =
|
|
|
|
[&](unsigned ID) -> Metadata *{ return MDValueList.getValueFwdRef(ID); };
|
|
|
|
auto getMDOrNull = [&](unsigned ID) -> Metadata *{
|
|
|
|
if (ID)
|
|
|
|
return getMD(ID - 1);
|
|
|
|
return nullptr;
|
|
|
|
};
|
2015-02-03 21:54:14 +00:00
|
|
|
auto getMDString = [&](unsigned ID) -> MDString *{
|
|
|
|
// This requires that the ID is not really a forward reference. In
|
|
|
|
// particular, the MDString must already have been resolved.
|
2015-02-13 01:20:38 +00:00
|
|
|
return cast_or_null<MDString>(getMDOrNull(ID));
|
2015-02-03 21:54:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define GET_OR_DISTINCT(CLASS, DISTINCT, ARGS) \
|
|
|
|
(DISTINCT ? CLASS::getDistinct ARGS : CLASS::get ARGS)
|
|
|
|
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
MDValueList.tryToResolveCycles();
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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
|
|
|
|
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);
|
2015-01-08 22:38:29 +00:00
|
|
|
bool IsDistinct = false;
|
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();
|
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
unsigned NextBitCode = Stream.readRecord(Code, Record);
|
2015-05-30 00:17:20 +00:00
|
|
|
if (NextBitCode != bitc::METADATA_NAMED_NODE)
|
|
|
|
return Error("METADATA_NAME not followed by METADATA_NAMED_NODE");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2010-07-21 23:38:33 +00:00
|
|
|
NMD->addOperand(MD);
|
2009-07-29 22:34:41 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-12-11 22:30:48 +00:00
|
|
|
case bitc::METADATA_OLD_FN_NODE: {
|
2014-12-12 02:11:31 +00:00
|
|
|
// FIXME: Remove in 4.0.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
// This is a LocalAsMetadata record, the only type of function-local
|
|
|
|
// metadata.
|
2014-12-06 01:26:49 +00:00
|
|
|
if (Record.size() % 2 == 1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-12-06 01:26:49 +00:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
// If this isn't a LocalAsMetadata record, we're dropping it. This used
|
|
|
|
// to be legal, but there's no upgrade path.
|
2014-12-06 01:26:49 +00:00
|
|
|
auto dropRecord = [&] {
|
|
|
|
MDValueList.AssignValue(MDNode::get(Context, None), NextMDValueNo++);
|
|
|
|
};
|
|
|
|
if (Record.size() != 2) {
|
|
|
|
dropRecord();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
|
|
|
if (Ty->isMetadataTy() || Ty->isVoidTy()) {
|
|
|
|
dropRecord();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
MDValueList.AssignValue(
|
|
|
|
LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
|
|
|
|
NextMDValueNo++);
|
2014-12-06 01:26:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-12-11 22:30:48 +00:00
|
|
|
case bitc::METADATA_OLD_NODE: {
|
2014-12-12 02:11:31 +00:00
|
|
|
// FIXME: Remove in 4.0.
|
2010-07-13 19:33:27 +00:00
|
|
|
if (Record.size() % 2 == 1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-23 01:07:34 +00:00
|
|
|
unsigned Size = Record.size();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
SmallVector<Metadata *, 8> Elts;
|
2009-07-23 01:07:34 +00:00
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-10-05 05:54:46 +00:00
|
|
|
if (Ty->isMetadataTy())
|
2009-08-04 06:00:18 +00:00
|
|
|
Elts.push_back(MDValueList.getValueFwdRef(Record[i+1]));
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
else if (!Ty->isVoidTy()) {
|
|
|
|
auto *MD =
|
|
|
|
ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
|
|
|
|
assert(isa<ConstantAsMetadata>(MD) &&
|
|
|
|
"Expected non-function-local metadata");
|
|
|
|
Elts.push_back(MD);
|
|
|
|
} else
|
2014-04-15 06:32:26 +00:00
|
|
|
Elts.push_back(nullptr);
|
2009-07-23 01:07:34 +00:00
|
|
|
}
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
MDValueList.AssignValue(MDNode::get(Context, Elts), NextMDValueNo++);
|
2009-07-23 01:07:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-12-11 23:02:24 +00:00
|
|
|
case bitc::METADATA_VALUE: {
|
|
|
|
if (Record.size() != 2)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-12-11 23:02:24 +00:00
|
|
|
|
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
|
|
|
if (Ty->isMetadataTy() || Ty->isVoidTy())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-12-11 23:02:24 +00:00
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
|
|
|
ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-01-08 22:38:29 +00:00
|
|
|
case bitc::METADATA_DISTINCT_NODE:
|
|
|
|
IsDistinct = true;
|
|
|
|
// fallthrough...
|
2014-12-11 23:02:24 +00:00
|
|
|
case bitc::METADATA_NODE: {
|
|
|
|
SmallVector<Metadata *, 8> Elts;
|
|
|
|
Elts.reserve(Record.size());
|
|
|
|
for (unsigned ID : Record)
|
|
|
|
Elts.push_back(ID ? MDValueList.getValueFwdRef(ID - 1) : nullptr);
|
2015-01-08 22:38:29 +00:00
|
|
|
MDValueList.AssignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
|
|
|
|
: MDNode::get(Context, Elts),
|
|
|
|
NextMDValueNo++);
|
2014-12-11 23:02:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-01-13 21:10:44 +00:00
|
|
|
case bitc::METADATA_LOCATION: {
|
|
|
|
if (Record.size() != 5)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
unsigned Line = Record[1];
|
|
|
|
unsigned Column = Record[2];
|
|
|
|
MDNode *Scope = cast<MDNode>(MDValueList.getValueFwdRef(Record[3]));
|
|
|
|
Metadata *InlinedAt =
|
|
|
|
Record[4] ? MDValueList.getValueFwdRef(Record[4] - 1) : nullptr;
|
2015-03-26 22:05:04 +00:00
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DILocation, Record[0],
|
2015-03-26 22:05:04 +00:00
|
|
|
(Context, Line, Column, Scope, InlinedAt)),
|
|
|
|
NextMDValueNo++);
|
2015-01-13 21:10:44 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-02-03 21:54:14 +00:00
|
|
|
case bitc::METADATA_GENERIC_DEBUG: {
|
|
|
|
if (Record.size() < 4)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
unsigned Tag = Record[1];
|
|
|
|
unsigned Version = Record[2];
|
|
|
|
|
|
|
|
if (Tag >= 1u << 16 || Version != 0)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
auto *Header = getMDString(Record[3]);
|
|
|
|
SmallVector<Metadata *, 8> DwarfOps;
|
|
|
|
for (unsigned I = 4, E = Record.size(); I != E; ++I)
|
|
|
|
DwarfOps.push_back(Record[I] ? MDValueList.getValueFwdRef(Record[I] - 1)
|
|
|
|
: nullptr);
|
2015-04-29 16:38:44 +00:00
|
|
|
MDValueList.AssignValue(GET_OR_DISTINCT(GenericDINode, Record[0],
|
2015-02-03 21:54:14 +00:00
|
|
|
(Context, Tag, Header, DwarfOps)),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:10:38 +00:00
|
|
|
case bitc::METADATA_SUBRANGE: {
|
|
|
|
if (Record.size() != 3)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DISubrange, Record[0],
|
2015-02-13 01:10:38 +00:00
|
|
|
(Context, Record[1], unrotateSign(Record[2]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:14:11 +00:00
|
|
|
case bitc::METADATA_ENUMERATOR: {
|
|
|
|
if (Record.size() != 3)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
2015-04-29 16:38:44 +00:00
|
|
|
MDValueList.AssignValue(GET_OR_DISTINCT(DIEnumerator, Record[0],
|
2015-02-13 01:14:11 +00:00
|
|
|
(Context, unrotateSign(Record[1]),
|
|
|
|
getMDString(Record[2]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:14:58 +00:00
|
|
|
case bitc::METADATA_BASIC_TYPE: {
|
|
|
|
if (Record.size() != 6)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIBasicType, Record[0],
|
2015-02-13 01:14:58 +00:00
|
|
|
(Context, Record[1], getMDString(Record[2]),
|
|
|
|
Record[3], Record[4], Record[5])),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:20:38 +00:00
|
|
|
case bitc::METADATA_DERIVED_TYPE: {
|
|
|
|
if (Record.size() != 12)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIDerivedType, Record[0],
|
2015-02-13 01:20:38 +00:00
|
|
|
(Context, Record[1], getMDString(Record[2]),
|
|
|
|
getMDOrNull(Record[3]), Record[4],
|
2015-02-20 03:17:58 +00:00
|
|
|
getMDOrNull(Record[5]), getMDOrNull(Record[6]),
|
|
|
|
Record[7], Record[8], Record[9], Record[10],
|
2015-02-13 01:20:38 +00:00
|
|
|
getMDOrNull(Record[11]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::METADATA_COMPOSITE_TYPE: {
|
|
|
|
if (Record.size() != 16)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DICompositeType, Record[0],
|
2015-02-13 01:20:38 +00:00
|
|
|
(Context, Record[1], getMDString(Record[2]),
|
|
|
|
getMDOrNull(Record[3]), Record[4],
|
|
|
|
getMDOrNull(Record[5]), getMDOrNull(Record[6]),
|
|
|
|
Record[7], Record[8], Record[9], Record[10],
|
|
|
|
getMDOrNull(Record[11]), Record[12],
|
|
|
|
getMDOrNull(Record[13]), getMDOrNull(Record[14]),
|
|
|
|
getMDString(Record[15]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:22:59 +00:00
|
|
|
case bitc::METADATA_SUBROUTINE_TYPE: {
|
|
|
|
if (Record.size() != 3)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DISubroutineType, Record[0],
|
2015-02-13 01:22:59 +00:00
|
|
|
(Context, Record[1], getMDOrNull(Record[2]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:19:14 +00:00
|
|
|
case bitc::METADATA_FILE: {
|
|
|
|
if (Record.size() != 3)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIFile, Record[0], (Context, getMDString(Record[1]),
|
2015-02-13 01:19:14 +00:00
|
|
|
getMDString(Record[2]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:25:10 +00:00
|
|
|
case bitc::METADATA_COMPILE_UNIT: {
|
2015-05-21 20:37:30 +00:00
|
|
|
if (Record.size() < 14 || Record.size() > 15)
|
2015-02-13 01:25:10 +00:00
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DICompileUnit, Record[0],
|
2015-02-20 03:17:58 +00:00
|
|
|
(Context, Record[1], getMDOrNull(Record[2]),
|
|
|
|
getMDString(Record[3]), Record[4],
|
|
|
|
getMDString(Record[5]), Record[6],
|
|
|
|
getMDString(Record[7]), Record[8],
|
|
|
|
getMDOrNull(Record[9]), getMDOrNull(Record[10]),
|
|
|
|
getMDOrNull(Record[11]), getMDOrNull(Record[12]),
|
2015-05-21 20:37:30 +00:00
|
|
|
getMDOrNull(Record[13]),
|
|
|
|
Record.size() == 14 ? 0 : Record[14])),
|
2015-02-13 01:25:10 +00:00
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:26:47 +00:00
|
|
|
case bitc::METADATA_SUBPROGRAM: {
|
|
|
|
if (Record.size() != 19)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
|
|
|
GET_OR_DISTINCT(
|
2015-04-29 16:38:44 +00:00
|
|
|
DISubprogram, Record[0],
|
2015-02-13 01:26:47 +00:00
|
|
|
(Context, getMDOrNull(Record[1]), getMDString(Record[2]),
|
|
|
|
getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
|
|
|
|
getMDOrNull(Record[6]), Record[7], Record[8], Record[9],
|
|
|
|
getMDOrNull(Record[10]), Record[11], Record[12], Record[13],
|
|
|
|
Record[14], getMDOrNull(Record[15]), getMDOrNull(Record[16]),
|
|
|
|
getMDOrNull(Record[17]), getMDOrNull(Record[18]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:29:28 +00:00
|
|
|
case bitc::METADATA_LEXICAL_BLOCK: {
|
|
|
|
if (Record.size() != 5)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DILexicalBlock, Record[0],
|
2015-02-13 01:29:28 +00:00
|
|
|
(Context, getMDOrNull(Record[1]),
|
|
|
|
getMDOrNull(Record[2]), Record[3], Record[4])),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:30:42 +00:00
|
|
|
case bitc::METADATA_LEXICAL_BLOCK_FILE: {
|
|
|
|
if (Record.size() != 4)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DILexicalBlockFile, Record[0],
|
2015-02-13 01:30:42 +00:00
|
|
|
(Context, getMDOrNull(Record[1]),
|
|
|
|
getMDOrNull(Record[2]), Record[3])),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:32:09 +00:00
|
|
|
case bitc::METADATA_NAMESPACE: {
|
|
|
|
if (Record.size() != 5)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DINamespace, Record[0],
|
2015-02-13 01:32:09 +00:00
|
|
|
(Context, getMDOrNull(Record[1]),
|
|
|
|
getMDOrNull(Record[2]), getMDString(Record[3]),
|
|
|
|
Record[4])),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:34:32 +00:00
|
|
|
case bitc::METADATA_TEMPLATE_TYPE: {
|
2015-02-19 00:37:21 +00:00
|
|
|
if (Record.size() != 3)
|
2015-02-13 01:34:32 +00:00
|
|
|
return Error("Invalid record");
|
|
|
|
|
2015-04-29 16:38:44 +00:00
|
|
|
MDValueList.AssignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
|
2015-02-19 00:37:21 +00:00
|
|
|
Record[0],
|
|
|
|
(Context, getMDString(Record[1]),
|
|
|
|
getMDOrNull(Record[2]))),
|
|
|
|
NextMDValueNo++);
|
2015-02-13 01:34:32 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case bitc::METADATA_TEMPLATE_VALUE: {
|
2015-02-19 00:37:21 +00:00
|
|
|
if (Record.size() != 5)
|
2015-02-13 01:34:32 +00:00
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DITemplateValueParameter, Record[0],
|
2015-02-19 00:37:21 +00:00
|
|
|
(Context, Record[1], getMDString(Record[2]),
|
|
|
|
getMDOrNull(Record[3]), getMDOrNull(Record[4]))),
|
2015-02-13 01:34:32 +00:00
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:35:40 +00:00
|
|
|
case bitc::METADATA_GLOBAL_VAR: {
|
|
|
|
if (Record.size() != 11)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIGlobalVariable, Record[0],
|
2015-02-13 01:35:40 +00:00
|
|
|
(Context, getMDOrNull(Record[1]),
|
|
|
|
getMDString(Record[2]), getMDString(Record[3]),
|
|
|
|
getMDOrNull(Record[4]), Record[5],
|
|
|
|
getMDOrNull(Record[6]), Record[7], Record[8],
|
|
|
|
getMDOrNull(Record[9]), getMDOrNull(Record[10]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:39:44 +00:00
|
|
|
case bitc::METADATA_LOCAL_VAR: {
|
2015-04-15 22:29:27 +00:00
|
|
|
// 10th field is for the obseleted 'inlinedAt:' field.
|
|
|
|
if (Record.size() != 9 && Record.size() != 10)
|
2015-02-13 01:39:44 +00:00
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DILocalVariable, Record[0],
|
2015-02-13 01:39:44 +00:00
|
|
|
(Context, Record[1], getMDOrNull(Record[2]),
|
|
|
|
getMDString(Record[3]), getMDOrNull(Record[4]),
|
|
|
|
Record[5], getMDOrNull(Record[6]), Record[7],
|
2015-04-15 22:29:27 +00:00
|
|
|
Record[8])),
|
2015-02-13 01:39:44 +00:00
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:42:09 +00:00
|
|
|
case bitc::METADATA_EXPRESSION: {
|
|
|
|
if (Record.size() < 1)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIExpression, Record[0],
|
2015-02-13 01:42:09 +00:00
|
|
|
(Context, makeArrayRef(Record).slice(1))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:43:22 +00:00
|
|
|
case bitc::METADATA_OBJC_PROPERTY: {
|
|
|
|
if (Record.size() != 8)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIObjCProperty, Record[0],
|
2015-02-13 01:43:22 +00:00
|
|
|
(Context, getMDString(Record[1]),
|
|
|
|
getMDOrNull(Record[2]), Record[3],
|
|
|
|
getMDString(Record[4]), getMDString(Record[5]),
|
|
|
|
Record[6], getMDOrNull(Record[7]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-13 01:46:02 +00:00
|
|
|
case bitc::METADATA_IMPORTED_ENTITY: {
|
|
|
|
if (Record.size() != 6)
|
|
|
|
return Error("Invalid record");
|
|
|
|
|
|
|
|
MDValueList.AssignValue(
|
2015-04-29 16:38:44 +00:00
|
|
|
GET_OR_DISTINCT(DIImportedEntity, Record[0],
|
2015-02-13 01:46:02 +00:00
|
|
|
(Context, Record[1], getMDOrNull(Record[2]),
|
|
|
|
getMDOrNull(Record[3]), Record[4],
|
|
|
|
getMDString(Record[5]))),
|
|
|
|
NextMDValueNo++);
|
|
|
|
break;
|
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
case bitc::METADATA_STRING: {
|
2014-06-25 15:41:00 +00:00
|
|
|
std::string String(Record.begin(), Record.end());
|
|
|
|
llvm::UpgradeMDStringConstant(String);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *MD = MDString::get(Context, String);
|
|
|
|
MDValueList.AssignValue(MD, 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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-05-28 14:10:31 +00:00
|
|
|
|
2009-09-28 21:14:55 +00:00
|
|
|
unsigned Kind = Record[0];
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<8> Name(Record.begin()+1, Record.end());
|
|
|
|
|
2009-12-29 09:01:33 +00:00
|
|
|
unsigned NewKind = TheModule->getMDKindID(Name.str());
|
2010-07-20 21:42:28 +00:00
|
|
|
if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Conflicting METADATA_KIND records");
|
2009-09-18 19:26:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
}
|
|
|
|
}
|
2015-02-03 21:54:14 +00:00
|
|
|
#undef GET_OR_DISTINCT
|
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.
|
2014-06-13 02:24:39 +00:00
|
|
|
std::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;
|
2014-12-03 02:08:38 +00:00
|
|
|
std::vector<std::pair<Function*, unsigned> > FunctionPrologueWorklist;
|
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);
|
2014-12-03 02:08:38 +00:00
|
|
|
FunctionPrologueWorklist.swap(FunctionPrologues);
|
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
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Expected a constant");
|
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 {
|
2015-06-06 20:44:53 +00:00
|
|
|
Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]);
|
|
|
|
if (!C)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Expected a constant");
|
2015-06-06 20:44:53 +00:00
|
|
|
GlobalAlias *Alias = AliasInitWorklist.back().first;
|
|
|
|
if (C->getType() != Alias->getType())
|
|
|
|
return Error("Alias and aliasee types don't match");
|
|
|
|
Alias->setAliasee(C);
|
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
|
|
|
}
|
2014-05-16 19:35:39 +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
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Expected a constant");
|
2013-09-16 01:08:15 +00:00
|
|
|
}
|
|
|
|
FunctionPrefixWorklist.pop_back();
|
|
|
|
}
|
|
|
|
|
2014-12-03 02:08:38 +00:00
|
|
|
while (!FunctionPrologueWorklist.empty()) {
|
|
|
|
unsigned ValID = FunctionPrologueWorklist.back().second;
|
|
|
|
if (ValID >= ValueList.size()) {
|
|
|
|
FunctionPrologues.push_back(FunctionPrologueWorklist.back());
|
|
|
|
} else {
|
|
|
|
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
|
|
|
|
FunctionPrologueWorklist.back().first->setPrologueData(C);
|
|
|
|
else
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Expected a constant");
|
2014-12-03 02:08:38 +00:00
|
|
|
}
|
|
|
|
FunctionPrologueWorklist.pop_back();
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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);
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseConstants() {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
|
|
|
if (NextCstNo != ValueList.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ronstant reference");
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
// Once all the constants have been read, go through and resolve forward
|
|
|
|
// references.
|
|
|
|
ValueList.ResolveConstantForwardRefs();
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-03-27 12:08:23 +00:00
|
|
|
if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
|
2007-04-24 04:04:35 +00:00
|
|
|
break;
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!CurTy->isIntegerTy() || Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-05-28 14:10:31 +00:00
|
|
|
APInt VInt = ReadWideAPInt(Record,
|
|
|
|
cast<IntegerType>(CurTy)->getBitWidth());
|
2012-05-12 10:48:17 +00:00
|
|
|
V = ConstantInt::get(Context, VInt);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-04-24 04:04:35 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-09-11 18:32:33 +00:00
|
|
|
case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
|
2007-04-24 04:04:35 +00:00
|
|
|
if (Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-12-17 00:04:22 +00:00
|
|
|
if (CurTy->isHalfTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf,
|
|
|
|
APInt(16, (uint16_t)Record[0])));
|
2011-12-17 00:04:22 +00:00
|
|
|
else if (CurTy->isFloatTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle,
|
|
|
|
APInt(32, (uint32_t)Record[0])));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isDoubleTy())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble,
|
|
|
|
APInt(64, Record[0])));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isX86_FP80Ty()) {
|
2009-03-23 21:16:53 +00:00
|
|
|
// Bits are not stored the same way as a normal i80 APInt, compensate.
|
|
|
|
uint64_t Rearrange[2];
|
|
|
|
Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
|
|
|
|
Rearrange[1] = Record[0] >> 48;
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended,
|
|
|
|
APInt(80, Rearrange)));
|
2009-10-05 05:54:46 +00:00
|
|
|
} else if (CurTy->isFP128Ty())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad,
|
|
|
|
APInt(128, Record)));
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (CurTy->isPPC_FP128Ty())
|
2013-01-22 09:46:31 +00:00
|
|
|
V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble,
|
|
|
|
APInt(128, Record)));
|
2007-04-24 03:30:34 +00:00
|
|
|
else
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy);
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
2007-09-11 18:32:33 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
|
|
|
|
if (Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
unsigned Size = Record.size();
|
2012-01-27 03:15:49 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *STy = dyn_cast<StructType>(CurTy)) {
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i],
|
2007-04-24 05:48:56 +00:00
|
|
|
STy->getElementType(i)));
|
2009-07-27 22:29:26 +00:00
|
|
|
V = ConstantStruct::get(STy, Elts);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
|
|
|
|
Type *EltTy = ATy->getElementType();
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
2009-07-28 18:32:17 +00:00
|
|
|
V = ConstantArray::get(ATy, Elts);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
|
|
|
|
Type *EltTy = VTy->getElementType();
|
2007-04-24 05:48:56 +00:00
|
|
|
for (unsigned i = 0; i != Size; ++i)
|
2007-05-04 19:11:41 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
2009-07-28 21:19:26 +00:00
|
|
|
V = ConstantVector::get(Elts);
|
2007-04-24 05:48:56 +00:00
|
|
|
} else {
|
2009-07-30 23:03:37 +00:00
|
|
|
V = UndefValue::get(CurTy);
|
2007-04-24 05:48:56 +00:00
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-02-05 02:41:35 +00:00
|
|
|
case bitc::CST_CODE_STRING: // STRING: [values]
|
2007-05-06 00:53:07 +00:00
|
|
|
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
|
|
|
|
if (Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallString<16> Elts(Record.begin(), Record.end());
|
2012-02-05 02:41:35 +00:00
|
|
|
V = ConstantDataArray::getString(Context, Elts,
|
|
|
|
BitCode == bitc::CST_CODE_CSTRING);
|
2007-05-06 00:35:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-01-30 00:51:16 +00:00
|
|
|
case bitc::CST_CODE_DATA: {// DATA: [n x value]
|
|
|
|
if (Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-01-30 00:51:16 +00:00
|
|
|
Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
|
|
|
|
unsigned Size = Record.size();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-01-30 00:51:16 +00:00
|
|
|
if (EltTy->isIntegerTy(8)) {
|
|
|
|
SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(16)) {
|
|
|
|
SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(32)) {
|
|
|
|
SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isIntegerTy(64)) {
|
|
|
|
SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
|
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isFloatTy()) {
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallVector<float, 16> Elts(Size);
|
|
|
|
std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat);
|
2012-01-30 00:51:16 +00:00
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else if (EltTy->isDoubleTy()) {
|
2012-05-28 14:10:31 +00:00
|
|
|
SmallVector<double, 16> Elts(Size);
|
|
|
|
std::transform(Record.begin(), Record.end(), Elts.begin(),
|
|
|
|
BitsToDouble);
|
2012-01-30 00:51:16 +00:00
|
|
|
if (isa<VectorType>(CurTy))
|
|
|
|
V = ConstantDataVector::get(Context, Elts);
|
|
|
|
else
|
|
|
|
V = ConstantDataArray::get(Context, Elts);
|
|
|
|
} else {
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type for value");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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]
|
2015-03-13 21:03:36 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Type *PointeeType = nullptr;
|
|
|
|
if (Record.size() % 2)
|
|
|
|
PointeeType = getTypeByID(Record[OpNum++]);
|
2007-04-24 07:07:11 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
2015-03-13 21:03:36 +00:00
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Type *ElTy = getTypeByID(Record[OpNum++]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!ElTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-03-13 21:03:36 +00:00
|
|
|
Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
2015-03-13 21:03:36 +00:00
|
|
|
|
|
|
|
if (PointeeType &&
|
2015-04-02 18:55:32 +00:00
|
|
|
PointeeType !=
|
|
|
|
cast<SequentialType>(Elts[0]->getType()->getScalarType())
|
|
|
|
->getElementType())
|
2015-03-16 22:03:50 +00:00
|
|
|
return Error("Explicit gep operator type does not match pointee type "
|
|
|
|
"of pointer operand");
|
2015-04-02 18:55:32 +00:00
|
|
|
|
|
|
|
ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
|
|
|
|
V = ConstantExpr::getGetElementPtr(PointeeType, 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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2013-09-12 22:02:31 +00:00
|
|
|
|
|
|
|
Type *SelectorTy = Type::getInt1Ty(Context);
|
|
|
|
|
|
|
|
// If CurTy is a vector of length n, then Record[0] must be a <n x i1>
|
|
|
|
// vector. Otherwise, it must be a single bit.
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
|
|
|
|
SelectorTy = VectorType::get(Type::getInt1Ty(Context),
|
|
|
|
VTy->getNumElements());
|
|
|
|
|
|
|
|
V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
|
|
|
|
SelectorTy),
|
|
|
|
ValueList.getConstantFwdRef(Record[1],CurTy),
|
|
|
|
ValueList.getConstantFwdRef(Record[2],CurTy));
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
2013-09-12 22:02:31 +00:00
|
|
|
}
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
case bitc::CST_CODE_CE_EXTRACTELT
|
|
|
|
: { // CE_EXTRACTELT: [opty, opval, opty, opval]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 3)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *OpTy =
|
2007-04-24 07:07:11 +00:00
|
|
|
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Constant *Op1 = nullptr;
|
|
|
|
if (Record.size() == 4) {
|
|
|
|
Type *IdxTy = getTypeByID(Record[2]);
|
|
|
|
if (!IdxTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
|
|
|
|
} else // TODO: Remove with llvm 4.0
|
|
|
|
Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
|
|
|
|
if (!Op1)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getExtractElement(Op0, Op1);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
case bitc::CST_CODE_CE_INSERTELT
|
|
|
|
: { // CE_INSERTELT: [opval, opval, opty, 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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
|
|
|
|
OpTy->getElementType());
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Constant *Op2 = nullptr;
|
|
|
|
if (Record.size() == 4) {
|
|
|
|
Type *IdxTy = getTypeByID(Record[2]);
|
|
|
|
if (!IdxTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
|
|
|
|
} else // TODO: Remove with llvm 4.0
|
|
|
|
Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
|
|
|
|
if (!Op2)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
|
|
|
|
Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
|
2009-07-07 20:18:58 +00:00
|
|
|
OpTy->getNumElements());
|
2007-04-24 07:07:11 +00:00
|
|
|
Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
|
2009-07-29 18:55:55 +00:00
|
|
|
V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
|
2007-04-24 07:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-02-12 21:28:33 +00:00
|
|
|
case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *RTy = dyn_cast<VectorType>(CurTy);
|
|
|
|
VectorType *OpTy =
|
2010-10-28 15:47:26 +00:00
|
|
|
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Record.size() < 4 || !RTy || !OpTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-06 01:58:20 +00:00
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:58:20 +00:00
|
|
|
for (unsigned i = 0; i != AsmStrSize; ++i)
|
|
|
|
AsmStr += (char)Record[2+i];
|
|
|
|
for (unsigned i = 0; i != ConstStrSize; ++i)
|
|
|
|
ConstrStr += (char)Record[3+AsmStrSize+i];
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = cast<PointerType>(CurTy);
|
2007-05-06 01:58:20 +00:00
|
|
|
V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
|
2009-10-21 23:28:00 +00:00
|
|
|
AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
|
2007-05-06 01:58:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-09-05 19:00:49 +00:00
|
|
|
// This version adds support for the asm dialect keywords (e.g.,
|
|
|
|
// inteldialect).
|
2012-09-05 00:56:20 +00:00
|
|
|
case bitc::CST_CODE_INLINEASM: {
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 2)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-09-05 00:56:20 +00:00
|
|
|
unsigned ConstStrSize = Record[2+AsmStrSize];
|
|
|
|
if (3+AsmStrSize+ConstStrSize > Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FnTy = getTypeByID(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!FnTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-09-21 14:34:31 +00:00
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
// Don't let Fn get dematerialized.
|
|
|
|
BlockAddressesTaken.insert(Fn);
|
|
|
|
|
2012-09-21 14:34:31 +00:00
|
|
|
// If the function is already parsed we can insert the block address right
|
|
|
|
// away.
|
2014-08-01 21:51:52 +00:00
|
|
|
BasicBlock *BB;
|
|
|
|
unsigned BBID = Record[2];
|
|
|
|
if (!BBID)
|
|
|
|
// Invalid reference to entry block.
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
2012-09-21 14:34:31 +00:00
|
|
|
if (!Fn->empty()) {
|
|
|
|
Function::iterator BBI = Fn->begin(), BBE = Fn->end();
|
2014-08-01 21:51:52 +00:00
|
|
|
for (size_t I = 0, E = BBID; I != E; ++I) {
|
2012-09-21 14:34:31 +00:00
|
|
|
if (BBI == BBE)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
2012-09-21 14:34:31 +00:00
|
|
|
++BBI;
|
|
|
|
}
|
2014-08-01 21:51:52 +00:00
|
|
|
BB = BBI;
|
2012-09-21 14:34:31 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise insert a placeholder and remember it so it can be inserted
|
|
|
|
// when the function is parsed.
|
2014-08-05 17:49:48 +00:00
|
|
|
auto &FwdBBs = BasicBlockFwdRefs[Fn];
|
|
|
|
if (FwdBBs.empty())
|
|
|
|
BasicBlockFwdRefQueue.push_back(Fn);
|
2014-08-16 01:54:37 +00:00
|
|
|
if (FwdBBs.size() < BBID + 1)
|
|
|
|
FwdBBs.resize(BBID + 1);
|
|
|
|
if (!FwdBBs[BBID])
|
|
|
|
FwdBBs[BBID] = BasicBlock::Create(Context);
|
|
|
|
BB = FwdBBs[BBID];
|
2012-09-21 14:34:31 +00:00
|
|
|
}
|
2014-08-01 21:51:52 +00:00
|
|
|
V = BlockAddress::get(Fn, BB);
|
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
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseUseLists() {
|
2011-12-07 21:44:12 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-12-07 21:44:12 +00:00
|
|
|
|
|
|
|
// Read all the records.
|
2014-07-28 21:19:41 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2011-12-07 21:44:12 +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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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();
|
2014-07-28 21:19:41 +00:00
|
|
|
bool IsBB = false;
|
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;
|
2014-07-28 21:19:41 +00:00
|
|
|
case bitc::USELIST_CODE_BB:
|
|
|
|
IsBB = true;
|
|
|
|
// fallthrough
|
|
|
|
case bitc::USELIST_CODE_DEFAULT: {
|
2011-12-07 21:44:12 +00:00
|
|
|
unsigned RecordLength = Record.size();
|
2014-07-28 21:19:41 +00:00
|
|
|
if (RecordLength < 3)
|
|
|
|
// Records should have at least an ID and two indexes.
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-07-28 21:19:41 +00:00
|
|
|
unsigned ID = Record.back();
|
|
|
|
Record.pop_back();
|
|
|
|
|
|
|
|
Value *V;
|
|
|
|
if (IsBB) {
|
|
|
|
assert(ID < FunctionBBs.size() && "Basic block not found");
|
|
|
|
V = FunctionBBs[ID];
|
|
|
|
} else
|
|
|
|
V = ValueList[ID];
|
|
|
|
unsigned NumUses = 0;
|
|
|
|
SmallDenseMap<const Use *, unsigned, 16> Order;
|
|
|
|
for (const Use &U : V->uses()) {
|
2014-08-16 01:54:34 +00:00
|
|
|
if (++NumUses > Record.size())
|
2014-07-28 21:19:41 +00:00
|
|
|
break;
|
2014-08-16 01:54:34 +00:00
|
|
|
Order[&U] = Record[NumUses - 1];
|
2014-07-28 21:19:41 +00:00
|
|
|
}
|
|
|
|
if (Order.size() != Record.size() || NumUses > Record.size())
|
|
|
|
// Mismatches can happen if the functions are being materialized lazily
|
|
|
|
// (out-of-order), or a value has been upgraded.
|
|
|
|
break;
|
|
|
|
|
|
|
|
V->sortUseList([&](const Use &L, const Use &R) {
|
|
|
|
return Order.lookup(&L) < Order.lookup(&R);
|
|
|
|
});
|
2011-12-07 21:44:12 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-13 19:24:30 +00:00
|
|
|
/// When we see the block for metadata, remember where it is and then skip it.
|
|
|
|
/// This lets us lazily deserialize the metadata.
|
|
|
|
std::error_code BitcodeReader::rememberAndSkipMetadata() {
|
|
|
|
// Save the current stream state.
|
|
|
|
uint64_t CurBit = Stream.GetCurrentBitNo();
|
|
|
|
DeferredMetadataInfo.push_back(CurBit);
|
|
|
|
|
|
|
|
// Skip over the block for now.
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Invalid record");
|
|
|
|
return std::error_code();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::error_code BitcodeReader::materializeMetadata() {
|
|
|
|
for (uint64_t BitPos : DeferredMetadataInfo) {
|
|
|
|
// Move the bit stream to the saved position.
|
|
|
|
Stream.JumpToBit(BitPos);
|
|
|
|
if (std::error_code EC = ParseMetadata())
|
|
|
|
return EC;
|
|
|
|
}
|
|
|
|
DeferredMetadataInfo.clear();
|
|
|
|
return std::error_code();
|
|
|
|
}
|
|
|
|
|
2015-04-01 14:44:59 +00:00
|
|
|
void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; }
|
2015-03-30 21:36:43 +00:00
|
|
|
|
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.
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::RememberAndSkipFunctionBody() {
|
2007-05-01 04:59:48 +00:00
|
|
|
// Get the function we are talking about.
|
|
|
|
if (FunctionsWithBodies.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Insufficient function protos");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
Function *Fn = FunctionsWithBodies.back();
|
|
|
|
FunctionsWithBodies.pop_back();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// Save the current stream state.
|
|
|
|
uint64_t CurBit = Stream.GetCurrentBitNo();
|
2010-01-27 20:34:15 +00:00
|
|
|
DeferredFunctionInfo[Fn] = CurBit;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// Skip over the function block for now.
|
|
|
|
if (Stream.SkipBlock())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed global initializer set");
|
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();
|
2014-05-16 20:39:27 +00:00
|
|
|
GI != GE;) {
|
|
|
|
GlobalVariable *GV = GI++;
|
|
|
|
UpgradeGlobalVariable(GV);
|
|
|
|
}
|
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
// 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);
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
2015-03-13 19:24:30 +00:00
|
|
|
std::error_code BitcodeReader::ParseModule(bool Resume,
|
|
|
|
bool ShouldLazyLoadMetadata) {
|
2012-02-06 22:30:29 +00:00
|
|
|
if (Resume)
|
|
|
|
Stream.JumpToBit(NextUnreadBit);
|
|
|
|
else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2007-05-05 18:57:30 +00:00
|
|
|
break;
|
2007-05-04 03:30:17 +00:00
|
|
|
case bitc::PARAMATTR_BLOCK_ID:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseAttributeBlock())
|
2013-11-04 16:16:24 +00:00
|
|
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseAttributeGroupBlock())
|
2013-11-04 16:16:24 +00:00
|
|
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseTypeTable())
|
2013-11-04 16:16:24 +00:00
|
|
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseValueSymbolTable())
|
2013-11-04 16:16:24 +00:00
|
|
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseConstants())
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ResolveGlobalAndAliasInits())
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2007-04-24 03:30:34 +00:00
|
|
|
break;
|
2009-07-22 17:43:22 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
2015-03-13 19:24:30 +00:00
|
|
|
if (ShouldLazyLoadMetadata && !IsMetadataMaterialized) {
|
|
|
|
if (std::error_code EC = rememberAndSkipMetadata())
|
|
|
|
return EC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata");
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseMetadata())
|
2013-11-04 16:16:24 +00:00
|
|
|
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());
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = GlobalCleanup())
|
2013-11-04 16:16:24 +00:00
|
|
|
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
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = RememberAndSkipFunctionBody())
|
2013-11-04 16:16:24 +00:00
|
|
|
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();
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseUseLists())
|
2013-11-04 16:16:24 +00:00
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// 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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid value");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-08-17 18:44:35 +00:00
|
|
|
GCTable.push_back(S);
|
2007-12-10 03:18:06 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-06-27 18:19:56 +00:00
|
|
|
case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name]
|
|
|
|
if (Record.size() < 2)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-06-27 18:19:56 +00:00
|
|
|
Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
|
|
|
|
unsigned ComdatNameSize = Record[1];
|
|
|
|
std::string ComdatName;
|
|
|
|
ComdatName.reserve(ComdatNameSize);
|
|
|
|
for (unsigned i = 0; i != ComdatNameSize; ++i)
|
|
|
|
ComdatName += (char)Record[2 + i];
|
|
|
|
Comdat *C = TheModule->getOrInsertComdat(ComdatName);
|
|
|
|
C->setSelectionKind(SK);
|
|
|
|
ComdatList.push_back(C);
|
|
|
|
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,
|
2015-02-04 00:42:45 +00:00
|
|
|
// unnamed_addr, externally_initialized, dllstorageclass,
|
|
|
|
// comdat]
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-27 19:58:56 +00:00
|
|
|
bool isConstant = Record[1] & 1;
|
|
|
|
bool explicitType = Record[1] & 2;
|
|
|
|
unsigned AddressSpace;
|
|
|
|
if (explicitType) {
|
|
|
|
AddressSpace = Record[1] >> 2;
|
|
|
|
} else {
|
|
|
|
if (!Ty->isPointerTy())
|
|
|
|
return Error("Invalid type for value");
|
|
|
|
AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
|
|
|
|
Ty = cast<PointerType>(Ty)->getElementType();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-01-19 15:16:06 +00:00
|
|
|
uint64_t RawLinkage = Record[3];
|
|
|
|
GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Alignment;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[4], Alignment))
|
|
|
|
return EC;
|
2007-04-22 06:23:29 +00:00
|
|
|
std::string Section;
|
|
|
|
if (Record[5]) {
|
|
|
|
if (Record[5]-1 >= SectionTable.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
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;
|
2014-05-07 22:57:20 +00:00
|
|
|
// Local linkage must have default visibility.
|
|
|
|
if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
|
|
|
|
// FIXME: Change to an error if non-default in 4.0.
|
2007-05-06 19:27:46 +00:00
|
|
|
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
|
2015-01-19 15:16:06 +00:00
|
|
|
UpgradeDLLImportExportLinkage(NewGV, RawLinkage);
|
2014-01-14 15:22:47 +00:00
|
|
|
|
2007-04-23 21:26:05 +00:00
|
|
|
ValueList.push_back(NewGV);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 00:18:21 +00:00
|
|
|
// Remember which value to use for the global initializer.
|
|
|
|
if (unsigned InitID = Record[2])
|
|
|
|
GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
|
2014-06-27 18:19:56 +00:00
|
|
|
|
2015-01-19 15:16:06 +00:00
|
|
|
if (Record.size() > 11) {
|
2014-06-27 18:19:56 +00:00
|
|
|
if (unsigned ComdatID = Record[11]) {
|
2015-05-26 23:00:56 +00:00
|
|
|
if (ComdatID > ComdatList.size())
|
|
|
|
return Error("Invalid global variable comdat ID");
|
2014-06-27 18:19:56 +00:00
|
|
|
NewGV->setComdat(ComdatList[ComdatID - 1]);
|
|
|
|
}
|
2015-01-19 15:16:06 +00:00
|
|
|
} else if (hasImplicitComdat(RawLinkage)) {
|
|
|
|
NewGV->setComdat(reinterpret_cast<Comdat *>(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,
|
2014-12-03 02:08:38 +00:00
|
|
|
// prologuedata, dllstorageclass, comdat, prefixdata]
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-17 16:28:26 +00:00
|
|
|
if (auto *PTy = dyn_cast<PointerType>(Ty))
|
|
|
|
Ty = PTy->getElementType();
|
|
|
|
auto *FTy = dyn_cast<FunctionType>(Ty);
|
2007-04-22 06:23:29 +00:00
|
|
|
if (!FTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type for value");
|
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];
|
2015-01-19 15:16:06 +00:00
|
|
|
uint64_t RawLinkage = Record[3];
|
|
|
|
Func->setLinkage(getDecodedLinkage(RawLinkage));
|
2008-09-25 21:00:45 +00:00
|
|
|
Func->setAttributes(getAttributes(Record[4]));
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Alignment;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[5], Alignment))
|
|
|
|
return EC;
|
|
|
|
Func->setAlignment(Alignment);
|
2007-05-08 05:38:01 +00:00
|
|
|
if (Record[6]) {
|
|
|
|
if (Record[6]-1 >= SectionTable.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
2007-05-08 05:38:01 +00:00
|
|
|
Func->setSection(SectionTable[Record[6]-1]);
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
2014-05-07 22:57:20 +00:00
|
|
|
// Local linkage must have default visibility.
|
|
|
|
if (!Func->hasLocalLinkage())
|
|
|
|
// FIXME: Change to an error if non-default in 4.0.
|
|
|
|
Func->setVisibility(GetDecodedVisibility(Record[7]));
|
2007-12-10 03:18:06 +00:00
|
|
|
if (Record.size() > 8 && Record[8]) {
|
2015-04-30 04:09:41 +00:00
|
|
|
if (Record[8]-1 >= GCTable.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
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)
|
2014-12-03 02:08:38 +00:00
|
|
|
FunctionPrologues.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
|
2015-01-19 15:16:06 +00:00
|
|
|
UpgradeDLLImportExportLinkage(Func, RawLinkage);
|
2014-01-14 15:22:47 +00:00
|
|
|
|
2015-01-19 15:16:06 +00:00
|
|
|
if (Record.size() > 12) {
|
2014-06-27 18:19:56 +00:00
|
|
|
if (unsigned ComdatID = Record[12]) {
|
2015-05-26 23:00:56 +00:00
|
|
|
if (ComdatID > ComdatList.size())
|
|
|
|
return Error("Invalid function comdat ID");
|
2014-06-27 18:19:56 +00:00
|
|
|
Func->setComdat(ComdatList[ComdatID - 1]);
|
|
|
|
}
|
2015-01-19 15:16:06 +00:00
|
|
|
} else if (hasImplicitComdat(RawLinkage)) {
|
|
|
|
Func->setComdat(reinterpret_cast<Comdat *>(1));
|
|
|
|
}
|
2014-06-27 18:19:56 +00:00
|
|
|
|
2014-12-03 02:08:38 +00:00
|
|
|
if (Record.size() > 13 && Record[13] != 0)
|
|
|
|
FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));
|
|
|
|
|
2007-04-23 21:26:05 +00:00
|
|
|
ValueList.push_back(Func);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 04:59:48 +00:00
|
|
|
// If this is a function with a body, remember the prototype we are
|
|
|
|
// creating now, so that we can match up the body with them later.
|
2012-02-06 22:30:29 +00:00
|
|
|
if (!isProto) {
|
2014-10-24 18:13:04 +00:00
|
|
|
Func->setIsMaterializable(true);
|
2007-05-01 04:59:48 +00:00
|
|
|
FunctionsWithBodies.push_back(Func);
|
2014-10-23 15:20:05 +00:00
|
|
|
if (LazyStreamer)
|
|
|
|
DeferredFunctionInfo[Func] = 0;
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-05-16 14:22:33 +00:00
|
|
|
auto *PTy = dyn_cast<PointerType>(Ty);
|
|
|
|
if (!PTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type for value");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2014-05-16 14:22:33 +00:00
|
|
|
auto *NewGA =
|
2015-04-29 21:22:39 +00:00
|
|
|
GlobalAlias::create(PTy, getDecodedLinkage(Record[2]), "", TheModule);
|
2008-03-12 00:49:19 +00:00
|
|
|
// Old bitcode files didn't have visibility field.
|
2014-05-07 22:57:20 +00:00
|
|
|
// Local linkage must have default visibility.
|
|
|
|
if (Record.size() > 3 && !NewGA->hasLocalLinkage())
|
|
|
|
// FIXME: Change to an error if non-default in 4.0.
|
2008-03-12 00:49:19 +00:00
|
|
|
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]);
|
2014-05-28 18:15:43 +00:00
|
|
|
if (Record.size() > 5)
|
2014-10-29 23:44:35 +00:00
|
|
|
NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5]));
|
2014-06-06 01:20:28 +00:00
|
|
|
if (Record.size() > 6)
|
2014-10-29 23:44:35 +00:00
|
|
|
NewGA->setUnnamedAddr(Record[6]);
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-04-26 03:27:58 +00:00
|
|
|
ValueList.shrinkTo(Record[0]);
|
|
|
|
break;
|
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-13 19:24:30 +00:00
|
|
|
std::error_code BitcodeReader::ParseBitcodeInto(Module *M,
|
|
|
|
bool ShouldLazyLoadMetadata) {
|
2014-04-15 06:32:26 +00:00
|
|
|
TheModule = nullptr;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = InitStream())
|
2013-11-04 16:16:24 +00:00
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode signature");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:23:29 +00:00
|
|
|
// We expect a number of well-defined blocks, though we don't necessarily
|
|
|
|
// need to understand them all.
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
2015-04-14 14:07:15 +00:00
|
|
|
if (Stream.AtEndOfStream()) {
|
|
|
|
if (TheModule)
|
|
|
|
return std::error_code();
|
|
|
|
// We didn't really read a proper Module.
|
|
|
|
return Error("Malformed IR file");
|
|
|
|
}
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid multiple blocks");
|
2013-01-20 02:13:19 +00:00
|
|
|
TheModule = M;
|
2015-03-13 19:24:30 +00:00
|
|
|
if (std::error_code EC = ParseModule(false, ShouldLazyLoadMetadata))
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
|
|
|
if (LazyStreamer)
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2013-01-20 02:13:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (Stream.SkipBlock())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-05-26 18:59:54 +00:00
|
|
|
}
|
2007-04-22 06:23:29 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-29 07:54:31 +00:00
|
|
|
|
2014-07-04 20:02:42 +00:00
|
|
|
ErrorOr<std::string> BitcodeReader::parseModuleTriple() {
|
2010-10-06 01:22:42 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2010-10-06 01:22:42 +00:00
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
|
2014-07-04 20:02:42 +00:00
|
|
|
std::string Triple;
|
2010-10-06 01:22:42 +00:00
|
|
|
// 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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-07-04 20:05:56 +00:00
|
|
|
return Triple;
|
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]
|
2014-07-04 20:02:42 +00:00
|
|
|
std::string S;
|
|
|
|
if (ConvertToString(Record, 0, S))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-07-04 20:02:42 +00:00
|
|
|
Triple = S;
|
2010-10-06 01:22:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Record.clear();
|
|
|
|
}
|
2014-07-04 20:05:56 +00:00
|
|
|
llvm_unreachable("Exit infinite loop");
|
2010-10-06 01:22:42 +00:00
|
|
|
}
|
|
|
|
|
2014-07-04 20:02:42 +00:00
|
|
|
ErrorOr<std::string> BitcodeReader::parseTriple() {
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = InitStream())
|
2013-11-04 16:16:24 +00:00
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode signature");
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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)
|
2014-07-04 13:52:01 +00:00
|
|
|
return parseModuleTriple();
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
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.
|
2015-04-24 22:04:41 +00:00
|
|
|
std::error_code BitcodeReader::ParseMetadataAttachment(Function &F) {
|
2009-09-18 19:26:43 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2013-01-20 02:13:19 +00:00
|
|
|
while (1) {
|
|
|
|
BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
|
2013-02-06 22:14:06 +00:00
|
|
|
|
2013-01-20 02:13:19 +00:00
|
|
|
switch (Entry.Kind) {
|
|
|
|
case BitstreamEntry::SubBlock: // Handled for us already.
|
|
|
|
case BitstreamEntry::Error:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
2013-01-20 02:13:19 +00:00
|
|
|
case BitstreamEntry::EndBlock:
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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();
|
2015-04-24 22:04:41 +00:00
|
|
|
if (Record.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-24 22:04:41 +00:00
|
|
|
if (RecordLength % 2 == 0) {
|
|
|
|
// A function attachment.
|
|
|
|
for (unsigned I = 0; I != RecordLength; I += 2) {
|
|
|
|
auto K = MDKindMap.find(Record[I]);
|
|
|
|
if (K == MDKindMap.end())
|
|
|
|
return Error("Invalid ID");
|
|
|
|
Metadata *MD = MDValueList.getValueFwdRef(Record[I + 1]);
|
|
|
|
F.setMetadata(K->second, cast<MDNode>(MD));
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// An instruction attachment.
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]);
|
|
|
|
if (isa<LocalAsMetadata>(Node))
|
2014-12-06 02:29:44 +00:00
|
|
|
// Drop the attachment. This used to be legal, but there's no
|
|
|
|
// upgrade path.
|
|
|
|
break;
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +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
|
|
|
|
2015-05-18 21:48:55 +00:00
|
|
|
static std::error_code TypeCheckLoadStoreInst(DiagnosticHandlerFunction DH,
|
|
|
|
Type *ValType, Type *PtrType) {
|
|
|
|
if (!isa<PointerType>(PtrType))
|
|
|
|
return Error(DH, "Load/Store operand is not a pointer type");
|
|
|
|
Type *ElemType = cast<PointerType>(PtrType)->getElementType();
|
|
|
|
|
|
|
|
if (ValType && ValType != ElemType)
|
|
|
|
return Error(DH, "Explicit load/store type does not match pointee type of "
|
|
|
|
"pointer operand");
|
|
|
|
if (!PointerType::isLoadableOrStorableType(ElemType))
|
|
|
|
return Error(DH, "Cannot load/store from pointer");
|
|
|
|
return std::error_code();
|
|
|
|
}
|
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
/// ParseFunctionBody - Lazily parse the specified function body block.
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::ParseFunctionBody(Function *F) {
|
2007-05-05 00:17:00 +00:00
|
|
|
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-02-25 08:30:17 +00:00
|
|
|
InstructionList.clear();
|
2007-05-01 05:52:21 +00:00
|
|
|
unsigned ModuleValueListSize = ValueList.size();
|
2010-08-25 20:22:53 +00:00
|
|
|
unsigned ModuleMDValueListSize = MDValueList.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 05:52:21 +00:00
|
|
|
// Add all the function arguments to the value table.
|
|
|
|
for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
|
|
|
|
ValueList.push_back(I);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
unsigned NextValueNo = ValueList.size();
|
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;
|
2015-01-09 02:51:45 +00:00
|
|
|
auto getLastInstruction = [&]() -> Instruction * {
|
|
|
|
if (CurBB && !CurBB->empty())
|
|
|
|
return &CurBB->back();
|
|
|
|
else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
|
|
|
|
!FunctionBBs[CurBBNo - 1]->empty())
|
|
|
|
return &FunctionBBs[CurBBNo - 1]->back();
|
|
|
|
return nullptr;
|
|
|
|
};
|
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:
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Malformed block");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-01 05:52:21 +00:00
|
|
|
break;
|
|
|
|
case bitc::CONSTANTS_BLOCK_ID:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseConstants())
|
2013-11-04 16:16:24 +00:00
|
|
|
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:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseValueSymbolTable())
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2007-05-01 05:52:21 +00:00
|
|
|
break;
|
2009-09-18 19:26:43 +00:00
|
|
|
case bitc::METADATA_ATTACHMENT_ID:
|
2015-04-24 22:04:41 +00:00
|
|
|
if (std::error_code EC = ParseMetadataAttachment(*F))
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2009-09-20 02:20:51 +00:00
|
|
|
break;
|
2010-01-13 19:34:08 +00:00
|
|
|
case bitc::METADATA_BLOCK_ID:
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseMetadata())
|
2013-11-04 16:16:24 +00:00
|
|
|
return EC;
|
2010-01-13 19:34:08 +00:00
|
|
|
break;
|
2014-07-28 21:19:41 +00:00
|
|
|
case bitc::USELIST_BLOCK_ID:
|
|
|
|
if (std::error_code EC = ParseUseLists())
|
|
|
|
return EC;
|
|
|
|
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
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid value");
|
2014-08-01 21:51:52 +00:00
|
|
|
case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
|
2007-05-01 07:01:57 +00:00
|
|
|
if (Record.size() < 1 || Record[0] == 0)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-01 05:52:21 +00:00
|
|
|
// Create all the basic blocks for the function.
|
2007-05-03 22:09:51 +00:00
|
|
|
FunctionBBs.resize(Record[0]);
|
2014-08-01 21:51:52 +00:00
|
|
|
|
|
|
|
// See if anything took the address of blocks in this function.
|
|
|
|
auto BBFRI = BasicBlockFwdRefs.find(F);
|
|
|
|
if (BBFRI == BasicBlockFwdRefs.end()) {
|
|
|
|
for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
|
|
|
|
FunctionBBs[i] = BasicBlock::Create(Context, "", F);
|
|
|
|
} else {
|
|
|
|
auto &BBRefs = BBFRI->second;
|
2014-08-16 01:54:37 +00:00
|
|
|
// Check for invalid basic block references.
|
|
|
|
if (BBRefs.size() > FunctionBBs.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid ID");
|
2014-08-16 01:54:37 +00:00
|
|
|
assert(!BBRefs.empty() && "Unexpected empty array");
|
|
|
|
assert(!BBRefs.front() && "Invalid reference to entry block");
|
|
|
|
for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
|
|
|
|
++I)
|
|
|
|
if (I < RE && BBRefs[I]) {
|
|
|
|
BBRefs[I]->insertInto(F);
|
|
|
|
FunctionBBs[I] = BBRefs[I];
|
2014-08-01 21:51:52 +00:00
|
|
|
} else {
|
|
|
|
FunctionBBs[I] = BasicBlock::Create(Context, "", F);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Erase from the table.
|
|
|
|
BasicBlockFwdRefs.erase(BBFRI);
|
|
|
|
}
|
|
|
|
|
2007-05-01 07:01:57 +00:00
|
|
|
CurBB = FunctionBBs[0];
|
|
|
|
continue;
|
2014-08-01 21:51:52 +00:00
|
|
|
}
|
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.
|
2015-01-09 02:51:45 +00:00
|
|
|
I = getLastInstruction();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!I)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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
|
|
|
|
2015-01-09 17:53:27 +00:00
|
|
|
case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
|
2015-01-09 02:51:45 +00:00
|
|
|
I = getLastInstruction();
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!I || Record.size() < 4)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
unsigned Line = Record[0], Col = Record[1];
|
|
|
|
unsigned ScopeID = Record[2], IAID = Record[3];
|
2012-11-15 22:34:00 +00:00
|
|
|
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-05-16 19:29:10 +00:00
|
|
|
I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2009-09-07 23:54:19 +00:00
|
|
|
if (OpNum < Record.size()) {
|
|
|
|
if (Opc == Instruction::Add ||
|
|
|
|
Opc == Instruction::Sub ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::Mul ||
|
|
|
|
Opc == Instruction::Shl) {
|
2010-01-25 21:55:39 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
|
2010-01-25 21:55:39 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
|
2011-02-06 21:44:57 +00:00
|
|
|
} else if (Opc == Instruction::SDiv ||
|
2011-02-07 16:40:21 +00:00
|
|
|
Opc == Instruction::UDiv ||
|
|
|
|
Opc == Instruction::LShr ||
|
|
|
|
Opc == Instruction::AShr) {
|
2011-02-06 21:44:57 +00:00
|
|
|
if (Record[OpNum] & (1 << bitc::PEO_EXACT))
|
2009-09-07 23:54:19 +00:00
|
|
|
cast<BinaryOperator>(I)->setIsExact(true);
|
2012-11-27 00:43:38 +00:00
|
|
|
} else if (isa<FPMathOperator>(I)) {
|
|
|
|
FastMathFlags FMF;
|
2012-12-09 21:12:04 +00:00
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::UnsafeAlgebra))
|
|
|
|
FMF.setUnsafeAlgebra();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoNaNs))
|
|
|
|
FMF.setNoNaNs();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoInfs))
|
|
|
|
FMF.setNoInfs();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::NoSignedZeros))
|
|
|
|
FMF.setNoSignedZeros();
|
|
|
|
if (0 != (Record[OpNum] & FastMathFlags::AllowReciprocal))
|
|
|
|
FMF.setAllowReciprocal();
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FMF.any())
|
|
|
|
I->setFastMathFlags(FMF);
|
2009-09-07 23:54:19 +00:00
|
|
|
}
|
2012-11-27 00:43:38 +00:00
|
|
|
|
2009-09-07 23:54:19 +00:00
|
|
|
}
|
2007-05-01 07:01:57 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
|
|
|
|
OpNum+2 != Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ResTy = getTypeByID(Record[OpNum]);
|
2007-05-06 00:21:25 +00:00
|
|
|
int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (Opc == -1 || !ResTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
|
|
|
}
|
2015-02-25 01:08:52 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD:
|
|
|
|
case bitc::FUNC_CODE_INST_GEP_OLD:
|
|
|
|
case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
|
2007-05-06 00:00:00 +00:00
|
|
|
unsigned OpNum = 0;
|
2015-02-25 01:08:52 +00:00
|
|
|
|
|
|
|
Type *Ty;
|
|
|
|
bool InBounds;
|
|
|
|
|
|
|
|
if (BitCode == bitc::FUNC_CODE_INST_GEP) {
|
|
|
|
InBounds = Record[OpNum++];
|
|
|
|
Ty = getTypeByID(Record[OpNum++]);
|
|
|
|
} else {
|
|
|
|
InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
|
|
|
|
Ty = nullptr;
|
|
|
|
}
|
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
Value *BasePtr;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-02 05:16:49 +00:00
|
|
|
|
2015-05-08 00:42:26 +00:00
|
|
|
if (!Ty)
|
|
|
|
Ty = cast<SequentialType>(BasePtr->getType()->getScalarType())
|
|
|
|
->getElementType();
|
|
|
|
else if (Ty !=
|
|
|
|
cast<SequentialType>(BasePtr->getType()->getScalarType())
|
|
|
|
->getElementType())
|
2015-03-16 21:35:48 +00:00
|
|
|
return Error(
|
|
|
|
"Explicit gep type does not match pointee type of pointer operand");
|
|
|
|
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-06 00:00:00 +00:00
|
|
|
GEPIdx.push_back(Op);
|
2007-05-02 05:16:49 +00:00
|
|
|
}
|
|
|
|
|
2015-03-14 19:53:33 +00:00
|
|
|
I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
|
2015-03-16 21:35:48 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2015-02-25 01:08:52 +00:00
|
|
|
if (InBounds)
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-05-23 01:55:30 +00:00
|
|
|
|
2015-05-16 00:33:12 +00:00
|
|
|
unsigned RecSize = Record.size();
|
|
|
|
if (OpNum == RecSize)
|
|
|
|
return Error("EXTRACTVAL: Invalid instruction with 0 indices");
|
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
SmallVector<unsigned, 4> EXTRACTVALIdx;
|
2015-02-16 00:03:11 +00:00
|
|
|
Type *CurTy = Agg->getType();
|
2015-05-16 00:33:12 +00:00
|
|
|
for (; OpNum != RecSize; ++OpNum) {
|
2015-02-16 00:03:11 +00:00
|
|
|
bool IsArray = CurTy->isArrayTy();
|
|
|
|
bool IsStruct = CurTy->isStructTy();
|
2008-05-31 00:58:22 +00:00
|
|
|
uint64_t Index = Record[OpNum];
|
2015-02-16 00:03:11 +00:00
|
|
|
|
|
|
|
if (!IsStruct && !IsArray)
|
|
|
|
return Error("EXTRACTVAL: Invalid type");
|
2008-05-31 00:58:22 +00:00
|
|
|
if ((unsigned)Index != Index)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid value");
|
2015-02-16 00:03:11 +00:00
|
|
|
if (IsStruct && Index >= CurTy->subtypes().size())
|
|
|
|
return Error("EXTRACTVAL: Invalid struct index");
|
|
|
|
if (IsArray && Index >= CurTy->getArrayNumElements())
|
|
|
|
return Error("EXTRACTVAL: Invalid array index");
|
2008-05-31 00:58:22 +00:00
|
|
|
EXTRACTVALIdx.push_back((unsigned)Index);
|
2015-02-16 00:03:11 +00:00
|
|
|
|
|
|
|
if (IsStruct)
|
|
|
|
CurTy = CurTy->subtypes()[Index];
|
|
|
|
else
|
|
|
|
CurTy = CurTy->subtypes()[0];
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-05-23 01:55:30 +00:00
|
|
|
Value *Val;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-05-23 01:55:30 +00:00
|
|
|
|
2015-05-16 00:33:12 +00:00
|
|
|
unsigned RecSize = Record.size();
|
|
|
|
if (OpNum == RecSize)
|
|
|
|
return Error("INSERTVAL: Invalid instruction with 0 indices");
|
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
SmallVector<unsigned, 4> INSERTVALIdx;
|
2015-02-16 00:03:11 +00:00
|
|
|
Type *CurTy = Agg->getType();
|
2015-05-16 00:33:12 +00:00
|
|
|
for (; OpNum != RecSize; ++OpNum) {
|
2015-02-16 00:03:11 +00:00
|
|
|
bool IsArray = CurTy->isArrayTy();
|
|
|
|
bool IsStruct = CurTy->isStructTy();
|
2008-05-31 00:58:22 +00:00
|
|
|
uint64_t Index = Record[OpNum];
|
2015-02-16 00:03:11 +00:00
|
|
|
|
|
|
|
if (!IsStruct && !IsArray)
|
|
|
|
return Error("INSERTVAL: Invalid type");
|
2008-05-31 00:58:22 +00:00
|
|
|
if ((unsigned)Index != Index)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid value");
|
2015-02-16 00:03:11 +00:00
|
|
|
if (IsStruct && Index >= CurTy->subtypes().size())
|
|
|
|
return Error("INSERTVAL: Invalid struct index");
|
|
|
|
if (IsArray && Index >= CurTy->getArrayNumElements())
|
|
|
|
return Error("INSERTVAL: Invalid array index");
|
|
|
|
|
2008-05-31 00:58:22 +00:00
|
|
|
INSERTVALIdx.push_back((unsigned)Index);
|
2015-02-16 00:03:11 +00:00
|
|
|
if (IsStruct)
|
|
|
|
CurTy = CurTy->subtypes()[Index];
|
|
|
|
else
|
|
|
|
CurTy = CurTy->subtypes()[0];
|
2008-05-23 01:55:30 +00:00
|
|
|
}
|
|
|
|
|
2015-05-18 22:27:11 +00:00
|
|
|
if (CurTy != Val->getType())
|
|
|
|
return Error("Inserted value type doesn't match aggregate type");
|
|
|
|
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-16 01:01:33 +00:00
|
|
|
I = SelectInst::Create(Cond, TrueVal, FalseVal);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-09-16 01:01:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-16 01:01:33 +00:00
|
|
|
case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
|
|
|
|
// new form of select
|
|
|
|
// handles select i1 or select [N x i1]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *TrueVal, *FalseVal, *Cond;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
|
2008-09-16 01:01:33 +00:00
|
|
|
getValueTypePair(Record, OpNum, NextValueNo, Cond))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-09-09 01:02:47 +00:00
|
|
|
|
|
|
|
// select condition can be either i1 or [N x i1]
|
2011-07-18 04:54:35 +00:00
|
|
|
if (VectorType* vector_type =
|
|
|
|
dyn_cast<VectorType>(Cond->getType())) {
|
2008-09-09 01:02:47 +00:00
|
|
|
// expect <n x i1>
|
2009-09-20 02:20:51 +00:00
|
|
|
if (vector_type->getElementType() != Type::getInt1Ty(Context))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type for value");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid type for value");
|
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) ||
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
getValueTypePair(Record, OpNum, NextValueNo, Idx))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-24 11:30:15 +00:00
|
|
|
if (!Vec->getType()->isVectorTy())
|
|
|
|
return Error("Invalid type for value");
|
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;
|
2015-04-24 11:30:15 +00:00
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Vec))
|
|
|
|
return Error("Invalid record");
|
|
|
|
if (!Vec->getType()->isVectorTy())
|
|
|
|
return Error("Invalid type for value");
|
|
|
|
if (popValue(Record, OpNum, NextValueNo,
|
2007-05-06 00:21:25 +00:00
|
|
|
cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
getValueTypePair(Record, OpNum, NextValueNo, Idx))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-04-06 20:25:17 +00:00
|
|
|
I = InsertElementInst::Create(Vec, Elt, Idx);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:21:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Vec1, *Vec2, *Mask;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-06 00:21:25 +00:00
|
|
|
|
2008-11-10 04:46:22 +00:00
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-24 11:30:15 +00:00
|
|
|
if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
|
|
|
|
return Error("Invalid type for value");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
if (LHS->getType()->isFPOrFPVectorTy())
|
2009-08-25 23:17:54 +00:00
|
|
|
I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
|
2009-07-08 03:04:38 +00:00
|
|
|
else
|
2009-08-25 23:17:54 +00:00
|
|
|
I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-09-09 01:02:47 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-07-08 03:04:38 +00:00
|
|
|
|
2007-05-02 04:27:25 +00:00
|
|
|
case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
|
2008-02-26 01:29:32 +00:00
|
|
|
{
|
|
|
|
unsigned Size = Record.size();
|
|
|
|
if (Size == 0) {
|
2009-08-13 21:58:54 +00:00
|
|
|
I = ReturnInst::Create(Context);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-02-26 01:29:32 +00:00
|
|
|
break;
|
2008-07-23 00:34:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned OpNum = 0;
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-06-17 18:09:11 +00:00
|
|
|
if (OpNum != Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-07-23 00:34:11 +00:00
|
|
|
|
2011-06-17 18:09:11 +00:00
|
|
|
I = ReturnInst::Create(Context, Op);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2008-07-23 00:34:11 +00:00
|
|
|
break;
|
2007-05-02 04:27:25 +00:00
|
|
|
}
|
2007-05-02 05:46:45 +00:00
|
|
|
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
|
2007-05-03 22:09:51 +00:00
|
|
|
if (Record.size() != 1 && Record.size() != 3)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-02 05:46:45 +00:00
|
|
|
BasicBlock *TrueDest = getBasicBlock(Record[0]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!TrueDest)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2008-04-06 20:25:17 +00:00
|
|
|
I = BranchInst::Create(TrueDest, FalseDest, Cond);
|
2009-09-20 02:20:51 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-10-27 19:13:16 +00:00
|
|
|
case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
|
2012-11-15 22:34:00 +00:00
|
|
|
// Check magic
|
2012-05-12 10:48:17 +00:00
|
|
|
if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
// "New" SwitchInst format with case ranges. The changes to write this
|
|
|
|
// format were reverted but we still recognize bitcode that uses it.
|
|
|
|
// Hopefully someday we will have support for case ranges and can use
|
|
|
|
// this format again.
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-05-12 10:48:17 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[1]);
|
|
|
|
unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
|
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
|
2012-05-12 10:48:17 +00:00
|
|
|
BasicBlock *Default = getBasicBlock(Record[3]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Cond || !Default)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
|
2007-05-02 05:46:45 +00:00
|
|
|
BasicBlock *Default = getBasicBlock(Record[2]);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Cond || !Default)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Address = getValue(Record, 1, NextValueNo, OpTy);
|
2014-04-15 06:32:26 +00:00
|
|
|
if (!OpTy || !Address)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-10-27 19:13:16 +00:00
|
|
|
unsigned NumDests = Record.size()-2;
|
2009-10-28 00:19:10 +00:00
|
|
|
IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
|
2009-10-27 19:13:16 +00:00
|
|
|
InstructionList.push_back(IBI);
|
|
|
|
for (unsigned i = 0, e = NumDests; i != e; ++i) {
|
|
|
|
if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
|
|
|
|
IBI->addDestination(DestBB);
|
|
|
|
} else {
|
|
|
|
delete IBI;
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-10-27 19:13:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
I = IBI;
|
|
|
|
break;
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-11-27 13:23:08 +00:00
|
|
|
case bitc::FUNC_CODE_INST_INVOKE: {
|
|
|
|
// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
|
2013-11-04 16:16:24 +00:00
|
|
|
if (Record.size() < 4)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-24 18:06:06 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
AttributeSet PAL = getAttributes(Record[OpNum++]);
|
|
|
|
unsigned CCInfo = Record[OpNum++];
|
|
|
|
BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
|
|
|
|
BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
|
|
|
|
|
|
|
|
FunctionType *FTy = nullptr;
|
|
|
|
if (CCInfo >> 13 & 1 &&
|
|
|
|
!(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
|
|
|
|
return Error("Explicit invoke type is not a function type");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
Value *Callee;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
|
2015-04-24 18:06:06 +00:00
|
|
|
if (!CalleeTy)
|
|
|
|
return Error("Callee is not a pointer");
|
|
|
|
if (!FTy) {
|
|
|
|
FTy = dyn_cast<FunctionType>(CalleeTy->getElementType());
|
|
|
|
if (!FTy)
|
|
|
|
return Error("Callee is not of pointer to function type");
|
|
|
|
} else if (CalleeTy->getElementType() != FTy)
|
|
|
|
return Error("Explicit invoke type does not match pointee type of "
|
|
|
|
"callee operand");
|
|
|
|
if (Record.size() < FTy->getNumParams() + OpNum)
|
|
|
|
return Error("Insufficient operands to call");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
if (!FTy->isVarArg()) {
|
|
|
|
if (Record.size() != OpNum)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-06 00:00:00 +00:00
|
|
|
} else {
|
|
|
|
// Read type/value pairs for varargs params.
|
|
|
|
while (OpNum != Record.size()) {
|
|
|
|
Value *Op;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2007-05-06 00:00:00 +00:00
|
|
|
Ops.push_back(Op);
|
2007-05-02 05:46:45 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-15 08:37:34 +00:00
|
|
|
I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2015-04-24 18:06:06 +00:00
|
|
|
cast<InvokeInst>(I)
|
|
|
|
->setCallingConv(static_cast<CallingConv::ID>(~(1U << 13) & 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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-03-30 11:28:46 +00:00
|
|
|
PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(PN);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *V;
|
|
|
|
// With the new function encoding, it is possible that operands have
|
|
|
|
// negative IDs (for forward references). Use a signed VBR
|
|
|
|
// representation to keep the encoding small.
|
|
|
|
if (UseRelativeIDs)
|
|
|
|
V = getValueSigned(Record, 1+i, NextValueNo, Ty);
|
|
|
|
else
|
|
|
|
V = getValue(Record, 1+i, NextValueNo, Ty);
|
2007-05-04 19:11:41 +00:00
|
|
|
BasicBlock *BB = getBasicBlock(Record[2+i]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!V || !BB)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-12 20:24:12 +00:00
|
|
|
Type *Ty = getTypeByID(Record[Idx++]);
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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!");
|
2014-06-04 18:51:31 +00:00
|
|
|
LP->addClause(cast<Constant>(Val));
|
2011-08-12 20:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-02-22 19:32:03 +00:00
|
|
|
uint64_t AlignRecord = Record[3];
|
|
|
|
const uint64_t InAllocaMask = uint64_t(1) << 5;
|
2015-04-28 16:51:01 +00:00
|
|
|
const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
|
|
|
|
const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask;
|
2015-02-22 19:32:03 +00:00
|
|
|
bool InAlloca = AlignRecord & InAllocaMask;
|
2015-04-28 16:51:01 +00:00
|
|
|
Type *Ty = getTypeByID(Record[0]);
|
|
|
|
if ((AlignRecord & ExplicitTypeMask) == 0) {
|
|
|
|
auto *PTy = dyn_cast_or_null<PointerType>(Ty);
|
|
|
|
if (!PTy)
|
|
|
|
return Error("Old-style alloca with a non-pointer type");
|
|
|
|
Ty = PTy->getElementType();
|
|
|
|
}
|
|
|
|
Type *OpTy = getTypeByID(Record[1]);
|
|
|
|
Value *Size = getFnValueByID(Record[2], OpTy);
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Align;
|
|
|
|
if (std::error_code EC =
|
2015-04-28 16:51:01 +00:00
|
|
|
parseAlignmentValue(AlignRecord & ~FlagMask, Align)) {
|
2015-02-22 19:32:03 +00:00
|
|
|
return EC;
|
|
|
|
}
|
2013-11-04 16:16:24 +00:00
|
|
|
if (!Ty || !Size)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-04-28 16:51:01 +00:00
|
|
|
AllocaInst *AI = new AllocaInst(Ty, Size, Align);
|
2014-07-16 01:34:27 +00:00
|
|
|
AI->setUsedWithInAlloca(InAlloca);
|
|
|
|
I = AI;
|
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) ||
|
2015-02-25 01:07:20 +00:00
|
|
|
(OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-02-25 01:07:20 +00:00
|
|
|
|
|
|
|
Type *Ty = nullptr;
|
|
|
|
if (OpNum + 3 == Record.size())
|
|
|
|
Ty = getTypeByID(Record[OpNum++]);
|
2015-05-18 21:48:55 +00:00
|
|
|
if (std::error_code EC =
|
|
|
|
TypeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType()))
|
|
|
|
return EC;
|
2015-04-17 19:56:21 +00:00
|
|
|
if (!Ty)
|
|
|
|
Ty = cast<PointerType>(Op->getType())->getElementType();
|
2015-02-25 01:07:20 +00:00
|
|
|
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Align;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
|
|
|
|
return EC;
|
2015-04-17 19:56:21 +00:00
|
|
|
I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
|
2015-02-25 01:07:20 +00:00
|
|
|
|
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) ||
|
2015-02-25 01:07:20 +00:00
|
|
|
(OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
|
2015-02-25 01:07:20 +00:00
|
|
|
Type *Ty = nullptr;
|
|
|
|
if (OpNum + 5 == Record.size())
|
|
|
|
Ty = getTypeByID(Record[OpNum++]);
|
2015-05-18 21:48:55 +00:00
|
|
|
if (std::error_code EC =
|
|
|
|
TypeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType()))
|
|
|
|
return EC;
|
|
|
|
if (!Ty)
|
|
|
|
Ty = cast<PointerType>(Op->getType())->getElementType();
|
2015-02-25 01:07:20 +00:00
|
|
|
|
2011-08-09 23:02:53 +00:00
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
|
|
|
|
if (Ordering == NotAtomic || Ordering == Release ||
|
|
|
|
Ordering == AcquireRelease)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Align;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
|
|
|
|
return EC;
|
|
|
|
I = new LoadInst(Op, "", Record[OpNum+1], Align, Ordering, SynchScope);
|
2015-02-25 01:07:20 +00:00
|
|
|
|
2011-08-09 23:02:53 +00:00
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2015-04-22 04:14:42 +00:00
|
|
|
case bitc::FUNC_CODE_INST_STORE:
|
|
|
|
case bitc::FUNC_CODE_INST_STORE_OLD: { // 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) ||
|
2015-04-22 04:14:42 +00:00
|
|
|
(BitCode == bitc::FUNC_CODE_INST_STORE
|
|
|
|
? getValueTypePair(Record, OpNum, NextValueNo, Val)
|
|
|
|
: popValue(Record, OpNum, NextValueNo,
|
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(),
|
|
|
|
Val)) ||
|
|
|
|
OpNum + 2 != Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2015-05-18 21:48:55 +00:00
|
|
|
|
|
|
|
if (std::error_code EC = TypeCheckLoadStoreInst(
|
|
|
|
DiagnosticHandler, Val->getType(), Ptr->getType()))
|
|
|
|
return EC;
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Align;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
|
|
|
|
return EC;
|
|
|
|
I = new StoreInst(Val, Ptr, Record[OpNum+1], Align);
|
2009-09-18 19:26:43 +00:00
|
|
|
InstructionList.push_back(I);
|
2007-12-11 08:59:05 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-04-22 04:14:46 +00:00
|
|
|
case bitc::FUNC_CODE_INST_STOREATOMIC:
|
|
|
|
case bitc::FUNC_CODE_INST_STOREATOMIC_OLD: {
|
2011-08-09 23:02:53 +00:00
|
|
|
// STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope]
|
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Val, *Ptr;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
2015-04-22 04:14:46 +00:00
|
|
|
(BitCode == bitc::FUNC_CODE_INST_STOREATOMIC
|
|
|
|
? getValueTypePair(Record, OpNum, NextValueNo, Val)
|
|
|
|
: popValue(Record, OpNum, NextValueNo,
|
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(),
|
|
|
|
Val)) ||
|
|
|
|
OpNum + 4 != Record.size())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
|
2015-05-18 21:48:55 +00:00
|
|
|
if (std::error_code EC = TypeCheckLoadStoreInst(
|
|
|
|
DiagnosticHandler, Val->getType(), Ptr->getType()))
|
|
|
|
return EC;
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
|
|
|
|
if (Ordering != NotAtomic && Record[OpNum] == 0)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-08-09 23:02:53 +00:00
|
|
|
|
2015-02-22 19:32:03 +00:00
|
|
|
unsigned Align;
|
|
|
|
if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
|
|
|
|
return EC;
|
|
|
|
I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SynchScope);
|
2011-08-09 23:02:53 +00:00
|
|
|
InstructionList.push_back(I);
|
|
|
|
break;
|
|
|
|
}
|
2015-04-28 04:30:29 +00:00
|
|
|
case bitc::FUNC_CODE_INST_CMPXCHG_OLD:
|
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,
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210903 91177308-0d34-0410-b5e6-96231b3b80d8
2014-06-13 14:24:07 +00:00
|
|
|
// failureordering?, isweak?]
|
2011-07-28 21:48:00 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
Value *Ptr, *Cmp, *New;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
|
2015-04-28 04:30:29 +00:00
|
|
|
(BitCode == bitc::FUNC_CODE_INST_CMPXCHG
|
|
|
|
? getValueTypePair(Record, OpNum, NextValueNo, Cmp)
|
|
|
|
: popValue(Record, OpNum, NextValueNo,
|
|
|
|
cast<PointerType>(Ptr->getType())->getElementType(),
|
|
|
|
Cmp)) ||
|
|
|
|
popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
|
|
|
|
Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2014-03-11 10:48:52 +00:00
|
|
|
AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]);
|
|
|
|
if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-28 21:48:00 +00:00
|
|
|
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]);
|
2014-03-11 10:48:52 +00:00
|
|
|
|
2015-05-18 21:48:55 +00:00
|
|
|
if (std::error_code EC = TypeCheckLoadStoreInst(
|
|
|
|
DiagnosticHandler, Cmp->getType(), Ptr->getType()))
|
|
|
|
return EC;
|
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]);
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210903 91177308-0d34-0410-b5e6-96231b3b80d8
2014-06-13 14:24:07 +00:00
|
|
|
|
|
|
|
if (Record.size() < 8) {
|
|
|
|
// Before weak cmpxchgs existed, the instruction simply returned the
|
|
|
|
// value loaded from memory, so bitcode files from that era will be
|
|
|
|
// expecting the first component of a modern cmpxchg.
|
|
|
|
CurBB->getInstList().push_back(I);
|
|
|
|
I = ExtractValueInst::Create(I, 0);
|
|
|
|
} else {
|
|
|
|
cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
|
|
|
|
}
|
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-28 21:48:00 +00:00
|
|
|
AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]);
|
|
|
|
if (Operation < AtomicRMWInst::FIRST_BINOP ||
|
|
|
|
Operation > AtomicRMWInst::LAST_BINOP)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-25 23:16:38 +00:00
|
|
|
AtomicOrdering Ordering = GetDecodedOrdering(Record[0]);
|
|
|
|
if (Ordering == NotAtomic || Ordering == Unordered ||
|
|
|
|
Ordering == Monotonic)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-04-17 06:40:14 +00:00
|
|
|
unsigned OpNum = 0;
|
|
|
|
AttributeSet PAL = getAttributes(Record[OpNum++]);
|
|
|
|
unsigned CCInfo = Record[OpNum++];
|
|
|
|
|
|
|
|
FunctionType *FTy = nullptr;
|
|
|
|
if (CCInfo >> 15 & 1 &&
|
|
|
|
!(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
|
|
|
|
return Error("Explicit call type is not a function type");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
Value *Callee;
|
|
|
|
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
|
2015-04-17 06:40:14 +00:00
|
|
|
if (!OpTy)
|
|
|
|
return Error("Callee is not a pointer type");
|
2015-04-23 21:36:23 +00:00
|
|
|
if (!FTy) {
|
|
|
|
FTy = dyn_cast<FunctionType>(OpTy->getElementType());
|
|
|
|
if (!FTy)
|
|
|
|
return Error("Callee is not of pointer to function type");
|
|
|
|
} else if (OpTy->getElementType() != FTy)
|
2015-04-17 06:40:14 +00:00
|
|
|
return Error("Explicit call type does not match pointee type of "
|
|
|
|
"callee operand");
|
|
|
|
if (Record.size() < FTy->getNumParams() + OpNum)
|
|
|
|
return Error("Insufficient operands to call");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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
|
|
|
|
2015-04-23 21:36:23 +00:00
|
|
|
I = CallInst::Create(FTy, 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(
|
2014-04-24 20:14:34 +00:00
|
|
|
static_cast<CallingConv::ID>((~(1U << 14) & CCInfo) >> 1));
|
|
|
|
CallInst::TailCallKind TCK = CallInst::TCK_None;
|
|
|
|
if (CCInfo & 1)
|
|
|
|
TCK = CallInst::TCK_Tail;
|
|
|
|
if (CCInfo & (1 << 14))
|
|
|
|
TCK = CallInst::TCK_MustTail;
|
|
|
|
cast<CallInst>(I)->setTailCallKind(TCK);
|
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)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *OpTy = getTypeByID(Record[0]);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
Value *Op = getValue(Record, 1, NextValueNo, OpTy);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ResTy = getTypeByID(Record[2]);
|
2007-05-03 22:04:19 +00:00
|
|
|
if (!OpTy || !Op || !ResTy)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid record");
|
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;
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid instruction with no BB");
|
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;
|
|
|
|
}
|
|
|
|
}
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Never resolved value found in function");
|
2007-05-01 07:01:57 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-08-25 20:23:38 +00:00
|
|
|
// FIXME: Check for unresolved forward-declared metadata references
|
|
|
|
// and clean up leaks.
|
|
|
|
|
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);
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2007-05-01 04:59:48 +00:00
|
|
|
}
|
|
|
|
|
2013-11-05 17:16:08 +00:00
|
|
|
/// Find the function body in the bitcode stream
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::FindFunctionInStream(
|
|
|
|
Function *F,
|
|
|
|
DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
|
2012-02-06 22:30:29 +00:00
|
|
|
while (DeferredFunctionInfoIterator->second == 0) {
|
|
|
|
if (Stream.AtEndOfStream())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Could not find function in stream");
|
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.
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseModule(true))
|
2013-11-05 17:16:08 +00:00
|
|
|
return EC;
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-06-23 21:53:12 +00:00
|
|
|
void BitcodeReader::releaseBuffer() { Buffer.release(); }
|
2007-05-18 04:02:46 +00:00
|
|
|
|
2014-10-24 22:50:48 +00:00
|
|
|
std::error_code BitcodeReader::materialize(GlobalValue *GV) {
|
2015-03-13 19:24:30 +00:00
|
|
|
if (std::error_code EC = materializeMetadata())
|
|
|
|
return EC;
|
|
|
|
|
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())
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
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)
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = FindFunctionInStream(F, DFII))
|
2013-11-05 19:36:34 +00:00
|
|
|
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
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
if (std::error_code EC = ParseFunctionBody(F))
|
2013-11-05 19:36:34 +00:00
|
|
|
return EC;
|
2014-10-24 18:13:04 +00:00
|
|
|
F->setIsMaterializable(false);
|
2007-08-04 01:51:18 +00:00
|
|
|
|
2015-03-30 21:36:43 +00:00
|
|
|
if (StripDebugInfo)
|
|
|
|
stripDebugInfo(*F);
|
|
|
|
|
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
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
// Bring in any functions that this function forward-referenced via
|
|
|
|
// blockaddresses.
|
|
|
|
return materializeForwardReferencedFunctions();
|
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;
|
2014-08-01 21:11:34 +00:00
|
|
|
|
|
|
|
// Dematerializing F would leave dangling references that wouldn't be
|
|
|
|
// reconnected on re-materialization.
|
|
|
|
if (BlockAddressesTaken.count(F))
|
|
|
|
return false;
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
return DeferredFunctionInfo.count(const_cast<Function*>(F));
|
|
|
|
}
|
|
|
|
|
2015-05-15 18:20:14 +00:00
|
|
|
void BitcodeReader::dematerialize(GlobalValue *GV) {
|
2010-01-27 20:34:15 +00:00
|
|
|
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.
|
2014-09-23 12:54:19 +00:00
|
|
|
F->dropAllReferences();
|
2014-10-24 18:13:04 +00:00
|
|
|
F->setIsMaterializable(true);
|
2007-05-18 04:02:46 +00:00
|
|
|
}
|
|
|
|
|
2015-05-15 18:20:14 +00:00
|
|
|
std::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.");
|
2014-08-01 21:11:34 +00:00
|
|
|
|
2015-03-13 19:24:30 +00:00
|
|
|
if (std::error_code EC = materializeMetadata())
|
|
|
|
return EC;
|
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
// Promise to materialize all forward references.
|
|
|
|
WillMaterializeAllForwardRefs = true;
|
|
|
|
|
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) {
|
2014-11-01 16:46:18 +00:00
|
|
|
if (std::error_code EC = materialize(F))
|
|
|
|
return EC;
|
2013-11-05 19:36:34 +00:00
|
|
|
}
|
2012-02-29 00:07:09 +00:00
|
|
|
// At this point, if there are any function bodies, the current bit is
|
|
|
|
// pointing to the END_BLOCK record after them. Now make sure the rest
|
|
|
|
// of the bits in the module have been read.
|
|
|
|
if (NextUnreadBit)
|
|
|
|
ParseModule(true);
|
|
|
|
|
2014-08-01 21:11:34 +00:00
|
|
|
// Check that all block address forward references got resolved (as we
|
|
|
|
// promised above).
|
2014-08-01 21:51:52 +00:00
|
|
|
if (!BasicBlockFwdRefs.empty())
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Never resolved function from blockaddress");
|
2014-08-01 21:11:34 +00:00
|
|
|
|
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);
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
Ask the module for its the identified types.
When lazy reading a module, the types used in a function will not be visible to
a TypeFinder until the body is read.
This patch fixes that by asking the module for its identified struct types.
If a materializer is present, the module asks it. If not, it uses a TypeFinder.
This fixes pr21374.
I will be the first to say that this is ugly, but it was the best I could find.
Some of the options I looked at:
* Asking the LLVMContext. This could be made to work for gold, but not currently
for ld64. ld64 will load multiple modules into a single context before merging
them. This causes us to see types from future merges. Unfortunately,
MappedTypes is not just a cache when it comes to opaque types. Once the
mapping has been made, we have to remember it for as long as the key may
be used. This would mean moving MappedTypes to the Linker class and having
to drop the Linker::LinkModules static methods, which are visible from C.
* Adding an option to ignore function bodies in the TypeFinder. This would
fix the PR by picking the worst result. It would work, but unfortunately
we are currently quite dependent on the upfront type merging. I will
try to reduce our dependency, but it is not clear that we will be able
to get rid of it for now.
The only clean solution I could think of is making the Module own the types.
This would have other advantages, but it is a much bigger change. I will
propose it, but it is nice to have this fixed while that is discussed.
With the gold plugin, this patch takes the number of types in the LTO clang
binary from 52817 to 49669.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223215 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-03 07:18:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const {
|
|
|
|
return IdentifiedStructTypes;
|
2007-05-18 04:02:46 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::error_code BitcodeReader::InitStream() {
|
2013-11-04 16:16:24 +00:00
|
|
|
if (LazyStreamer)
|
|
|
|
return InitLazyStream();
|
2012-02-06 22:30:29 +00:00
|
|
|
return InitStreamFromBuffer();
|
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::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();
|
|
|
|
|
2014-07-29 21:01:24 +00:00
|
|
|
if (Buffer->getBufferSize() & 3)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode signature");
|
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))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode wrapper header");
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
|
2014-11-12 14:48:38 +00:00
|
|
|
Stream.init(&*StreamFile);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 02:24:39 +00:00
|
|
|
std::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.
|
2014-12-18 10:03:35 +00:00
|
|
|
auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(LazyStreamer);
|
2014-12-18 05:08:43 +00:00
|
|
|
StreamingMemoryObject &Bytes = *OwnedBytes;
|
2014-12-18 10:03:35 +00:00
|
|
|
StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
|
2014-11-12 14:48:38 +00:00
|
|
|
Stream.init(&*StreamFile);
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
unsigned char buf[16];
|
2014-12-18 05:08:43 +00:00
|
|
|
if (Bytes.readBytes(buf, 16, 0) != 16)
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode signature");
|
2012-02-06 22:30:29 +00:00
|
|
|
|
|
|
|
if (!isBitcode(buf, buf + 16))
|
2015-01-10 00:07:30 +00:00
|
|
|
return Error("Invalid bitcode signature");
|
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);
|
2014-12-18 05:08:43 +00:00
|
|
|
Bytes.dropLeadingBytes(bitcodeStart - buf);
|
|
|
|
Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
2014-06-13 02:24:39 +00:00
|
|
|
return std::error_code();
|
2013-11-04 16:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
2014-06-12 01:45:43 +00:00
|
|
|
class BitcodeErrorCategoryType : public std::error_category {
|
2014-06-10 21:26:47 +00:00
|
|
|
const char *name() const LLVM_NOEXCEPT 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 {
|
2014-07-29 20:22:46 +00:00
|
|
|
BitcodeError E = static_cast<BitcodeError>(IE);
|
2013-11-04 16:16:24 +00:00
|
|
|
switch (E) {
|
2014-07-29 20:22:46 +00:00
|
|
|
case BitcodeError::InvalidBitcodeSignature:
|
2013-11-04 16:16:24 +00:00
|
|
|
return "Invalid bitcode signature";
|
2015-01-10 00:07:30 +00:00
|
|
|
case BitcodeError::CorruptedBitcode:
|
|
|
|
return "Corrupted bitcode";
|
2013-11-04 16:16:24 +00:00
|
|
|
}
|
2013-11-05 13:45:09 +00:00
|
|
|
llvm_unreachable("Unknown error type!");
|
2013-11-04 16:16:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2014-09-19 20:29:02 +00:00
|
|
|
static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory;
|
|
|
|
|
2014-07-29 20:22:46 +00:00
|
|
|
const std::error_category &llvm::BitcodeErrorCategory() {
|
2014-09-19 20:29:02 +00:00
|
|
|
return *ErrorCategory;
|
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
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-01 22:27:19 +00:00
|
|
|
/// \brief Get a lazy one-at-time loading module from bitcode.
|
2007-04-29 07:54:31 +00:00
|
|
|
///
|
2014-08-01 22:27:19 +00:00
|
|
|
/// This isn't always used in a lazy context. In particular, it's also used by
|
|
|
|
/// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull
|
|
|
|
/// in forward-referenced functions from block address references.
|
|
|
|
///
|
|
|
|
/// \param[in] WillMaterializeAll Set to \c true if the caller promises to
|
|
|
|
/// materialize everything -- in particular, if this isn't truly lazy.
|
2014-08-26 22:00:09 +00:00
|
|
|
static ErrorOr<Module *>
|
2014-09-03 17:31:46 +00:00
|
|
|
getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
|
2015-01-10 00:07:30 +00:00
|
|
|
LLVMContext &Context, bool WillMaterializeAll,
|
2015-03-13 19:24:30 +00:00
|
|
|
DiagnosticHandlerFunction DiagnosticHandler,
|
|
|
|
bool ShouldLazyLoadMetadata = false) {
|
2010-01-27 20:34:15 +00:00
|
|
|
Module *M = new Module(Buffer->getBufferIdentifier(), Context);
|
2015-01-10 00:07:30 +00:00
|
|
|
BitcodeReader *R =
|
|
|
|
new BitcodeReader(Buffer.get(), Context, DiagnosticHandler);
|
2010-01-27 20:34:15 +00:00
|
|
|
M->setMaterializer(R);
|
2014-08-01 21:11:34 +00:00
|
|
|
|
|
|
|
auto cleanupOnError = [&](std::error_code EC) {
|
2014-06-18 20:07:35 +00:00
|
|
|
R->releaseBuffer(); // Never take ownership on error.
|
2010-01-27 20:34:15 +00:00
|
|
|
delete M; // Also deletes R.
|
2014-01-13 18:31:04 +00:00
|
|
|
return EC;
|
2014-08-01 21:11:34 +00:00
|
|
|
};
|
|
|
|
|
2015-03-13 19:24:30 +00:00
|
|
|
// Delay parsing Metadata if ShouldLazyLoadMetadata is true.
|
|
|
|
if (std::error_code EC = R->ParseBitcodeInto(M, ShouldLazyLoadMetadata))
|
2014-08-01 21:11:34 +00:00
|
|
|
return cleanupOnError(EC);
|
2012-01-02 07:49:53 +00:00
|
|
|
|
2014-08-01 22:27:19 +00:00
|
|
|
if (!WillMaterializeAll)
|
|
|
|
// Resolve forward references from blockaddresses.
|
|
|
|
if (std::error_code EC = R->materializeForwardReferencedFunctions())
|
|
|
|
return cleanupOnError(EC);
|
2012-01-02 07:49:53 +00:00
|
|
|
|
2014-08-26 22:00:09 +00:00
|
|
|
Buffer.release(); // The BitcodeReader owns it now.
|
2010-01-27 20:34:15 +00:00
|
|
|
return M;
|
2007-04-29 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2014-08-26 22:00:09 +00:00
|
|
|
ErrorOr<Module *>
|
2014-09-03 17:31:46 +00:00
|
|
|
llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
|
2015-01-10 00:07:30 +00:00
|
|
|
LLVMContext &Context,
|
2015-03-13 19:24:30 +00:00
|
|
|
DiagnosticHandlerFunction DiagnosticHandler,
|
|
|
|
bool ShouldLazyLoadMetadata) {
|
2015-01-10 00:07:30 +00:00
|
|
|
return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false,
|
2015-03-13 19:24:30 +00:00
|
|
|
DiagnosticHandler, ShouldLazyLoadMetadata);
|
2014-08-01 22:27:19 +00:00
|
|
|
}
|
2012-02-06 22:30:29 +00:00
|
|
|
|
2014-12-18 05:08:43 +00:00
|
|
|
ErrorOr<std::unique_ptr<Module>>
|
|
|
|
llvm::getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer,
|
2015-01-10 00:07:30 +00:00
|
|
|
LLVMContext &Context,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler) {
|
2014-12-18 05:08:43 +00:00
|
|
|
std::unique_ptr<Module> M = make_unique<Module>(Name, Context);
|
2015-01-10 00:07:30 +00:00
|
|
|
BitcodeReader *R = new BitcodeReader(Streamer, Context, DiagnosticHandler);
|
2012-02-06 22:30:29 +00:00
|
|
|
M->setMaterializer(R);
|
2014-12-18 05:08:43 +00:00
|
|
|
if (std::error_code EC = R->ParseBitcodeInto(M.get()))
|
|
|
|
return EC;
|
|
|
|
return std::move(M);
|
2012-02-06 22:30:29 +00:00
|
|
|
}
|
|
|
|
|
2015-01-10 00:07:30 +00:00
|
|
|
ErrorOr<Module *>
|
|
|
|
llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler) {
|
2014-08-26 21:49:01 +00:00
|
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
|
2015-01-10 00:07:30 +00:00
|
|
|
ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModuleImpl(
|
|
|
|
std::move(Buf), Context, true, DiagnosticHandler);
|
2014-01-15 01:08:23 +00:00
|
|
|
if (!ModuleOrErr)
|
|
|
|
return ModuleOrErr;
|
2014-01-13 18:31:04 +00:00
|
|
|
Module *M = ModuleOrErr.get();
|
2010-01-27 20:34:15 +00:00
|
|
|
// Read in the entire module, and destroy the BitcodeReader.
|
2014-08-26 21:49:01 +00:00
|
|
|
if (std::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
|
|
|
|
2015-01-10 00:07:30 +00:00
|
|
|
std::string
|
|
|
|
llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler) {
|
2014-08-26 21:49:01 +00:00
|
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
|
2015-01-10 00:07:30 +00:00
|
|
|
auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context,
|
|
|
|
DiagnosticHandler);
|
2014-07-04 20:02:42 +00:00
|
|
|
ErrorOr<std::string> Triple = R->parseTriple();
|
2014-07-04 13:52:01 +00:00
|
|
|
if (Triple.getError())
|
|
|
|
return "";
|
|
|
|
return Triple.get();
|
2010-10-06 01:22:42 +00:00
|
|
|
}
|