lib/Target/SparcV9/SparcV9PreSelection.cpp

   1 //===- PreSelection.cpp - Specialize LLVM code for target machine ---------===//
   2 //
   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.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  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"
  26 using std::map;
  27 using std::cerr;
  28
  29 namespace {
  30   //===--------------------------------------------------------------------===//
  31   // SelectDebugLevel - Allow command line control over debugging.
  32   //
  33   enum PreSelectDebugLevel_t {
  34     PreSelect_NoDebugInfo,
  35     PreSelect_PrintOutput,
  36   };
  37
  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"),
  42      cl::values(
  43        clEnumValN(PreSelect_NoDebugInfo, "n", "disable debug output (default)"),
  44        clEnumValN(PreSelect_PrintOutput, "y", "print generated machine code"),
  45        /* default level = */ PreSelect_NoDebugInfo));
  46
  47
  48   //===--------------------------------------------------------------------===//
  49   // class ConstantPoolForModule:
  50   //
  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.
  57   //
  58   static AnnotationID CPFM_AID(
  59                  AnnotationManager::getID("CodeGen::ConstantPoolForModule"));
  60
  61   class ConstantPoolForModule: private Annotation, public NonCopyable {
  62     Module* myModule;
  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
  67   public:
  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));
  73       return *cpool;
  74     }
  75
  76     GlobalVariable* getGlobalForConstant(Constant* CV) {
  77       std::map<const Constant*, GlobalVariable*>::iterator I = gvars.find(CV);
  78       if (I != gvars.end())
  79         return I->second;               // global exists so return it
  80       return addToConstantPool(CV);     // create a new global and return it
  81     }
  82
  83     GlobalVariable*  addToConstantPool(Constant* CV) {
  84       GlobalVariable*& GV = gvars[CV];  // handle to global var entry in map
  85       if (GV == NULL)
  86         { // check if a global constant already existed; otherwise create one
  87           std::map<const Constant*, GlobalVariable*>::iterator PI =
  88             origGVars.find(CV);
  89           if (PI != origGVars.end())
  90             GV = PI->second;            // put in map
  91           else
  92             {
  93               GV = new GlobalVariable(CV->getType(), true,true,CV); //put in map
  94               myModule->getGlobalList().push_back(GV); // GV owned by module now
  95             }
  96         }
  97       return GV;
  98     }
  99   };
 100
 101   /* ctor */
 102   ConstantPoolForModule::ConstantPoolForModule(Module* M)
 103     : Annotation(CPFM_AID), myModule(M)
 104   {
 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;
 109   }
 110
 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.
 115   //
 116   class PreSelection : public BasicBlockPass, public InstVisitor<PreSelection>
 117   {
 118     const TargetMachine &target;
 119     Function* function;
 120
 121     GetElementPtrInst* getGlobalAddr(Value* ptr, Instruction* insertBefore = 0);
 122
 123     GlobalVariable* getGlobalForConstant(Constant* CV) {
 124       Module* M = function->getParent();
 125       return ConstantPoolForModule::get(M).getGlobalForConstant(CV);
 126     }
 127
 128   public:
 129     PreSelection (const TargetMachine &T): target(T), function(NULL) {}
 130
 131     // runOnBasicBlock - apply this pass to each BB
 132     bool runOnBasicBlock(BasicBlock &BB) {
 133       function = BB.getParent();
 134       this->visit(BB);
 135       return true;
 136     }
 137
 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;
 142       return false;
 143     }
 144
 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 visitStoreInst(StoreInst &I);
 150
 151     // Helper functions for visiting operands of every instruction
 152     void visitOperands(Instruction &I);    // work on all operands of instr.
 153     void visitOneOperand(Instruction &I, Constant* CV, unsigned opNum,
 154                          Instruction& insertBefore); // iworks on one operand
 155   };
 156 }  // end anonymous namespace
 157
 158
 159 // Register the pass...
 160 static RegisterOpt<PreSelection> X("preselect",
 161                                    "Specialize LLVM code for a target machine",
 162                                    createPreSelectionPass);
 163
 164 // PreSelection::getGlobalAddr: Put address of a global into a v. register.
 165 GetElementPtrInst*
 166 PreSelection::getGlobalAddr(Value* ptr, Instruction* insertBefore)
 167 {
 168   return (isa<GlobalValue>(ptr))
 169     ? new GetElementPtrInst(ptr,
 170                     std::vector<Value*>(1, ConstantSInt::get(Type::LongTy, 0U)),
 171                     "addrOfGlobal", insertBefore)
 172     : NULL;
 173 }
 174
 175
 176 //------------------------------------------------------------------------------
 177 // Instruction visitor methods to perform instruction-specific operations
 178 //------------------------------------------------------------------------------
 179
 180 // Common work for *all* instructions.  This needs to be called explicitly
 181 // by other visit<InstructionType> functions.
 182 inline void
 183 PreSelection::visitInstruction(Instruction &I)
 184 {
 185   visitOperands(I);              // Perform operand transformations
 186 }
 187
 188
 189 // GetElementPtr instructions: check if pointer is a global
 190 void
 191 PreSelection::visitGetElementPtrInst(GetElementPtrInst &I)
 192 {
 193   // Check for a global and put its address into a register before this instr
 194   if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
 195     I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
 196
 197   // Decompose multidimensional array references
 198   DecomposeArrayRef(&I);
 199
 200   // Perform other transformations common to all instructions
 201   visitInstruction(I);
 202 }
 203
 204
 205 // Load instructions: check if pointer is a global
 206 void
 207 PreSelection::visitLoadInst(LoadInst &I)
 208 {
 209   // Check for a global and put its address into a register before this instr
 210   if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
 211     I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
 212
 213   // Perform other transformations common to all instructions
 214   visitInstruction(I);
 215 }
 216
 217
 218 // Store instructions: check if pointer is a global
 219 void
 220 PreSelection::visitStoreInst(StoreInst &I)
 221 {
 222   // Check for a global and put its address into a register before this instr
 223   if (GetElementPtrInst* gep = getGlobalAddr(I.getPointerOperand(), &I))
 224     I.setOperand(I.getPointerOperandIndex(), gep); // replace pointer operand
 225
 226   // Perform other transformations common to all instructions
 227   visitInstruction(I);
 228 }
 229
 230
 231 // visitOperands() transforms individual operands of all instructions:
 232 // -- Load "large" int constants into a virtual register.  What is large
 233 //    depends on the type of instruction and on the target architecture.
 234 // -- For any constants that cannot be put in an immediate field,
 235 //    load address into virtual register first, and then load the constant.
 236 //
 237 void
 238 PreSelection::visitOperands(Instruction &I)
 239 {
 240   // For any instruction other than PHI, copies go just before the instr.
 241   // For a PHI, operand copies must be before the terminator of the
 242   // appropriate predecessor basic block.  Remaining logic is simple
 243   // so just handle PHIs and other instructions separately.
 244   //
 245   if (PHINode* phi = dyn_cast<PHINode>(&I))
 246     {
 247       for (unsigned i=0, N=phi->getNumIncomingValues(); i < N; ++i)
 248         if (Constant* CV = dyn_cast<Constant>(phi->getIncomingValue(i)))
 249           this->visitOneOperand(I, CV, phi->getOperandNumForIncomingValue(i),
 250                                 * phi->getIncomingBlock(i)->getTerminator());
 251     }
 252   else
 253     for (unsigned i=0, N=I.getNumOperands(); i < N; ++i)
 254       if (Constant* CV = dyn_cast<Constant>(I.getOperand(i)))
 255         this->visitOneOperand(I, CV, i, I);
 256 }
 257
 258 void
 259 PreSelection::visitOneOperand(Instruction &I, Constant* CV, unsigned opNum,
 260                               Instruction& insertBefore)
 261 {
 262   if (target.getInstrInfo().ConstantTypeMustBeLoaded(CV))
 263     { // load address of constant into a register, then load the constant
 264       GetElementPtrInst* gep = getGlobalAddr(getGlobalForConstant(CV),
 265                                              &insertBefore);
 266       LoadInst* ldI = new LoadInst(gep, "loadConst", &insertBefore);
 267       I.setOperand(opNum, ldI);        // replace operand with copy in v.reg.
 268     }
 269   else if (target.getInstrInfo().ConstantMayNotFitInImmedField(CV, &I))
 270     { // put the constant into a virtual register using a cast
 271       CastInst* castI = new CastInst(CV, CV->getType(), "copyConst",
 272                                      &insertBefore);
 273       I.setOperand(opNum, castI);      // replace operand with copy in v.reg.
 274     }
 275 }
 276
 277 //===----------------------------------------------------------------------===//
 278 // createPreSelectionPass - Public entrypoint for pre-selection pass
 279 // and this file as a whole...
 280 //
 281 Pass*
 282 createPreSelectionPass(TargetMachine &T)
 283 {
 284   return new PreSelection(T);
 285 }
 286