6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-19 04:29:21 +00:00
Code Issues Projects Releases Wiki Activity

the bytecode reader supports dematerializeFunction

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35475 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2007-03-29 18:58:08 +00:00
parent cb2df95c88
commit f735f7b3ac
2 changed files with 22 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/Bytecode/Reader/Reader.cpp
View File

@ -1636,8 +1636,6 @@ bool BytecodeReader::ParseFunction(Function* Func, std::string* ErrMsg) {
BlockEnd = Fi->second.EndBuf;
assert(Fi->first == Func && "Found wrong function?");
LazyFunctionLoadMap.erase(Fi);
this->ParseFunctionBody(Func);
return false;
}
@ -1668,7 +1666,6 @@ bool BytecodeReader::ParseAllFunctionBodies(std::string* ErrMsg) {
ParseFunctionBody(Func);
++Fi;
}
LazyFunctionLoadMap.clear();
return false;
}

26
lib/Bytecode/Reader/Reader.h
View File

@ -154,20 +154,38 @@ public:
bool ParseAllFunctionBodies(std::string* ErrMsg);
/// @brief Parse the next function of specific type
bool ParseFunction(Function* Func, std::string* ErrMsg) ;
bool ParseFunction(Function* Func, std::string* ErrMsg);
/// This method is abstract in the parent ModuleProvider class. Its
/// implementation is identical to the ParseFunction method.
/// @see ParseFunction
/// @brief Make a specific function materialize.
virtual bool materializeFunction(Function *F, std::string *ErrMsg = 0) {
LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(F);
if (Fi == LazyFunctionLoadMap.end())
return false;
// If it already is material, ignore the request.
if (!F->hasNotBeenReadFromBytecode()) return false;
assert(LazyFunctionLoadMap.count(F) &&
"not materialized but I don't know about it?");
if (ParseFunction(F,ErrMsg))
return true;
return false;
}
/// dematerializeFunction - If the given function is read in, and if the
/// module provider supports it, release the memory for the function, and set
/// it up to be materialized lazily. If the provider doesn't support this
/// capability, this method is a noop.
///
virtual void dematerializeFunction(Function *F) {
// If the function is not materialized, or if it is a prototype, ignore.
if (F->hasNotBeenReadFromBytecode() ||
F->isDeclaration())
return;
// Just forget the function body, we can remat it later.
F->deleteBody();
F->setLinkage(GlobalValue::GhostLinkage);
}
/// This method is abstract in the parent ModuleProvider class. Its
/// implementation is identical to ParseAllFunctionBodies.