#include "llvm/ValueSymbolTable.h"
#include "llvm/Instructions.h"
#include "llvm/Assembly/Writer.h"
-#include "llvm/Support/Streams.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
#include "llvm/ADT/DenseMap.h"
-#include <sstream>
using namespace llvm;
// Error - Simple wrapper function to conditionally assign to E and return true.
// for debugging...
virtual void dump() const {
- cerr << "AbstractTypeSet!\n";
+ errs() << "AbstractTypeSet!\n";
}
};
}
static void PrintMap(const std::map<const Value*, Value*> &M) {
for (std::map<const Value*, Value*>::const_iterator I = M.begin(), E =M.end();
I != E; ++I) {
- cerr << " Fr: " << (void*)I->first << " ";
+ errs() << " Fr: " << (void*)I->first << " ";
I->first->dump();
- cerr << " To: " << (void*)I->second << " ";
+ errs() << " To: " << (void*)I->second << " ";
I->second->dump();
- cerr << "\n";
+ errs() << "\n";
}
}
#endif
// RemapOperand - Use ValueMap to convert constants from one module to another.
static Value *RemapOperand(const Value *In,
- std::map<const Value*, Value*> &ValueMap,
- LLVMContext &Context) {
+ std::map<const Value*, Value*> &ValueMap) {
std::map<const Value*,Value*>::const_iterator I = ValueMap.find(In);
if (I != ValueMap.end())
return I->second;
if (const ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) {
std::vector<Constant*> Operands(CPA->getNumOperands());
for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
- Operands[i] =cast<Constant>(RemapOperand(CPA->getOperand(i), ValueMap,
- Context));
- Result =
- ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands);
+ Operands[i] =cast<Constant>(RemapOperand(CPA->getOperand(i), ValueMap));
+ Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands);
} else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) {
std::vector<Constant*> Operands(CPS->getNumOperands());
for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
- Operands[i] =cast<Constant>(RemapOperand(CPS->getOperand(i), ValueMap,
- Context));
- Result =
- ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
+ Operands[i] =cast<Constant>(RemapOperand(CPS->getOperand(i), ValueMap));
+ Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
} else if (isa<ConstantPointerNull>(CPV) || isa<UndefValue>(CPV)) {
Result = const_cast<Constant*>(CPV);
} else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CPV)) {
std::vector<Constant*> Operands(CP->getNumOperands());
for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
- Operands[i] = cast<Constant>(RemapOperand(CP->getOperand(i), ValueMap,
- Context));
+ Operands[i] = cast<Constant>(RemapOperand(CP->getOperand(i), ValueMap));
Result = ConstantVector::get(Operands);
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
std::vector<Constant*> Ops;
for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
- Ops.push_back(cast<Constant>(RemapOperand(CE->getOperand(i),ValueMap,
- Context)));
+ Ops.push_back(cast<Constant>(RemapOperand(CE->getOperand(i),ValueMap)));
Result = CE->getWithOperands(Ops);
+ } else if (const BlockAddress *CE = dyn_cast<BlockAddress>(CPV)) {
+ Result = BlockAddress::get(
+ cast<Function>(RemapOperand(CE->getFunction(), ValueMap)),
+ CE->getBasicBlock());
} else {
assert(!isa<GlobalValue>(CPV) && "Unmapped global?");
llvm_unreachable("Unknown type of derived type constant value!");
}
- } else if (const MDNode *N = dyn_cast<MDNode>(In)) {
- std::vector<Value*> Elems;
- for (unsigned i = 0, e = N->getNumElements(); i !=e; ++i)
- Elems.push_back(RemapOperand(N->getElement(i), ValueMap, Context));
- if (!Elems.empty())
- Result = MDNode::get(Context, &Elems[0], Elems.size());
- } else if (const MDString *MDS = dyn_cast<MDString>(In)) {
- Result = MDString::get(Context, MDS->getString());
+ } else if (isa<MetadataBase>(In)) {
+ Result = const_cast<Value*>(In);
} else if (isa<InlineAsm>(In)) {
Result = const_cast<Value*>(In);
}
}
#ifndef NDEBUG
- cerr << "LinkModules ValueMap: \n";
+ errs() << "LinkModules ValueMap: \n";
PrintMap(ValueMap);
- cerr << "Couldn't remap value: " << (void*)In << " " << *In << "\n";
+ errs() << "Couldn't remap value: " << (void*)In << " " << *In << "\n";
llvm_unreachable("Couldn't remap value!");
#endif
return 0;
if (SGV->hasInitializer()) { // Only process initialized GV's
// Figure out what the initializer looks like in the dest module...
Constant *SInit =
- cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap,
- Dest->getContext()));
+ cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap));
// Grab destination global variable or alias.
GlobalValue *DGV = cast<GlobalValue>(ValueMap[SGV]->stripPointerCasts());
for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end();
OI != OE; ++OI)
if (!isa<Instruction>(*OI) && !isa<BasicBlock>(*OI))
- *OI = RemapOperand(*OI, ValueMap, Dest->getContext());
+ *OI = RemapOperand(*OI, ValueMap);
// There is no need to map the arguments anymore.
for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
if (!Src->getDataLayout().empty() && !Dest->getDataLayout().empty() &&
Src->getDataLayout() != Dest->getDataLayout())
- cerr << "WARNING: Linking two modules of different data layouts!\n";
+ errs() << "WARNING: Linking two modules of different data layouts!\n";
if (!Src->getTargetTriple().empty() &&
Dest->getTargetTriple() != Src->getTargetTriple())
- cerr << "WARNING: Linking two modules of different target triples!\n";
+ errs() << "WARNING: Linking two modules of different target triples!\n";
// Append the module inline asm string.
if (!Src->getModuleInlineAsm().empty()) {