RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 11:42:57 +01:00
Code Issues Projects Releases Wiki Activity

Checking in Chris's suggestions:

Browse Source 
Added assert() to ensure symbol table is well formed.
Added code to remember the value that was found; resolving types can change
the symbol table and invalidate the value of the iterator.
Added comments to the ResolveTypes() function (mainly for my own benefit).
Please feel free to correct the comments if they are not accurate.

llvm-svn: 9693
This commit is contained in:
John Criswell 2003-11-04 15:22:26 +00:00
parent 790547084f
commit 3e30e40801
1 changed files with 32 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
lib/Transforms/Utils/Linker.cpp
View File

@ -31,8 +31,23 @@ static inline bool Error(std::string *E, const std::string &Message) {
return true;
}
// ResolveTypes - Attempt to link the two specified types together. Return true
// if there is an error and they cannot yet be linked.
//
// Function: ResolveTypes()
//
// Description:
// Attempt to link the two specified types together.
//
// Inputs:
// DestTy - The type to which we wish to resolve.
// SrcTy - The original type which we want to resolve.
// Name - The name of the type.
//
// Outputs:
// DestST - The symbol table in which the new type should be placed.
//
// Return value:
// true - There is an error and the types cannot yet be linked.
// false - No errors.
//
static bool ResolveTypes(const Type *DestTy, const Type *SrcTy,
SymbolTable *DestST, const std::string &Name) {
@ -356,13 +371,27 @@ static GlobalValue *FindGlobalNamed(const std::string &Name, const Type *Ty,
for (SymbolTable::iterator I = ST->begin(), E = ST->end(); I != E; ++I)
if (I->first != Type::TypeTy) {
SymbolTable::VarMap &VM = I->second;
// Does this type plane contain an entry with the specified name?
SymbolTable::type_iterator TI = VM.find(Name);
if (TI != VM.end()) {
//
// Ensure that this type if placed correctly into the symbol table.
//
assert(TI->second->getType() == I->first && "Type conflict!");
//
// Save a reference to the new type. Resolving the type can modify the
// symbol table, invalidating the TI variable.
//
Value *ValPtr = TI->second;
//
// Determine whether we can fold the two types together, resolving them.
// If so, we can use this value.
//
if (!RecursiveResolveTypes(Ty, I->first, ST, ""))
return cast<GlobalValue>(TI->second);
return cast<GlobalValue>(ValPtr);
}
}
return 0; // Otherwise, nothing could be found.