/// somewhere not accessible in the object file.
/// This is used for dynamic disassembly (see RawMemoryObject).
void setFallbackRegion(OwningPtr<MemoryObject> &Region) {
- FallbackRegion.reset(Region.take());
+ FallbackRegion.reset(Region.release());
}
/// \brief Set the symbolizer to use to get information on external functions.
OwningPtr<Module> M2(new Module(F->getBufferIdentifier(), Context));
if (LLParser(F, SM, Err, M2.get()).Run())
return 0;
- return M2.take();
+ return M2.release();
}
Module *llvm::ParseAssemblyFile(const std::string &Filename, SMDiagnostic &Err,
return 0;
}
- return ParseAssembly(File.take(), 0, Err, Context);
+ return ParseAssembly(File.release(), 0, Err, Context);
}
Module *llvm::ParseAssemblyString(const char *AsmString, Module *M,
return true;
// If successful, createAsmPrinter took ownership of AsmStreamer.
- AsmStreamer.take();
+ AsmStreamer.release();
PM.add(Printer);
return true;
// If successful, createAsmPrinter took ownership of AsmStreamer.
- AsmStreamer.take();
+ AsmStreamer.release();
PM.add(Printer);
/// Construct a PBQP register allocator.
RegAllocPBQP(OwningPtr<PBQPBuilder> &b, char *cPassID=0)
- : MachineFunctionPass(ID), builder(b.take()), customPassID(cPassID) {
+ : MachineFunctionPass(ID), builder(b.release()), customPassID(cPassID) {
initializeSlotIndexesPass(*PassRegistry::getPassRegistry());
initializeLiveIntervalsPass(*PassRegistry::getPassRegistry());
initializeLiveStacksPass(*PassRegistry::getPassRegistry());
}
}
- return p.take();
+ return p.release();
}
void PBQPBuilder::addSpillCosts(PBQP::Vector &costVec,
}
}
- return p.take();
+ return p.release();
}
void PBQPBuilderWithCoalescing::addPhysRegCoalesce(PBQP::Vector &costVec,
if (!CU->extract(DIData, &offset)) {
break;
}
- CUs.push_back(CU.take());
+ CUs.push_back(CU.release());
offset = CUs.back()->getNextUnitOffset();
}
}
&I->second.Relocs, isLittleEndian()));
if (!TU->extract(DIData, &offset))
break;
- TUs.push_back(TU.take());
+ TUs.push_back(TU.release());
offset = TUs.back()->getNextUnitOffset();
}
}
if (!DWOCU->extract(DIData, &offset)) {
break;
}
- DWOCUs.push_back(DWOCU.take());
+ DWOCUs.push_back(DWOCU.release());
offset = DWOCUs.back()->getNextUnitOffset();
}
}
isLittleEndian()));
if (!TU->extract(DIData, &offset))
break;
- DWOTUs.push_back(TU.take());
+ DWOTUs.push_back(TU.release());
offset = DWOTUs.back()->getNextUnitOffset();
}
}
// Make data point to uncompressed section contents and save its contents.
name = name.substr(1);
data = UncompressedSection->getBuffer();
- UncompressedSections.push_back(UncompressedSection.take());
+ UncompressedSections.push_back(UncompressedSection.release());
}
StringRef *Section =
if (UseMCJIT && ExecutionEngine::MCJITCtor) {
ExecutionEngine *EE =
ExecutionEngine::MCJITCtor(M, ErrorStr, MCJMM ? MCJMM : JMM,
- AllocateGVsWithCode, TheTM.take());
+ AllocateGVsWithCode, TheTM.release());
if (EE) return EE;
} else if (ExecutionEngine::JITCtor) {
ExecutionEngine *EE =
ExecutionEngine::JITCtor(M, ErrorStr, JMM,
- AllocateGVsWithCode, TheTM.take());
+ AllocateGVsWithCode, TheTM.release());
if (EE) return EE;
}
}
ObjCache->notifyObjectCompiled(M, MB.get());
}
- return CompiledObject.take();
+ return CompiledObject.release();
}
void MCJIT::generateCodeForModule(Module *M) {
if (0 != ObjCache) {
OwningPtr<MemoryBuffer> PreCompiledObject(ObjCache->getObject(M));
if (0 != PreCompiledObject.get())
- ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.take()));
+ ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.release()));
}
// If the cache did not contain a suitable object, compile the object
// Load the object into the dynamic linker.
// MCJIT now owns the ObjectImage pointer (via its LoadedObjects list).
- ObjectImage *LoadedObject = Dyld.loadObject(ObjectToLoad.take());
+ ObjectImage *LoadedObject = Dyld.loadObject(ObjectToLoad.release());
LoadedObjects.push_back(LoadedObject);
if (!LoadedObject)
report_fatal_error(Dyld.getErrorString());
// FIXME: Support nested archives?
if (!ChildIt->getAsBinary(ChildBin) && ChildBin->isObject()) {
object::ObjectFile *OF = reinterpret_cast<object::ObjectFile *>(
- ChildBin.take());
+ ChildBin.release());
// This causes the object file to be loaded.
addObjectFile(OF);
// The address should be here now.
// Give the subclasses a chance to tie-up any loose ends.
finalizeLoad(LocalSections);
- return Obj.take();
+ return Obj.release();
}
// A helper method for computeTotalAllocSize.
OwningPtr<MemoryBuffer> MB;
error_code ec;
if (!(ec = MemoryBuffer::getFile(Path, MB))) {
- *OutMemBuf = wrap(MB.take());
+ *OutMemBuf = wrap(MB.release());
return 0;
}
OwningPtr<MemoryBuffer> MB;
error_code ec;
if (!(ec = MemoryBuffer::getSTDIN(MB))) {
- *OutMemBuf = wrap(MB.take());
+ *OutMemBuf = wrap(MB.release());
return 0;
}
return 0;
}
- return getLazyIRModule(File.take(), Err, Context);
+ return getLazyIRModule(File.release(), Err, Context);
}
Module *llvm::ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
return 0;
}
- return ParseIR(File.take(), Err, Context);
+ return ParseIR(File.release(), Err, Context);
}
//===----------------------------------------------------------------------===//
sys::fs::remove(NativeObjectPath);
return NULL;
}
- NativeObjectFile = BuffPtr.take();
+ NativeObjectFile = BuffPtr.release();
// remove temp files
sys::fs::remove(NativeObjectPath);
OwningPtr<MemoryBuffer> buffer;
if (MemoryBuffer::getFile(path, buffer))
return false;
- return isTargetMatch(buffer.take(), triplePrefix);
+ return isTargetMatch(buffer.release(), triplePrefix);
}
/// isTargetMatch - Returns 'true' if the memory buffer is for the specified
errMsg = ec.message();
return NULL;
}
- return makeLTOModule(buffer.take(), options, errMsg);
+ return makeLTOModule(buffer.release(), options, errMsg);
}
LTOModule *LTOModule::makeLTOModule(int fd, const char *path,
errMsg = ec.message();
return NULL;
}
- return makeLTOModule(buffer.take(), options, errMsg);
+ return makeLTOModule(buffer.release(), options, errMsg);
}
LTOModule *LTOModule::makeLTOModule(const void *mem, size_t length,
OwningPtr<MemoryBuffer> buffer(makeBuffer(mem, length, path));
if (!buffer)
return NULL;
- return makeLTOModule(buffer.take(), options, errMsg);
+ return makeLTOModule(buffer.release(), options, errMsg);
}
LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
options);
m->materializeAllPermanently();
- LTOModule *Ret = new LTOModule(m.take(), target);
+ LTOModule *Ret = new LTOModule(m.release(), target);
// We need a MCContext set up in order to get mangled names of private
// symbols. It is a bit odd that we need to report uses and definitions
}
void MCDisassembler::setSymbolizer(OwningPtr<MCSymbolizer> &Symzer) {
- Symbolizer.reset(Symzer.take());
+ Symbolizer.reset(Symzer.release());
}
OwningPtr<MCSymbolizer> Symbolizer(
TheTarget->createMCSymbolizer(Triple, GetOpInfo, SymbolLookUp, DisInfo,
- Ctx, RelInfo.take()));
+ Ctx, RelInfo.release()));
DisAsm->setSymbolizer(Symbolizer);
DisAsm->setupForSymbolicDisassembly(GetOpInfo, SymbolLookUp, DisInfo,
Ctx, RelInfo);
using namespace llvm;
MCSymbolizer::MCSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo)
- : Ctx(Ctx), RelInfo(RelInfo.take()) {
+ : Ctx(Ctx), RelInfo(RelInfo.release()) {
}
MCSymbolizer::~MCSymbolizer() {
switch (Type) {
case sys::fs::file_magic::archive:
- return Archive::create(scopedSource.take());
+ return Archive::create(scopedSource.release());
case sys::fs::file_magic::elf_relocatable:
case sys::fs::file_magic::elf_executable:
case sys::fs::file_magic::elf_shared_object:
case sys::fs::file_magic::coff_import_library:
case sys::fs::file_magic::pecoff_executable:
case sys::fs::file_magic::bitcode:
- return ObjectFile::createSymbolicFile(scopedSource.take(), true, Type,
+ return ObjectFile::createSymbolicFile(scopedSource.release(), true, Type,
Context);
case sys::fs::file_magic::macho_universal_binary:
- return MachOUniversalBinary::create(scopedSource.take());
+ return MachOUniversalBinary::create(scopedSource.release());
case sys::fs::file_magic::unknown:
case sys::fs::file_magic::windows_resource:
// Unrecognized object file format.
OwningPtr<MemoryBuffer> File;
if (error_code EC = MemoryBuffer::getFileOrSTDIN(Path, File))
return EC;
- return createBinary(File.take());
+ return createBinary(File.release());
}
OwningPtr<COFFObjectFile> Ret(new COFFObjectFile(Object, EC, BufferOwned));
if (EC)
return EC;
- return Ret.take();
+ return Ret.release();
}
if (EC)
return EC;
- return R.take();
+ return R.release();
}
} // end namespace llvm
new IRObjectFile(Object, EC, Context, BufferOwned));
if (EC)
return EC;
- return Ret.take();
+ return Ret.release();
}
if (EC)
return EC;
- return Ret.take();
+ return Ret.release();
}
} // end namespace object
OwningPtr<MachOUniversalBinary> Ret(new MachOUniversalBinary(Source, EC));
if (EC)
return EC;
- return Ret.take();
+ return Ret.release();
}
MachOUniversalBinary::MachOUniversalBinary(MemoryBuffer *Source,
OwningPtr<MemoryBuffer> File;
if (error_code EC = MemoryBuffer::getFile(ObjectPath, File))
return EC;
- return createObjectFile(File.take());
+ return createObjectFile(File.release());
}
if (!NewBuf) return ~0U;
- return AddNewSourceBuffer(NewBuf.take(), IncludeLoc);
+ return AddNewSourceBuffer(NewBuf.release(), IncludeLoc);
}
<< ec.message() <<"\n";
return 1;
}
- MemoryBuffer *F = File.take();
+ MemoryBuffer *F = File.release();
// Tell SrcMgr about this buffer, which is what TGParser will pick up.
SrcMgr.AddNewSourceBuffer(F, SMLoc());
OwningPtr<SpecialCaseList> SCL(new SpecialCaseList());
if (!SCL->parse(MB, Error))
return 0;
- return SCL.take();
+ return SCL.release();
}
SpecialCaseList *SpecialCaseList::createOrDie(const StringRef Path) {
<< "' passes compile correctly after the '"
<< getPassesString(Prefix) << "' passes: ";
- OwningPtr<Module> OriginalInput(BD.swapProgramIn(PrefixOutput.take()));
+ OwningPtr<Module> OriginalInput(BD.swapProgramIn(PrefixOutput.release()));
if (BD.runPasses(BD.getProgram(), Suffix, BitcodeResult, false/*delete*/,
true/*quiet*/)) {
errs() << " Error running this sequence of passes"
// Otherwise, we must not be running the bad pass anymore.
outs() << " yup.\n"; // No miscompilation!
// Restore orig program & free test.
- delete BD.swapProgramIn(OriginalInput.take());
+ delete BD.swapProgramIn(OriginalInput.release());
return NoFailure;
}
Err.print(argv[0], errs());
return 1;
}
- object::Archive *Ar = new object::Archive(ArBuf.take(), ec);
+ object::Archive *Ar = new object::Archive(ArBuf.release(), ec);
if (ec || !Ar) {
Err.print(argv[0], errs());
return 1;
object::Archive::child_iterator OldMember = Member.getOld();
failIfError(OldMember->getMemoryBuffer(MemberBuffer));
}
- MemberBuffers[I] = MemberBuffer.take();
+ MemberBuffers[I] = MemberBuffer.release();
}
if (Symtab) {
}
if (!EC) {
- object::Archive Archive(Buf.take(), EC);
+ object::Archive Archive(Buf.release(), EC);
if (EC) {
errs() << ToolName << ": error loading '" << ArchiveName
return;
}
- ErrorOr<ObjectFile*> ObjOrErr(ObjectFile::createObjectFile(Buff.take()));
+ ErrorOr<ObjectFile*> ObjOrErr(ObjectFile::createObjectFile(Buff.release()));
if (error_code EC = ObjOrErr.getError()) {
errs() << Filename << ": " << EC.message() << '\n';
return;
errs() << ProgName << ": " << ec.message() << '\n';
return 1;
}
- MemoryBuffer *Buffer = BufferPtr.take();
+ MemoryBuffer *Buffer = BufferPtr.release();
SourceMgr SrcMgr;
errs() << ToolName << ": " << ec.message() << '\n';
return;
}
- MemoryBuffer *Buffer = BufferPtr.take();
+ MemoryBuffer *Buffer = BufferPtr.release();
SourceMgr SrcMgr;
return;
LLVMContext &Context = getGlobalContext();
- ErrorOr<Binary *> BinaryOrErr = createBinary(Buffer.take(), &Context);
+ ErrorOr<Binary *> BinaryOrErr = createBinary(Buffer.release(), &Context);
if (error(BinaryOrErr.getError(), Filename))
return;
OwningPtr<Binary> Bin(BinaryOrErr.get());
}
OwningPtr<MachOObjectFile> MachOOF(static_cast<MachOObjectFile *>(
- ObjectFile::createMachOObjectFile(Buff.take()).get()));
+ ObjectFile::createMachOObjectFile(Buff.release()).get()));
DisassembleInputMachO2(Filename, MachOOF.get());
}
errs() << "llvm-objdump: " << Filename << ": " << ec.message() << '\n';
return;
}
- DbgObj = ObjectFile::createMachOObjectFile(Buf.take()).get();
+ DbgObj = ObjectFile::createMachOObjectFile(Buf.release()).get();
}
// Setup the DIContext
return Error("unable to read input: '" + ec.message() + "'");
// Load the object file
- LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.take())));
+ LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.release())));
if (!LoadedObject) {
return Error(Dyld.getErrorString());
}
return Error("unable to read input: '" + ec.message() + "'");
// Load the object file
- LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.take())));
+ LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.release())));
if (!LoadedObject) {
return Error(Dyld.getErrorString());
}
if (!error(BinaryOrErr.getError())) {
OwningPtr<Binary> ParsedBinary(BinaryOrErr.get());
// Check if it's a universal binary.
- Bin = ParsedBinary.take();
+ Bin = ParsedBinary.release();
ParsedBinariesAndObjects.push_back(Bin);
if (Bin->isMachO() || Bin->isMachOUniversalBinary()) {
// On Darwin we may find DWARF in separate object file in
return I->second;
OwningPtr<ObjectFile> ParsedObj;
if (!UB->getObjectForArch(Triple(ArchName).getArch(), ParsedObj)) {
- Res = ParsedObj.take();
+ Res = ParsedObj.release();
ParsedBinariesAndObjects.push_back(Res);
}
ObjectFileForArch[std::make_pair(UB, ArchName)] = Res;
errs() << "Error: '" << ec.message() << "' opening file '" << InputFilename
<< "'\n";
} else {
- ec = coff2yaml(outs(), buf.take());
+ ec = coff2yaml(outs(), buf.release());
if (ec)
errs() << "Error: " << ec.message() << " dumping COFF file\n";
}
Function *FA, *FB;
createTwoModuleCase(A, FA, B, FB);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
checkAdd(ptr);
Function *FA, *FB;
createTwoModuleCase(A, FA, B, FB);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
TheJIT->finalizeObject();
Function *FA, *FB;
createTwoModuleExternCase(A, FA, B, FB);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
TheJIT->finalizeObject();
Function *FA, *FB;
createTwoModuleExternCase(A, FA, B, FB);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
checkAdd(ptr);
createTwoModuleExternCase(A, FA1, B, FB);
FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
TheJIT->finalizeObject();
FB = startFunction<int32_t(void)>(B.get(), "FB");
endFunctionWithRet(FB, Builder.CreateLoad(GVB));
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t FBPtr = TheJIT->getFunctionAddress(FB->getName().str());
TheJIT->finalizeObject();
Function *FA, *FB, *FC;
createThreeModuleCase(A, FA, B, FB, C, FC);
- createJIT(A.take());
- TheJIT->addModule(B.take());
- TheJIT->addModule(C.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
+ TheJIT->addModule(C.release());
uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
checkAdd(ptr);
Function *FA, *FB, *FC;
createThreeModuleCase(A, FA, B, FB, C, FC);
- createJIT(A.take());
- TheJIT->addModule(B.take());
- TheJIT->addModule(C.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
+ TheJIT->addModule(C.release());
uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
checkAdd(ptr);
Function *FA, *FB, *FC;
createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
- createJIT(A.take());
- TheJIT->addModule(B.take());
- TheJIT->addModule(C.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
+ TheJIT->addModule(C.release());
uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
checkAdd(ptr);
Function *FA, *FB, *FC;
createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
- createJIT(A.take());
- TheJIT->addModule(B.take());
- TheJIT->addModule(C.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
+ TheJIT->addModule(C.release());
uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
checkAdd(ptr);
Function *FA, *FB1, *FB2;
createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
checkAccumulate(ptr);
Function *FA, *FB1, *FB2;
createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
checkAccumulate(ptr);
Function *FA, *FB1, *FB2;
createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
- createJIT(A.take());
- TheJIT->addModule(B.take());
+ createJIT(A.release());
+ TheJIT->addModule(B.release());
uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
checkAccumulate(ptr);
TEST_F(MCJITObjectCacheTest, SetNullObjectCache) {
SKIP_UNSUPPORTED_PLATFORM;
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(NULL);
// Save a copy of the module pointer before handing it off to MCJIT.
const Module * SavedModulePointer = M.get();
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(Cache.get());
OwningPtr<TestObjectCache> Cache(new TestObjectCache);
// Compile this module with an MCJIT engine
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(Cache.get());
TheJIT->finalizeObject();
const Module * SecondModulePointer = M.get();
// Create a new MCJIT instance to load this module then execute it.
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(Cache.get());
compileAndRun();
OwningPtr<TestObjectCache> Cache(new TestObjectCache);
// Compile this module with an MCJIT engine
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(Cache.get());
TheJIT->finalizeObject();
const Module * SecondModulePointer = M.get();
// Create a new MCJIT instance to load this module then execute it.
- createJIT(M.take());
+ createJIT(M.release());
TheJIT->setObjectCache(Cache.get());
// Verify that our object cache does not contain the module yet.
int initialValue = 5;
GlobalValue *Global = insertGlobalInt32(M.get(), "test_global", initialValue);
- createJIT(M.take());
+ createJIT(M.release());
void *globalPtr = TheJIT->getPointerToGlobal(Global);
EXPECT_TRUE(0 != globalPtr)
<< "Unable to get pointer to global value from JIT";
SKIP_UNSUPPORTED_PLATFORM;
Function *F = insertAddFunction(M.get());
- createJIT(M.take());
+ createJIT(M.release());
uint64_t addPtr = TheJIT->getFunctionAddress(F->getName().str());
EXPECT_TRUE(0 != addPtr)
<< "Unable to get pointer to function from JIT";
int rc = 6;
Function *Main = insertMainFunction(M.get(), 6);
- createJIT(M.take());
+ createJIT(M.release());
uint64_t ptr = TheJIT->getFunctionAddress(Main->getName().str());
EXPECT_TRUE(0 != ptr)
<< "Unable to get pointer to main() from JIT";
Value *ReadGlobal = Builder.CreateLoad(GV);
endFunctionWithRet(ReturnGlobal, ReadGlobal);
- createJIT(M.take());
+ createJIT(M.release());
uint64_t rgvPtr = TheJIT->getFunctionAddress(ReturnGlobal->getName().str());
EXPECT_TRUE(0 != rgvPtr);
Inner = Outer;
}
- createJIT(M.take());
+ createJIT(M.release());
uint64_t ptr = TheJIT->getFunctionAddress(Outer->getName().str());
EXPECT_TRUE(0 != ptr)
<< "Unable to get pointer to outer function from JIT";
// If we want to canonicalize whitespace, strip excess whitespace from the
// buffer containing the CHECK lines. Remove DOS style line endings.
MemoryBuffer *F =
- CanonicalizeInputFile(File.take(), NoCanonicalizeWhiteSpace);
+ CanonicalizeInputFile(File.release(), NoCanonicalizeWhiteSpace);
SM.AddNewSourceBuffer(F, SMLoc());
// Remove duplicate spaces in the input file if requested.
// Remove DOS style line endings.
MemoryBuffer *F =
- CanonicalizeInputFile(File.take(), NoCanonicalizeWhiteSpace);
+ CanonicalizeInputFile(File.release(), NoCanonicalizeWhiteSpace);
SM.AddNewSourceBuffer(F, SMLoc());
StringRef(II->TheDef->getName()).endswith("_Int"))
continue;
- Matchables.push_back(II.take());
+ Matchables.push_back(II.release());
}
// Parse all of the InstAlias definitions and stick them in the list of
// Validate the alias definitions.
II->validate(CommentDelimiter, false);
- Matchables.push_back(II.take());
+ Matchables.push_back(II.release());
}
}
AliasII->formTwoOperandAlias(Constraint);
// Add the alias to the matchables list.
- NewMatchables.push_back(AliasII.take());
+ NewMatchables.push_back(AliasII.release());
}
} else
II->buildAliasResultOperands();
Matcher *getNext() { return Next.get(); }
const Matcher *getNext() const { return Next.get(); }
void setNext(Matcher *C) { Next.reset(C); }
- Matcher *takeNext() { return Next.take(); }
+ Matcher *takeNext() { return Next.release(); }
OwningPtr<Matcher> &getNextPtr() { return Next; }
for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
OwningPtr<Matcher> Child(Scope->takeChild(i));
ContractNodes(Child, CGP);
- Scope->resetChild(i, Child.take());
+ Scope->resetChild(i, Child.release());
}
return;
}
if (New) {
// Insert the new node.
- New->setNext(MatcherPtr.take());
+ New->setNext(MatcherPtr.release());
MatcherPtr.reset(New);
// Remove the old one.
MC->setNext(MC->getNext()->takeNext());
if (isa<EmitNodeMatcher>(N) && isa<MarkGlueResultsMatcher>(N->getNext()) &&
isa<CompleteMatchMatcher>(N->getNext()->getNext())) {
// Unlink the two nodes from the list.
- Matcher *EmitNode = MatcherPtr.take();
+ Matcher *EmitNode = MatcherPtr.release();
Matcher *MFR = EmitNode->takeNext();
Matcher *Tail = MFR->takeNext();
isa<RecordMatcher>(N)) &&
isa<CheckOpcodeMatcher>(N->getNext())) {
// Unlink the two nodes from the list.
- Matcher *CheckType = MatcherPtr.take();
+ Matcher *CheckType = MatcherPtr.release();
Matcher *CheckOpcode = CheckType->takeNext();
Matcher *Tail = CheckOpcode->takeNext();
for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
OwningPtr<Matcher> Child(Scope->takeChild(i));
SinkPatternPredicates(Child);
- Scope->resetChild(i, Child.take());
+ Scope->resetChild(i, Child.release());
}
return;
}
// Okay, we know we can sink it past at least one node. Unlink it from the
// chain and scan for the new insertion point.
- MatcherPtr.take(); // Don't delete CPPM.
+ MatcherPtr.release(); // Don't delete CPPM.
MatcherPtr.reset(CPPM->takeNext());
N = MatcherPtr.get();
OwningPtr<Matcher> Child(Scope->takeChild(i));
FactorNodes(Child);
- if (Matcher *N = Child.take())
+ if (Matcher *N = Child.release())
OptionsToMatch.push_back(N);
}
ContractNodes(MatcherPtr, CGP);
SinkPatternPredicates(MatcherPtr);
FactorNodes(MatcherPtr);
- return MatcherPtr.take();
+ return MatcherPtr.release();
}