1 //===- PreSelection.cpp - Specialize LLVM code for target machine ---------===//
3 // This file defines the PreSelection pass which specializes LLVM code for a
4 // target machine, while remaining in legal portable LLVM form and
5 // preserving type information and type safety. This is meant to enable
6 // dataflow optimizations on target-specific operations such as accesses to
7 // constants, globals, and array indexing.
9 //===----------------------------------------------------------------------===//
11 #include "llvm/CodeGen/PreSelection.h"
12 #include "llvm/Target/TargetMachine.h"
13 #include "llvm/Target/MachineInstrInfo.h"
14 #include "llvm/Transforms/Scalar.h"
15 #include "llvm/Support/InstVisitor.h"
16 #include "llvm/Module.h"
17 #include "llvm/Constants.h"
18 #include "llvm/iMemory.h"
19 #include "llvm/iPHINode.h"
20 #include "llvm/iOther.h"
21 #include "llvm/DerivedTypes.h"
22 #include "llvm/Pass.h"
23 #include "llvm/Annotation.h"
24 #include "Support/CommandLine.h"
25 #include "Support/NonCopyable.h"
30 //===--------------------------------------------------------------------===//
31 // SelectDebugLevel - Allow command line control over debugging.
33 enum PreSelectDebugLevel_t {
34 PreSelect_NoDebugInfo,
35 PreSelect_PrintOutput,
38 // Enable Debug Options to be specified on the command line
39 cl::opt<PreSelectDebugLevel_t>
40 PreSelectDebugLevel("dpreselect", cl::Hidden,
41 cl::desc("debug information for target-dependent pre-selection"),
43 clEnumValN(PreSelect_NoDebugInfo, "n", "disable debug output (default)"),
44 clEnumValN(PreSelect_PrintOutput, "y", "print generated machine code"),
45 /* default level = */ PreSelect_NoDebugInfo));
48 //===--------------------------------------------------------------------===//
49 // class ConstantPoolForModule:
51 // The pool of constants that must be emitted for a module.
52 // This is a single pool for the entire module and is shared by
53 // all invocations of the PreSelection pass for this module by putting
54 // this as as annotation on the Module object.
55 // A single GlobalVariable is created for each constant in the pool
56 // representing the memory for that constant.
58 static AnnotationID CPFM_AID(
59 AnnotationManager::getID("CodeGen::ConstantPoolForModule"));
61 class ConstantPoolForModule: private Annotation, public NonCopyable {
63 std::map<const Constant*, GlobalVariable*> gvars;
64 std::map<const Constant*, GlobalVariable*> origGVars;
65 ConstantPoolForModule(Module* M); // called only by annotation builder
66 ConstantPoolForModule(); // do not implement
68 static ConstantPoolForModule& get(Module* M) {
69 ConstantPoolForModule* cpool =
70 (ConstantPoolForModule*) M->getAnnotation(CPFM_AID);
71 if (cpool == NULL) // create a new annotation and add it to the Module
72 M->addAnnotation(cpool = new ConstantPoolForModule(M));
76 GlobalVariable* getGlobalForConstant(Constant* CV) {
77 std::map<const Constant*, GlobalVariable*>::iterator I = gvars.find(CV);
79 return I->second; // global exists so return it
80 return addToConstantPool(CV); // create a new global and return it
83 GlobalVariable* addToConstantPool(Constant* CV) {
84 GlobalVariable*& GV = gvars[CV]; // handle to global var entry in map
86 { // check if a global constant already existed; otherwise create one
87 std::map<const Constant*, GlobalVariable*>::iterator PI =
89 if (PI != origGVars.end())
90 GV = PI->second; // put in map
93 GV = new GlobalVariable(CV->getType(), true,true,CV); //put in map
94 myModule->getGlobalList().push_back(GV); // GV owned by module now
102 ConstantPoolForModule::ConstantPoolForModule(Module* M)
103 : Annotation(CPFM_AID), myModule(M)
105 // Build reverse map for pre-existing global constants so we can find them
106 for (Module::giterator GI = M->gbegin(), GE = M->gend(); GI != GE; ++GI)
107 if (GI->hasInitializer() && GI->isConstant())
108 origGVars[GI->getInitializer()] = GI;
111 //===--------------------------------------------------------------------===//
112 // PreSelection Pass - Specialize LLVM code for the current target machine.
113 // This was and will be a basicblock pass, but make it a FunctionPass until
114 // BasicBlockPass ::doFinalization(Function&) is available.
116 class PreSelection : public BasicBlockPass, public InstVisitor<PreSelection>
118 const TargetMachine ⌖
121 GetElementPtrInst* getGlobalAddr(Value* ptr, Instruction* insertBefore = 0);
123 GlobalVariable* getGlobalForConstant(Constant* CV) {
124 Module* M = function->getParent();
125 return ConstantPoolForModule::get(M).getGlobalForConstant(CV);
129 PreSelection (const TargetMachine &T): target(T), function(NULL) {}
131 // runOnBasicBlock - apply this pass to each BB
132 bool runOnBasicBlock(BasicBlock &BB) {
133 function = BB.getParent();
138 bool doFinalization(Function &F) {
139 if (PreSelectDebugLevel >= PreSelect_PrintOutput)
140 cerr << "\n\n*** LLVM code after pre-selection for function "
141 << F.getName() << ":\n\n" << F;
145 // These methods do the actual work of specializing code
146 void visitInstruction(Instruction &I); // common work for every instr.
147 void visitGetElementPtrInst(GetElementPtrInst &I);
148 void visitLoadInst(LoadInst &I);
149 void visitCastInst(CastInst &I);
150 void visitStoreInst(StoreInst &I);
152 // Helper functions for visiting operands of every instruction
153 void visitOperands(Instruction &I); // work on all operands of instr.
154 void visitOneOperand(Instruction &I, Constant* CV, unsigned opNum,
155 Instruction& insertBefore); // iworks on one operand
157 } // end anonymous namespace
160 // Register the pass...
161 static RegisterOpt<PreSelection> X("preselect",
162 "Specialize LLVM code for a target machine",
163 createPreSelectionPass);
165 // PreSelection::getGlobalAddr: Put address of a global into a v. register.
167 PreSelection::getGlobalAddr(Value* ptr, Instruction* insertBefore)
169 return (isa<GlobalValue>(ptr))
170 ? new GetElementPtrInst(ptr,
171 std::vector<Value*>(1, ConstantSInt::get(Type::LongTy, 0U)),
172 "addrOfGlobal", insertBefore)
177 //------------------------------------------------------------------------------
178 // Instruction visitor methods to perform instruction-specific operations
179 //------------------------------------------------------------------------------
181 // Common work for *all* instructions. This needs to be called explicitly
182 // by other visit<InstructionType> functions.
184 PreSelection::visitInstruction(Instruction &I)
186 visitOperands(I); // Perform operand transformations
190 // GetElementPtr instructions: check if pointer is a global
192 PreSelection::visitGetElementPtrInst(GetElementPtrInst &I)
194 // Check for a global and put its address into a register before this instr
195 if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
196 I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
198 // Decompose multidimensional array references
199 DecomposeArrayRef(&I);
201 // Perform other transformations common to all instructions
206 // Load instructions: check if pointer is a global
208 PreSelection::visitLoadInst(LoadInst &I)
210 // Check for a global and put its address into a register before this instr
211 if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
212 I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
214 // Perform other transformations common to all instructions
219 // Store instructions: check if pointer is a global
221 PreSelection::visitStoreInst(StoreInst &I)
223 // Check for a global and put its address into a register before this instr
224 if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
225 I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
227 // Perform other transformations common to all instructions
232 // Cast instructions: make multi-step casts explicit
233 // -- float/double to uint32_t:
234 // If target does not have a float-to-unsigned instruction, we
235 // need to convert to uint64_t and then to uint32_t, or we may
236 // overflow the signed int representation for legal uint32_t
237 // values. Expand this without checking target.
240 PreSelection::visitCastInst(CastInst &I)
242 CastInst* castI = NULL;
244 // Check for a global and put its address into a register before this instr
245 if (I.getType() == Type::UIntTy &&
246 I.getOperand(0)->getType()->isFloatingPoint())
247 { // insert a cast-fp-to-long before I, and then replace the operand of I
248 castI = new CastInst(I.getOperand(0), Type::LongTy, "fp2Long2Uint", &I);
249 I.setOperand(0, castI); // replace fp operand with long
252 // Perform other transformations common to all instructions
255 visitInstruction(*castI);
259 // visitOperands() transforms individual operands of all instructions:
260 // -- Load "large" int constants into a virtual register. What is large
261 // depends on the type of instruction and on the target architecture.
262 // -- For any constants that cannot be put in an immediate field,
263 // load address into virtual register first, and then load the constant.
266 PreSelection::visitOperands(Instruction &I)
268 // For any instruction other than PHI, copies go just before the instr.
269 // For a PHI, operand copies must be before the terminator of the
270 // appropriate predecessor basic block. Remaining logic is simple
271 // so just handle PHIs and other instructions separately.
273 if (PHINode* phi = dyn_cast<PHINode>(&I))
275 for (unsigned i=0, N=phi->getNumIncomingValues(); i < N; ++i)
276 if (Constant* CV = dyn_cast<Constant>(phi->getIncomingValue(i)))
277 this->visitOneOperand(I, CV, phi->getOperandNumForIncomingValue(i),
278 * phi->getIncomingBlock(i)->getTerminator());
281 for (unsigned i=0, N=I.getNumOperands(); i < N; ++i)
282 if (Constant* CV = dyn_cast<Constant>(I.getOperand(i)))
283 this->visitOneOperand(I, CV, i, I);
287 PreSelection::visitOneOperand(Instruction &I, Constant* CV, unsigned opNum,
288 Instruction& insertBefore)
290 if (target.getInstrInfo().ConstantTypeMustBeLoaded(CV))
291 { // load address of constant into a register, then load the constant
292 GetElementPtrInst* gep = getGlobalAddr(getGlobalForConstant(CV),
294 LoadInst* ldI = new LoadInst(gep, "loadConst", &insertBefore);
295 I.setOperand(opNum, ldI); // replace operand with copy in v.reg.
297 else if (target.getInstrInfo().ConstantMayNotFitInImmedField(CV, &I))
298 { // put the constant into a virtual register using a cast
299 CastInst* castI = new CastInst(CV, CV->getType(), "copyConst",
301 I.setOperand(opNum, castI); // replace operand with copy in v.reg.
305 //===----------------------------------------------------------------------===//
306 // createPreSelectionPass - Public entrypoint for pre-selection pass
307 // and this file as a whole...
310 createPreSelectionPass(TargetMachine &T)
312 return new PreSelection(T);