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 visitCastInst(CastInst &I);
 150     void visitStoreInst(StoreInst &I);
 151
 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
 156   };
 157 }  // end anonymous namespace
 158
 159
 160 // Register the pass...
 161 static RegisterOpt<PreSelection> X("preselect",
 162                                    "Specialize LLVM code for a target machine",
 163                                    createPreSelectionPass);
 164
 165 // PreSelection::getGlobalAddr: Put address of a global into a v. register.
 166 GetElementPtrInst*
 167 PreSelection::getGlobalAddr(Value* ptr, Instruction* insertBefore)
 168 {
 169   return (isa<GlobalValue>(ptr))
 170     ? new GetElementPtrInst(ptr,
 171                     std::vector<Value*>(1, ConstantSInt::get(Type::LongTy, 0U)),
 172                     "addrOfGlobal", insertBefore)
 173     : NULL;
 174 }
 175
 176
 177 //------------------------------------------------------------------------------
 178 // Instruction visitor methods to perform instruction-specific operations
 179 //------------------------------------------------------------------------------
 180
 181 // Common work for *all* instructions.  This needs to be called explicitly
 182 // by other visit<InstructionType> functions.
 183 inline void
 184 PreSelection::visitInstruction(Instruction &I)
 185 {
 186   visitOperands(I);              // Perform operand transformations
 187 }
 188
 189
 190 // GetElementPtr instructions: check if pointer is a global
 191 void
 192 PreSelection::visitGetElementPtrInst(GetElementPtrInst &I)
 193 {
 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
 197
 198   // Decompose multidimensional array references
 199   DecomposeArrayRef(&I);
 200
 201   // Perform other transformations common to all instructions
 202   visitInstruction(I);
 203 }
 204
 205
 206 // Load instructions: check if pointer is a global
 207 void
 208 PreSelection::visitLoadInst(LoadInst &I)
 209 {
 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
 213
 214   // Perform other transformations common to all instructions
 215   visitInstruction(I);
 216 }
 217
 218
 219 // Store instructions: check if pointer is a global
 220 void
 221 PreSelection::visitStoreInst(StoreInst &I)
 222 {
 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
 226
 227   // Perform other transformations common to all instructions
 228   visitInstruction(I);
 229 }
 230
 231
 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.
 238 //
 239 void
 240 PreSelection::visitCastInst(CastInst &I)
 241 {
 242   CastInst* castI = NULL;
 243
 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
 250     }
 251
 252   // Perform other transformations common to all instructions
 253   visitInstruction(I);
 254   if (castI)
 255     visitInstruction(*castI);
 256 }
 257
 258
 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.
 264 //
 265 void
 266 PreSelection::visitOperands(Instruction &I)
 267 {
 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.
 272   //
 273   if (PHINode* phi = dyn_cast<PHINode>(&I))
 274     {
 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());
 279     }
 280   else
 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);
 284 }
 285
 286 void
 287 PreSelection::visitOneOperand(Instruction &I, Constant* CV, unsigned opNum,
 288                               Instruction& insertBefore)
 289 {
 290   if (target.getInstrInfo().ConstantTypeMustBeLoaded(CV))
 291     { // load address of constant into a register, then load the constant
 292       GetElementPtrInst* gep = getGlobalAddr(getGlobalForConstant(CV),
 293                                              &insertBefore);
 294       LoadInst* ldI = new LoadInst(gep, "loadConst", &insertBefore);
 295       I.setOperand(opNum, ldI);        // replace operand with copy in v.reg.
 296     }
 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",
 300                                      &insertBefore);
 301       I.setOperand(opNum, castI);      // replace operand with copy in v.reg.
 302     }
 303 }
 304
 305 //===----------------------------------------------------------------------===//
 306 // createPreSelectionPass - Public entrypoint for pre-selection pass
 307 // and this file as a whole...
 308 //
 309 Pass*
 310 createPreSelectionPass(TargetMachine &T)
 311 {
 312   return new PreSelection(T);
 313 }
 314