src/IceTargetLowering.cpp

   1 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
   2 //
   3 //                        The Subzero Code Generator
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the skeleton of the TargetLowering class,
  11 // specifically invoking the appropriate lowering method for a given
  12 // instruction kind and driving global register allocation.  It also
  13 // implements the non-deleted instruction iteration in
  14 // LoweringContext.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "assembler_arm32.h"
  19 #include "assembler_ia32.h"
  20 #include "IceCfg.h" // setError()
  21 #include "IceCfgNode.h"
  22 #include "IceOperand.h"
  23 #include "IceRegAlloc.h"
  24 #include "IceTargetLowering.h"
  25 #include "IceTargetLoweringARM32.h"
  26 #include "IceTargetLoweringX8632.h"
  27
  28 namespace Ice {
  29
  30 void LoweringContext::init(CfgNode *N) {
  31   Node = N;
  32   End = getNode()->getInsts().end();
  33   rewind();
  34   advanceForward(Next);
  35 }
  36
  37 void LoweringContext::rewind() {
  38   Begin = getNode()->getInsts().begin();
  39   Cur = Begin;
  40   skipDeleted(Cur);
  41   Next = Cur;
  42 }
  43
  44 void LoweringContext::insert(Inst *Inst) {
  45   getNode()->getInsts().insert(Next, Inst);
  46   LastInserted = Inst;
  47 }
  48
  49 void LoweringContext::skipDeleted(InstList::iterator &I) const {
  50   while (I != End && I->isDeleted())
  51     ++I;
  52 }
  53
  54 void LoweringContext::advanceForward(InstList::iterator &I) const {
  55   if (I != End) {
  56     ++I;
  57     skipDeleted(I);
  58   }
  59 }
  60
  61 Inst *LoweringContext::getLastInserted() const {
  62   assert(LastInserted);
  63   return LastInserted;
  64 }
  65
  66 TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
  67 #define SUBZERO_TARGET(X)                                                      \
  68   if (Target == Target_##X)                                                    \
  69     return Target##X::create(Func);
  70 #include "llvm/Config/SZTargets.def"
  71
  72   Func->setError("Unsupported target");
  73   return nullptr;
  74 }
  75
  76 TargetLowering::TargetLowering(Cfg *Func)
  77     : Func(Func), Ctx(Func->getContext()), HasComputedFrame(false),
  78       CallsReturnsTwice(false), StackAdjustment(0), NextLabelNumber(0),
  79       Context(), SnapshotStackAdjustment(0) {}
  80
  81 std::unique_ptr<Assembler> TargetLowering::createAssembler(TargetArch Target,
  82                                                            Cfg *Func) {
  83 #define SUBZERO_TARGET(X)                                                      \
  84   if (Target == Target_##X)                                                    \
  85     return std::unique_ptr<Assembler>(new X::Assembler##X());
  86 #include "llvm/Config/SZTargets.def"
  87
  88   Func->setError("Unsupported target assembler");
  89   return nullptr;
  90 }
  91
  92 void TargetLowering::doAddressOpt() {
  93   if (llvm::isa<InstLoad>(*Context.getCur()))
  94     doAddressOptLoad();
  95   else if (llvm::isa<InstStore>(*Context.getCur()))
  96     doAddressOptStore();
  97   Context.advanceCur();
  98   Context.advanceNext();
  99 }
 100
 101 void TargetLowering::doNopInsertion() {
 102   Inst *I = Context.getCur();
 103   bool ShouldSkip = llvm::isa<InstFakeUse>(I) || llvm::isa<InstFakeDef>(I) ||
 104                     llvm::isa<InstFakeKill>(I) || I->isRedundantAssign() ||
 105                     I->isDeleted();
 106   if (!ShouldSkip) {
 107     int Probability = Ctx->getFlags().getNopProbabilityAsPercentage();
 108     for (int I = 0; I < Ctx->getFlags().getMaxNopsPerInstruction(); ++I) {
 109       randomlyInsertNop(Probability / 100.0);
 110     }
 111   }
 112 }
 113
 114 // Lowers a single instruction according to the information in
 115 // Context, by checking the Context.Cur instruction kind and calling
 116 // the appropriate lowering method.  The lowering method should insert
 117 // target instructions at the Cur.Next insertion point, and should not
 118 // delete the Context.Cur instruction or advance Context.Cur.
 119 //
 120 // The lowering method may look ahead in the instruction stream as
 121 // desired, and lower additional instructions in conjunction with the
 122 // current one, for example fusing a compare and branch.  If it does,
 123 // it should advance Context.Cur to point to the next non-deleted
 124 // instruction to process, and it should delete any additional
 125 // instructions it consumes.
 126 void TargetLowering::lower() {
 127   assert(!Context.atEnd());
 128   Inst *Inst = Context.getCur();
 129   Inst->deleteIfDead();
 130   if (!Inst->isDeleted()) {
 131     // Mark the current instruction as deleted before lowering,
 132     // otherwise the Dest variable will likely get marked as non-SSA.
 133     // See Variable::setDefinition().
 134     Inst->setDeleted();
 135     switch (Inst->getKind()) {
 136     case Inst::Alloca:
 137       lowerAlloca(llvm::cast<InstAlloca>(Inst));
 138       break;
 139     case Inst::Arithmetic:
 140       lowerArithmetic(llvm::cast<InstArithmetic>(Inst));
 141       break;
 142     case Inst::Assign:
 143       lowerAssign(llvm::cast<InstAssign>(Inst));
 144       break;
 145     case Inst::Br:
 146       lowerBr(llvm::cast<InstBr>(Inst));
 147       break;
 148     case Inst::Call:
 149       lowerCall(llvm::cast<InstCall>(Inst));
 150       break;
 151     case Inst::Cast:
 152       lowerCast(llvm::cast<InstCast>(Inst));
 153       break;
 154     case Inst::ExtractElement:
 155       lowerExtractElement(llvm::cast<InstExtractElement>(Inst));
 156       break;
 157     case Inst::Fcmp:
 158       lowerFcmp(llvm::cast<InstFcmp>(Inst));
 159       break;
 160     case Inst::Icmp:
 161       lowerIcmp(llvm::cast<InstIcmp>(Inst));
 162       break;
 163     case Inst::InsertElement:
 164       lowerInsertElement(llvm::cast<InstInsertElement>(Inst));
 165       break;
 166     case Inst::IntrinsicCall: {
 167       InstIntrinsicCall *Call = llvm::cast<InstIntrinsicCall>(Inst);
 168       if (Call->getIntrinsicInfo().ReturnsTwice)
 169         setCallsReturnsTwice(true);
 170       lowerIntrinsicCall(Call);
 171       break;
 172     }
 173     case Inst::Load:
 174       lowerLoad(llvm::cast<InstLoad>(Inst));
 175       break;
 176     case Inst::Phi:
 177       lowerPhi(llvm::cast<InstPhi>(Inst));
 178       break;
 179     case Inst::Ret:
 180       lowerRet(llvm::cast<InstRet>(Inst));
 181       break;
 182     case Inst::Select:
 183       lowerSelect(llvm::cast<InstSelect>(Inst));
 184       break;
 185     case Inst::Store:
 186       lowerStore(llvm::cast<InstStore>(Inst));
 187       break;
 188     case Inst::Switch:
 189       lowerSwitch(llvm::cast<InstSwitch>(Inst));
 190       break;
 191     case Inst::Unreachable:
 192       lowerUnreachable(llvm::cast<InstUnreachable>(Inst));
 193       break;
 194     case Inst::BundleLock:
 195     case Inst::BundleUnlock:
 196     case Inst::FakeDef:
 197     case Inst::FakeUse:
 198     case Inst::FakeKill:
 199     case Inst::Target:
 200       // These are all Target instruction types and shouldn't be
 201       // encountered at this stage.
 202       Func->setError("Can't lower unsupported instruction type");
 203       break;
 204     }
 205
 206     postLower();
 207   }
 208
 209   Context.advanceCur();
 210   Context.advanceNext();
 211 }
 212
 213 // Drives register allocation, allowing all physical registers (except
 214 // perhaps for the frame pointer) to be allocated.  This set of
 215 // registers could potentially be parameterized if we want to restrict
 216 // registers e.g. for performance testing.
 217 void TargetLowering::regAlloc(RegAllocKind Kind) {
 218   TimerMarker T(TimerStack::TT_regAlloc, Func);
 219   LinearScan LinearScan(Func);
 220   RegSetMask RegInclude = RegSet_None;
 221   RegSetMask RegExclude = RegSet_None;
 222   RegInclude |= RegSet_CallerSave;
 223   RegInclude |= RegSet_CalleeSave;
 224   if (hasFramePointer())
 225     RegExclude |= RegSet_FramePointer;
 226   LinearScan.init(Kind);
 227   llvm::SmallBitVector RegMask = getRegisterSet(RegInclude, RegExclude);
 228   LinearScan.scan(RegMask, Ctx->getFlags().shouldRandomizeRegAlloc());
 229 }
 230
 231 InstCall *TargetLowering::makeHelperCall(const IceString &Name, Variable *Dest,
 232                                          SizeT MaxSrcs) {
 233   const bool HasTailCall = false;
 234   Constant *CallTarget = Ctx->getConstantExternSym(Name);
 235   InstCall *Call =
 236       InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
 237   return Call;
 238 }
 239
 240 void TargetLowering::emitWithoutPrefix(const ConstantRelocatable *C) const {
 241   if (!ALLOW_DUMP)
 242     return;
 243   Ostream &Str = Ctx->getStrEmit();
 244   if (C->getSuppressMangling())
 245     Str << C->getName();
 246   else
 247     Str << Ctx->mangleName(C->getName());
 248   RelocOffsetT Offset = C->getOffset();
 249   if (Offset) {
 250     if (Offset > 0)
 251       Str << "+";
 252     Str << Offset;
 253   }
 254 }
 255
 256 void TargetLowering::emit(const ConstantRelocatable *C) const {
 257   if (!ALLOW_DUMP)
 258     return;
 259   Ostream &Str = Ctx->getStrEmit();
 260   Str << getConstantPrefix();
 261   emitWithoutPrefix(C);
 262 }
 263
 264 std::unique_ptr<TargetDataLowering>
 265 TargetDataLowering::createLowering(GlobalContext *Ctx) {
 266   TargetArch Target = Ctx->getFlags().getTargetArch();
 267 #define SUBZERO_TARGET(X)                                                      \
 268   if (Target == Target_##X)                                                    \
 269     return std::unique_ptr<TargetDataLowering>(TargetData##X::create(Ctx));
 270 #include "llvm/Config/SZTargets.def"
 271
 272   llvm_unreachable("Unsupported target data lowering");
 273   return nullptr;
 274 }
 275
 276 TargetDataLowering::~TargetDataLowering() {}
 277
 278 } // end of namespace Ice