#include "llvm/DerivedTypes.h"
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
+#include "llvm/MDNode.h"
#include "llvm/Module.h"
#include "llvm/AutoUpgrade.h"
#include "llvm/ADT/SmallString.h"
case 9: return GlobalValue::PrivateLinkage;
case 10: return GlobalValue::WeakODRLinkage;
case 11: return GlobalValue::LinkOnceODRLinkage;
+ case 12: return GlobalValue::AvailableExternallyLinkage;
}
}
static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
switch (Val) {
default: return -1;
- case bitc::BINOP_ADD: return Instruction::Add;
- case bitc::BINOP_SUB: return Instruction::Sub;
- case bitc::BINOP_MUL: return Instruction::Mul;
+ case bitc::BINOP_ADD:
+ return Ty->isFPOrFPVector() ? Instruction::FAdd : Instruction::Add;
+ case bitc::BINOP_SUB:
+ return Ty->isFPOrFPVector() ? Instruction::FSub : Instruction::Sub;
+ case bitc::BINOP_MUL:
+ return Ty->isFPOrFPVector() ? Instruction::FMul : Instruction::Mul;
case bitc::BINOP_UDIV: return Instruction::UDiv;
case bitc::BINOP_SDIV:
return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
UserCS->getType()->isPacked());
} else if (isa<ConstantVector>(UserC)) {
NewC = ConstantVector::get(&NewOps[0], NewOps.size());
- } else if (isa<ConstantExpr>(UserC)) {
+ } else {
+ assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
NewC = cast<ConstantExpr>(UserC)->getWithOperands(&NewOps[0],
NewOps.size());
- } else {
- assert(isa<MDNode>(UserC) && "Must be a metadata node.");
- NewC = MDNode::get(&NewOps[0], NewOps.size());
}
UserC->replaceAllUsesWith(NewC);
NewOps.clear();
}
+ // Update all ValueHandles, they should be the only users at this point.
+ Placeholder->replaceAllUsesWith(RealVal);
delete Placeholder;
}
}
case bitc::TYPE_CODE_OPAQUE: // OPAQUE
ResultTy = 0;
break;
+ case bitc::TYPE_CODE_METADATA: // METADATA
+ ResultTy = Type::MetadataTy;
+ break;
case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
if (Record.size() < 1)
return Error("Invalid Integer type record");
break;
case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
if (ConvertToString(Record, 1, ValueName))
- return Error("Invalid TST_ENTRY record");
+ return Error("Invalid VST_ENTRY record");
unsigned ValueID = Record[0];
if (ValueID >= ValueList.size())
return Error("Invalid Value ID in VST_ENTRY record");
return Error("Invalid CST_MDNODE record");
unsigned Size = Record.size();
- SmallVector<Constant*, 8> Elts;
+ SmallVector<Value*, 8> Elts;
for (unsigned i = 0; i != Size; i += 2) {
const Type *Ty = getTypeByID(Record[i], false);
- Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], Ty));
+ if (Ty != Type::VoidTy)
+ Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty));
+ else
+ Elts.push_back(NULL);
}
V = MDNode::get(&Elts[0], Elts.size());
break;
return Error("Premature end of bitstream");
}
-/// SkipWrapperHeader - Some systems wrap bc files with a special header for
-/// padding or other reasons. The format of this header is:
-///
-/// struct bc_header {
-/// uint32_t Magic; // 0x0B17C0DE
-/// uint32_t Version; // Version, currently always 0.
-/// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
-/// uint32_t BitcodeSize; // Size of traditional bitcode file.
-/// ... potentially other gunk ...
-/// };
-///
-/// This function is called when we find a file with a matching magic number.
-/// In this case, skip down to the subsection of the file that is actually a BC
-/// file.
-static bool SkipWrapperHeader(unsigned char *&BufPtr, unsigned char *&BufEnd) {
- enum {
- KnownHeaderSize = 4*4, // Size of header we read.
- OffsetField = 2*4, // Offset in bytes to Offset field.
- SizeField = 3*4 // Offset in bytes to Size field.
- };
-
-
- // Must contain the header!
- if (BufEnd-BufPtr < KnownHeaderSize) return true;
-
- unsigned Offset = ( BufPtr[OffsetField ] |
- (BufPtr[OffsetField+1] << 8) |
- (BufPtr[OffsetField+2] << 16) |
- (BufPtr[OffsetField+3] << 24));
- unsigned Size = ( BufPtr[SizeField ] |
- (BufPtr[SizeField +1] << 8) |
- (BufPtr[SizeField +2] << 16) |
- (BufPtr[SizeField +3] << 24));
-
- // Verify that Offset+Size fits in the file.
- if (Offset+Size > unsigned(BufEnd-BufPtr))
- return true;
- BufPtr += Offset;
- BufEnd = BufPtr+Size;
- return false;
-}
-
bool BitcodeReader::ParseBitcode() {
TheModule = 0;
// 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 (BufPtr != BufEnd && BufPtr[0] == 0xDE && BufPtr[1] == 0xC0 &&
- BufPtr[2] == 0x17 && BufPtr[3] == 0x0B)
- if (SkipWrapperHeader(BufPtr, BufEnd))
+ if (isBitcodeWrapper(BufPtr, BufEnd))
+ if (SkipBitcodeWrapperHeader(BufPtr, BufEnd))
return Error("Invalid bitcode wrapper header");
- Stream.init(BufPtr, BufEnd);
+ StreamFile.init(BufPtr, BufEnd);
+ Stream.init(StreamFile);
// Sniff for the signature.
if (Stream.Read(8) != 'B' ||
Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
- for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
- DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
- ++I) {
- Function *F = I->first;
+ // Iterate over the module, deserializing any functions that are still on
+ // disk.
+ for (Module::iterator F = TheModule->begin(), E = TheModule->end();
+ F != E; ++F)
if (F->hasNotBeenReadFromBitcode() &&
materializeFunction(F, ErrInfo))
return 0;
- }
// 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
// is run.
if (M)
M = R->releaseModule(ErrMsg);
-
+
delete R;
return M;
}
projects / oota-llvm.git / blobdiff