#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/ManagedStatic.h"
+
using namespace llvm;
enum {
} else {
// Otherwise insert a placeholder and remember it so it can be inserted
// when the function is parsed.
- BB = BasicBlock::Create(Context);
auto &FwdBBs = BasicBlockFwdRefs[Fn];
if (FwdBBs.empty())
BasicBlockFwdRefQueue.push_back(Fn);
- FwdBBs.emplace_back(BBID, BB);
+ if (FwdBBs.size() < BBID + 1)
+ FwdBBs.resize(BBID + 1);
+ if (!FwdBBs[BBID])
+ FwdBBs[BBID] = BasicBlock::Create(Context);
+ BB = FwdBBs[BBID];
}
V = BlockAddress::get(Fn, BB);
break;
// creating now, so that we can match up the body with them later.
if (!isProto) {
FunctionsWithBodies.push_back(Func);
- if (LazyStreamer) DeferredFunctionInfo[Func] = 0;
+ if (LazyStreamer)
+ DeferredFunctionInfo[Func] = 0;
}
break;
}
FunctionBBs[i] = BasicBlock::Create(Context, "", F);
} else {
auto &BBRefs = BBFRI->second;
- std::sort(BBRefs.begin(), BBRefs.end(),
- [](const std::pair<unsigned, BasicBlock *> &LHS,
- const std::pair<unsigned, BasicBlock *> &RHS) {
- return LHS.first < RHS.first;
- });
- unsigned R = 0, RE = BBRefs.size();
- for (unsigned I = 0, E = FunctionBBs.size(); I != E; ++I)
- if (R != RE && BBRefs[R].first == I) {
- assert(I != 0 && "Invalid reference to entry block");
- BasicBlock *BB = BBRefs[R++].second;
- BB->insertInto(F);
- FunctionBBs[I] = BB;
+ // Check for invalid basic block references.
+ if (BBRefs.size() > FunctionBBs.size())
+ return Error(BitcodeError::InvalidID);
+ 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];
} else {
FunctionBBs[I] = BasicBlock::Create(Context, "", F);
}
- // Check for invalid basic block references.
- if (R != RE)
- return Error(BitcodeError::InvalidID);
// Erase from the table.
BasicBlockFwdRefs.erase(BBFRI);
assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
// Just forget the function body, we can remat it later.
- F->deleteBody();
+ F->dropAllReferences();
}
std::error_code BitcodeReader::MaterializeModule(Module *M) {
};
}
+static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory;
+
const std::error_category &llvm::BitcodeErrorCategory() {
- static BitcodeErrorCategoryType O;
- return O;
+ return *ErrorCategory;
}
//===----------------------------------------------------------------------===//
///
/// \param[in] WillMaterializeAll Set to \c true if the caller promises to
/// materialize everything -- in particular, if this isn't truly lazy.
-static ErrorOr<Module *> getLazyBitcodeModuleImpl(MemoryBuffer *Buffer,
- LLVMContext &Context,
- bool WillMaterializeAll) {
+static ErrorOr<Module *>
+getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
+ LLVMContext &Context, bool WillMaterializeAll) {
Module *M = new Module(Buffer->getBufferIdentifier(), Context);
- BitcodeReader *R = new BitcodeReader(Buffer, Context);
+ BitcodeReader *R = new BitcodeReader(Buffer.get(), Context);
M->setMaterializer(R);
auto cleanupOnError = [&](std::error_code EC) {
if (std::error_code EC = R->materializeForwardReferencedFunctions())
return cleanupOnError(EC);
+ Buffer.release(); // The BitcodeReader owns it now.
return M;
}
-ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
- LLVMContext &Context) {
- return getLazyBitcodeModuleImpl(Buffer, Context, false);
+ErrorOr<Module *>
+llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
+ LLVMContext &Context) {
+ return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false);
}
Module *llvm::getStreamedBitcodeModule(const std::string &name,
return M;
}
-ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer,
+ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
LLVMContext &Context) {
+ std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
ErrorOr<Module *> ModuleOrErr =
- getLazyBitcodeModuleImpl(Buffer, Context, true);
+ getLazyBitcodeModuleImpl(std::move(Buf), Context, true);
if (!ModuleOrErr)
return ModuleOrErr;
Module *M = ModuleOrErr.get();
// Read in the entire module, and destroy the BitcodeReader.
- if (std::error_code EC = M->materializeAllPermanently(true)) {
+ if (std::error_code EC = M->materializeAllPermanently()) {
delete M;
return EC;
}
return M;
}
-std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer,
+std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer,
LLVMContext &Context) {
- BitcodeReader *R = new BitcodeReader(Buffer, Context);
+ std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
+ auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context);
ErrorOr<std::string> Triple = R->parseTriple();
- R->releaseBuffer();
- delete R;
if (Triple.getError())
return "";
return Triple.get();