From 51cbcbf435d1aaa1a5269d62b5d0b31b57316b4a Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 20 Nov 2002 20:47:41 +0000 Subject: [PATCH] Initial checkin of Module cloning support stuff git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4788 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Utils/CloneFunction.cpp | 6 +- lib/Transforms/Utils/CloneModule.cpp | 73 +++++++++++++++++++++ lib/Transforms/Utils/ValueMapper.cpp | 88 ++++++++++++++++++++++++++ lib/Transforms/Utils/ValueMapper.h | 16 +++++ 4 files changed, 179 insertions(+), 4 deletions(-) create mode 100644 lib/Transforms/Utils/CloneModule.cpp create mode 100644 lib/Transforms/Utils/ValueMapper.cpp create mode 100644 lib/Transforms/Utils/ValueMapper.h diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index 29c7aaa0374..ca22003b409 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -10,6 +10,7 @@ #include "llvm/iTerminators.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "ValueMapper.h" // RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. @@ -18,10 +19,7 @@ static inline void RemapInstruction(Instruction *I, std::map &ValueMap) { for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { const Value *Op = I->getOperand(op); - Value *V = ValueMap[Op]; - if (!V && (isa(Op) || isa(Op))) - continue; // Globals and constants don't get relocated - + Value *V = MapValue(Op, ValueMap); #ifndef NDEBUG if (!V) { std::cerr << "Val = \n" << Op << "Addr = " << (void*)Op; diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp new file mode 100644 index 00000000000..043e06d5437 --- /dev/null +++ b/lib/Transforms/Utils/CloneModule.cpp @@ -0,0 +1,73 @@ +//===- CloneModule.cpp - Clone an entire module ---------------------------===// +// +// This file implements the CloneModule interface which makes a copy of an +// entire module. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/Utils/Cloning.h" +#include "llvm/Module.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Constant.h" +#include "ValueMapper.h" + +/// CloneModule - Return an exact copy of the specified module. This is not as +/// easy as it might seem because we have to worry about making copies of global +/// variables and functions, and making their (intializers and references, +/// respectively) refer to the right globals. +/// +Module *CloneModule(const Module *M) { + // First off, we need to create the new module... + Module *New = new Module(); + + // Create the value map that maps things from the old module over to the new + // module. + std::map ValueMap; + + // Loop over all of the global variables, making corresponding globals in the + // new module. Here we add them to the ValueMap and to the new Module. We + // don't worry about attributes or initializers, they will come later. + // + for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) + ValueMap[I] = new GlobalVariable(I->getType()->getElementType(), + false, false, 0, I->getName(), New); + + // Loop over the functions in the module, making external functions as before + for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) + ValueMap[I]=new Function(cast(I->getType()->getElementType()), + false, I->getName(), New); + + // Now that all of the things that global variable initializer can refer to + // have been created, loop through and copy the global variable referrers + // over... We also set the attributes on the global now. + // + for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) { + GlobalVariable *GV = cast(ValueMap[I]); + if (I->hasInitializer()) + GV->setInitializer(cast(MapValue(I->getInitializer(), + ValueMap))); + if (I->hasInternalLinkage()) + GV->setInternalLinkage(true); + } + + // Similarly, copy over function bodies now... + // + for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { + Function *F = cast(ValueMap[I]); + if (!I->isExternal()) { + Function::aiterator DestI = F->abegin(); + for (Function::const_aiterator J = I->abegin(); J != I->aend(); ++J) { + DestI->setName(J->getName()); + ValueMap[J] = DestI++; + } + + std::vector Returns; // Ignore returns cloned... + CloneFunctionInto(F, I, ValueMap, Returns); + } + + if (I->hasInternalLinkage()) + F->setInternalLinkage(true); + } + + return New; +} diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp new file mode 100644 index 00000000000..e6ab2974283 --- /dev/null +++ b/lib/Transforms/Utils/ValueMapper.cpp @@ -0,0 +1,88 @@ +//===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===// +// +// This file defines the MapValue function, which is shared by various parts of +// the lib/Transforms/Utils library. +// +//===----------------------------------------------------------------------===// + +#include "ValueMapper.h" +#include "llvm/Constants.h" +#include "llvm/Instruction.h" + +Value *MapValue(const Value *V, std::map &VM) { + Value *&VMSlot = VM[V]; + if (VMSlot) return VMSlot; // Does it exist in the map yet? + + if (Constant *C = (Constant*)dyn_cast(V)) { + if (isa(C) || isa(C) || + isa(C)) + return VMSlot = C; // Primitive constants map directly + else if (ConstantPointerRef *CPR = dyn_cast(C)) { + GlobalValue *MV = cast(MapValue((Value*)CPR->getValue(),VM)); + return VMSlot = ConstantPointerRef::get(MV); + } else if (ConstantArray *CA = dyn_cast(C)) { + const std::vector &Vals = CA->getValues(); + for (unsigned i = 0, e = Vals.size(); i != e; ++i) { + Value *MV = MapValue(Vals[i], VM); + if (MV != Vals[i]) { + // This array must contain a reference to a global, make a new array + // and return it. + // + std::vector Values; + Values.reserve(Vals.size()); + for (unsigned j = 0; j != i; ++j) + Values.push_back(cast(Vals[j])); + Values.push_back(cast(MV)); + for (; i != e; ++i) + Values.push_back(cast(MapValue(Vals[i], VM))); + return VMSlot = ConstantArray::get(CA->getType(), Values); + } + } + return VMSlot = C; + + } else if (ConstantStruct *CS = dyn_cast(C)) { + const std::vector &Vals = CS->getValues(); + for (unsigned i = 0, e = Vals.size(); i != e; ++i) { + Value *MV = MapValue(Vals[i], VM); + if (MV != Vals[i]) { + // This struct must contain a reference to a global, make a new struct + // and return it. + // + std::vector Values; + Values.reserve(Vals.size()); + for (unsigned j = 0; j != i; ++j) + Values.push_back(cast(Vals[j])); + Values.push_back(cast(MV)); + for (; i != e; ++i) + Values.push_back(cast(MapValue(Vals[i], VM))); + return VMSlot = ConstantStruct::get(CS->getType(), Values); + } + } + return VMSlot = C; + + } else if (ConstantExpr *CE = dyn_cast(C)) { + if (CE->getOpcode() == Instruction::Cast) { + Constant *MV = cast(MapValue(CE->getOperand(0), VM)); + return VMSlot = ConstantExpr::getCast(MV, CE->getType()); + } else if (CE->getOpcode() == Instruction::GetElementPtr) { + std::vector Idx; + Constant *MV = cast(MapValue(CE->getOperand(0), VM)); + for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) + Idx.push_back(cast(MapValue(CE->getOperand(i), VM))); + return VMSlot = ConstantExpr::getGetElementPtr(MV, Idx); + } else { + assert(CE->getNumOperands() == 2 && "Must be binary operator?"); + Constant *MV1 = cast(MapValue(CE->getOperand(0), VM)); + Constant *MV2 = cast(MapValue(CE->getOperand(1), VM)); + return VMSlot = ConstantExpr::get(CE->getOpcode(), MV1, MV2); + } + + } else { + assert(0 && "Unknown type of constant!"); + } + } + + assert(0 && "Unknown value type: why didn't it get resolved?!"); + return 0; +} + diff --git a/lib/Transforms/Utils/ValueMapper.h b/lib/Transforms/Utils/ValueMapper.h new file mode 100644 index 00000000000..23f70588586 --- /dev/null +++ b/lib/Transforms/Utils/ValueMapper.h @@ -0,0 +1,16 @@ +//===- ValueMapper.h - Interface shared by lib/Transforms/Utils -*- C++ -*-===// +// +// This file defines the MapValue interface which is used by various parts of +// the Transforms/Utils library to implement cloning and linking facilities. +// +//===----------------------------------------------------------------------===// + +#ifndef LIB_TRANSFORMS_UTILS_VALUE_MAPPER_H +#define LIB_TRANSFORMS_UTILS_VALUE_MAPPER_H + +#include +class Value; + +Value *MapValue(const Value *V, std::map &VM); + +#endif -- 2.34.1