lib/Target/PowerPC/PPCISelPattern.cpp

   1 //===-- PPC32ISelPattern.cpp - A pattern matching inst selector for PPC32 -===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Nate Begeman and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a pattern matching instruction selector for 32 bit PowerPC.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PowerPC.h"
  15 #include "PowerPCInstrBuilder.h"
  16 #include "PowerPCInstrInfo.h"
  17 #include "PPC32RegisterInfo.h"
  18 #include "llvm/Constants.h"                   // FIXME: REMOVE
  19 #include "llvm/Function.h"
  20 #include "llvm/CodeGen/MachineConstantPool.h" // FIXME: REMOVE
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/SelectionDAG.h"
  24 #include "llvm/CodeGen/SelectionDAGISel.h"
  25 #include "llvm/CodeGen/SSARegMap.h"
  26 #include "llvm/Target/TargetData.h"
  27 #include "llvm/Target/TargetLowering.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/MathExtras.h"
  30 #include "llvm/ADT/Statistic.h"
  31 #include <set>
  32 #include <algorithm>
  33 using namespace llvm;
  34
  35 //===----------------------------------------------------------------------===//
  36 //  PPC32TargetLowering - PPC32 Implementation of the TargetLowering interface
  37 namespace {
  38   class PPC32TargetLowering : public TargetLowering {
  39     int VarArgsFrameIndex;            // FrameIndex for start of varargs area.
  40     int ReturnAddrIndex;              // FrameIndex for return slot.
  41   public:
  42     PPC32TargetLowering(TargetMachine &TM) : TargetLowering(TM) {
  43       // Set up the TargetLowering object.
  44
  45       // Set up the register classes.
  46       addRegisterClass(MVT::i32, PPC32::GPRCRegisterClass);
  47       addRegisterClass(MVT::f32, PPC32::FPRCRegisterClass);
  48       addRegisterClass(MVT::f64, PPC32::FPRCRegisterClass);
  49
  50       computeRegisterProperties();
  51     }
  52
  53     /// LowerArguments - This hook must be implemented to indicate how we should
  54     /// lower the arguments for the specified function, into the specified DAG.
  55     virtual std::vector<SDOperand>
  56     LowerArguments(Function &F, SelectionDAG &DAG);
  57
  58     /// LowerCallTo - This hook lowers an abstract call to a function into an
  59     /// actual call.
  60     virtual std::pair<SDOperand, SDOperand>
  61     LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg,
  62                 SDOperand Callee, ArgListTy &Args, SelectionDAG &DAG);
  63
  64     virtual std::pair<SDOperand, SDOperand>
  65     LowerVAStart(SDOperand Chain, SelectionDAG &DAG);
  66
  67     virtual std::pair<SDOperand,SDOperand>
  68     LowerVAArgNext(bool isVANext, SDOperand Chain, SDOperand VAList,
  69                    const Type *ArgTy, SelectionDAG &DAG);
  70
  71     virtual std::pair<SDOperand, SDOperand>
  72     LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth,
  73                             SelectionDAG &DAG);
  74   };
  75 }
  76
  77
  78 std::vector<SDOperand>
  79 PPC32TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
  80   //
  81   // add beautiful description of PPC stack frame format, or at least some docs
  82   //
  83   MachineFunction &MF = DAG.getMachineFunction();
  84   MachineFrameInfo *MFI = MF.getFrameInfo();
  85   MachineBasicBlock& BB = MF.front();
  86   std::vector<SDOperand> ArgValues;
  87
  88   // Due to the rather complicated nature of the PowerPC ABI, rather than a
  89   // fixed size array of physical args, for the sake of simplicity let the STL
  90   // handle tracking them for us.
  91   std::vector<unsigned> argVR, argPR, argOp;
  92   unsigned ArgOffset = 24;
  93   unsigned GPR_remaining = 8;
  94   unsigned FPR_remaining = 13;
  95   unsigned GPR_idx = 0, FPR_idx = 0;
  96   static const unsigned GPR[] = {
  97     PPC::R3, PPC::R4, PPC::R5, PPC::R6,
  98     PPC::R7, PPC::R8, PPC::R9, PPC::R10,
  99   };
 100   static const unsigned FPR[] = {
 101     PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7,
 102     PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12, PPC::F13
 103   };
 104
 105   // Add DAG nodes to load the arguments...  On entry to a function on PPC,
 106   // the arguments start at offset 24, although they are likely to be passed
 107   // in registers.
 108   for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
 109     SDOperand newroot, argt;
 110     unsigned ObjSize;
 111     bool needsLoad = false;
 112     MVT::ValueType ObjectVT = getValueType(I->getType());
 113
 114     switch (ObjectVT) {
 115     default: assert(0 && "Unhandled argument type!");
 116     case MVT::i1:
 117     case MVT::i8:
 118     case MVT::i16:
 119     case MVT::i32:
 120       ObjSize = 4;
 121       if (GPR_remaining > 0) {
 122         BuildMI(&BB, PPC::IMPLICIT_DEF, 0, GPR[GPR_idx]);
 123         unsigned virtReg =
 124           MF.getSSARegMap()->createVirtualRegister(getRegClassFor(MVT::i32));
 125         argt = newroot = DAG.getCopyFromReg(virtReg, MVT::i32, DAG.getRoot());
 126         if (ObjectVT != MVT::i32)
 127           argt = DAG.getNode(ISD::TRUNCATE, ObjectVT, newroot);
 128         argVR.push_back(virtReg);
 129         argPR.push_back(GPR[GPR_idx]);
 130         argOp.push_back(PPC::OR);
 131       } else {
 132         needsLoad = true;
 133       }
 134       break;
 135       case MVT::i64: ObjSize = 8;
 136       // FIXME: can split 64b load between reg/mem if it is last arg in regs
 137       if (GPR_remaining > 1) {
 138         BuildMI(&BB, PPC::IMPLICIT_DEF, 0, GPR[GPR_idx]);
 139         BuildMI(&BB, PPC::IMPLICIT_DEF, 0, GPR[GPR_idx+1]);
 140         MF.getSSARegMap()->createVirtualRegister(getRegClassFor(MVT::i32));
 141         unsigned virtReg =
 142           MF.getSSARegMap()->createVirtualRegister(getRegClassFor(MVT::i32))-1;
 143         // FIXME: is this correct?
 144         argt = newroot = DAG.getCopyFromReg(virtReg, MVT::i32, DAG.getRoot());
 145         argt = DAG.getCopyFromReg(virtReg+1, MVT::i32, newroot);
 146         // Push the arguments for emitting into BB later
 147         argVR.push_back(virtReg);       argVR.push_back(virtReg+1);
 148         argPR.push_back(GPR[GPR_idx]);  argPR.push_back(GPR[GPR_idx+1]);
 149         argOp.push_back(PPC::OR);       argOp.push_back(PPC::OR);
 150       } else {
 151         needsLoad = true;
 152       }
 153       break;
 154       case MVT::f32: ObjSize = 4;
 155       case MVT::f64: ObjSize = 8;
 156       if (FPR_remaining > 0) {
 157         BuildMI(&BB, PPC::IMPLICIT_DEF, 0, FPR[FPR_idx]);
 158         unsigned virtReg =
 159           MF.getSSARegMap()->createVirtualRegister(getRegClassFor(ObjectVT));
 160         argt = newroot = DAG.getCopyFromReg(virtReg, ObjectVT, DAG.getRoot());
 161         argVR.push_back(virtReg);
 162         argPR.push_back(FPR[FPR_idx]);
 163         argOp.push_back(PPC::FMR);
 164         --FPR_remaining;
 165         ++FPR_idx;
 166       } else {
 167         needsLoad = true;
 168       }
 169       break;
 170     }
 171
 172     // We need to load the argument to a virtual register if we determined above
 173     // that we ran out of physical registers of the appropriate type
 174     if (needsLoad) {
 175       int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
 176       SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 177       argt = newroot = DAG.getLoad(ObjectVT, DAG.getEntryNode(), FIN);
 178     }
 179
 180     // Every 4 bytes of argument space consumes one of the GPRs available for
 181     // argument passing.
 182     if (GPR_remaining > 0) {
 183       unsigned delta = (GPR_remaining > 1 && ObjSize == 8) ? 2 : 1;
 184       GPR_remaining -= delta;
 185       GPR_idx += delta;
 186     }
 187     ArgOffset += ObjSize;
 188
 189     DAG.setRoot(newroot.getValue(1));
 190     ArgValues.push_back(argt);
 191   }
 192
 193   for (int i = 0, count = argVR.size(); i < count; ++i) {
 194     if (argOp[i] == PPC::FMR)
 195       BuildMI(&BB, argOp[i], 1, argVR[i]).addReg(argPR[i]);
 196     else
 197       BuildMI(&BB, argOp[i], 2, argVR[i]).addReg(argPR[i]).addReg(argPR[i]);
 198   }
 199
 200   // If the function takes variable number of arguments, make a frame index for
 201   // the start of the first vararg value... for expansion of llvm.va_start.
 202   if (F.isVarArg())
 203     VarArgsFrameIndex = MFI->CreateFixedObject(4, ArgOffset);
 204
 205   return ArgValues;
 206 }
 207
 208 std::pair<SDOperand, SDOperand>
 209 PPC32TargetLowering::LowerCallTo(SDOperand Chain,
 210                                  const Type *RetTy, bool isVarArg,
 211          SDOperand Callee, ArgListTy &Args, SelectionDAG &DAG) {
 212   // args_to_use will accumulate outgoing args for the ISD::CALL case in
 213   // SelectExpr to use to put the arguments in the appropriate registers.
 214   std::vector<SDOperand> args_to_use;
 215
 216   // Count how many bytes are to be pushed on the stack, including the linkage
 217   // area, and parameter passing area.
 218   unsigned NumBytes = 24;
 219
 220   if (Args.empty()) {
 221     NumBytes = 0;    // Save zero bytes.
 222   } else {
 223     for (unsigned i = 0, e = Args.size(); i != e; ++i)
 224       switch (getValueType(Args[i].second)) {
 225       default: assert(0 && "Unknown value type!");
 226       case MVT::i1:
 227       case MVT::i8:
 228       case MVT::i16:
 229       case MVT::i32:
 230       case MVT::f32:
 231         NumBytes += 4;
 232         break;
 233       case MVT::i64:
 234       case MVT::f64:
 235         NumBytes += 8;
 236         break;
 237       }
 238
 239     // Just to be safe, we'll always reserve the full 24 bytes of linkage area
 240     // plus 32 bytes of argument space in case any called code gets funky on us.
 241     if (NumBytes < 56) NumBytes = 56;
 242
 243     // Adjust the stack pointer for the new arguments...
 244     // These operations are automatically eliminated by the prolog/epilog pass
 245     Chain = DAG.getNode(ISD::ADJCALLSTACKDOWN, MVT::Other, Chain,
 246                         DAG.getConstant(NumBytes, getPointerTy()));
 247
 248     // Set up a copy of the stack pointer for use loading and storing any
 249     // arguments that may not fit in the registers available for argument
 250     // passing.
 251     SDOperand StackPtr = DAG.getCopyFromReg(PPC::R1, MVT::i32,
 252                                             DAG.getEntryNode());
 253
 254     // Figure out which arguments are going to go in registers, and which in
 255     // memory.  Also, if this is a vararg function, floating point operations
 256     // must be stored to our stack, and loaded into integer regs as well, if
 257     // any integer regs are available for argument passing.
 258     unsigned ArgOffset = 24;
 259     unsigned GPR_remaining = 8;
 260     unsigned FPR_remaining = 13;
 261     std::vector<SDOperand> Stores;
 262     for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 263       // PtrOff will be used to store the current argument to the stack if a
 264       // register cannot be found for it.
 265       SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 266       PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 267       MVT::ValueType ArgVT = getValueType(Args[i].second);
 268
 269       switch (ArgVT) {
 270       default: assert(0 && "Unexpected ValueType for argument!");
 271       case MVT::i1:
 272       case MVT::i8:
 273       case MVT::i16:
 274         // Promote the integer to 32 bits.  If the input type is signed use a
 275         // sign extend, otherwise use a zero extend.
 276         if (Args[i].second->isSigned())
 277           Args[i].first =DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Args[i].first);
 278         else
 279           Args[i].first =DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Args[i].first);
 280         // FALL THROUGH
 281       case MVT::i32:
 282         if (GPR_remaining > 0) {
 283           args_to_use.push_back(Args[i].first);
 284           --GPR_remaining;
 285         } else {
 286           Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 287                                        Args[i].first, PtrOff));
 288         }
 289         ArgOffset += 4;
 290         break;
 291       case MVT::i64:
 292         // If we have one free GPR left, we can place the upper half of the i64
 293         // in it, and store the other half to the stack.  If we have two or more
 294         // free GPRs, then we can pass both halves of the i64 in registers.
 295         if (GPR_remaining > 0) {
 296           SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 297             Args[i].first, DAG.getConstant(1, MVT::i32));
 298           SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 299             Args[i].first, DAG.getConstant(0, MVT::i32));
 300           args_to_use.push_back(Hi);
 301           if (GPR_remaining > 1) {
 302             args_to_use.push_back(Lo);
 303             GPR_remaining -= 2;
 304           } else {
 305             SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
 306             PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
 307             Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 308                                          Lo, PtrOff));
 309             --GPR_remaining;
 310           }
 311         } else {
 312           Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 313                                        Args[i].first, PtrOff));
 314         }
 315         ArgOffset += 8;
 316         break;
 317       case MVT::f32:
 318       case MVT::f64:
 319         if (FPR_remaining > 0) {
 320           if (isVarArg) {
 321             // FIXME: Need FunctionType information so we can conditionally
 322             // store only the non-fixed arguments in a vararg function.
 323             Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 324                                          Args[i].first, PtrOff));
 325             // FIXME: Need a way to communicate to the ISD::CALL select code
 326             // that a particular argument is non-fixed so that we can load them
 327             // into the correct GPR to shadow the FPR
 328           }
 329           args_to_use.push_back(Args[i].first);
 330           --FPR_remaining;
 331           // If we have any FPRs remaining, we may also have GPRs remaining.
 332           // Args passed in FPRs consume either 1 (f32) or 2 (f64) available
 333           // GPRs.
 334           if (GPR_remaining > 0) --GPR_remaining;
 335           if (GPR_remaining > 0 && MVT::f64 == ArgVT) --GPR_remaining;
 336         } else {
 337           Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 338                                        Args[i].first, PtrOff));
 339         }
 340         ArgOffset += (ArgVT == MVT::f32) ? 4 : 8;
 341         break;
 342       }
 343     }
 344     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, Stores);
 345   }
 346
 347   std::vector<MVT::ValueType> RetVals;
 348   MVT::ValueType RetTyVT = getValueType(RetTy);
 349   if (RetTyVT != MVT::isVoid)
 350     RetVals.push_back(RetTyVT);
 351   RetVals.push_back(MVT::Other);
 352
 353   SDOperand TheCall = SDOperand(DAG.getCall(RetVals,
 354                                             Chain, Callee, args_to_use), 0);
 355   Chain = TheCall.getValue(RetTyVT != MVT::isVoid);
 356   Chain = DAG.getNode(ISD::ADJCALLSTACKUP, MVT::Other, Chain,
 357                       DAG.getConstant(NumBytes, getPointerTy()));
 358   return std::make_pair(TheCall, Chain);
 359 }
 360
 361 std::pair<SDOperand, SDOperand>
 362 PPC32TargetLowering::LowerVAStart(SDOperand Chain, SelectionDAG &DAG) {
 363   //vastart just returns the address of the VarArgsFrameIndex slot.
 364   return std::make_pair(DAG.getFrameIndex(VarArgsFrameIndex, MVT::i32), Chain);
 365 }
 366
 367 std::pair<SDOperand,SDOperand> PPC32TargetLowering::
 368 LowerVAArgNext(bool isVANext, SDOperand Chain, SDOperand VAList,
 369                const Type *ArgTy, SelectionDAG &DAG) {
 370   MVT::ValueType ArgVT = getValueType(ArgTy);
 371   SDOperand Result;
 372   if (!isVANext) {
 373     Result = DAG.getLoad(ArgVT, DAG.getEntryNode(), VAList);
 374   } else {
 375     unsigned Amt;
 376     if (ArgVT == MVT::i32 || ArgVT == MVT::f32)
 377       Amt = 4;
 378     else {
 379       assert((ArgVT == MVT::i64 || ArgVT == MVT::f64) &&
 380              "Other types should have been promoted for varargs!");
 381       Amt = 8;
 382     }
 383     Result = DAG.getNode(ISD::ADD, VAList.getValueType(), VAList,
 384                          DAG.getConstant(Amt, VAList.getValueType()));
 385   }
 386   return std::make_pair(Result, Chain);
 387 }
 388
 389
 390 std::pair<SDOperand, SDOperand> PPC32TargetLowering::
 391 LowerFrameReturnAddress(bool isFrameAddress, SDOperand Chain, unsigned Depth,
 392                         SelectionDAG &DAG) {
 393   abort();
 394 }
 395
 396 namespace {
 397
 398 //===--------------------------------------------------------------------===//
 399 /// ISel - PPC32 specific code to select PPC32 machine instructions for
 400 /// SelectionDAG operations.
 401 //===--------------------------------------------------------------------===//
 402 class ISel : public SelectionDAGISel {
 403
 404   /// Comment Here.
 405   PPC32TargetLowering PPC32Lowering;
 406
 407   /// ExprMap - As shared expressions are codegen'd, we keep track of which
 408   /// vreg the value is produced in, so we only emit one copy of each compiled
 409   /// tree.
 410   std::map<SDOperand, unsigned> ExprMap;
 411
 412   unsigned GlobalBaseReg;
 413   bool GlobalBaseInitialized;
 414
 415 public:
 416   ISel(TargetMachine &TM) : SelectionDAGISel(PPC32Lowering), PPC32Lowering(TM)
 417   {}
 418
 419   /// runOnFunction - Override this function in order to reset our per-function
 420   /// variables.
 421   virtual bool runOnFunction(Function &Fn) {
 422     // Make sure we re-emit a set of the global base reg if necessary
 423     GlobalBaseInitialized = false;
 424     return SelectionDAGISel::runOnFunction(Fn);
 425   }
 426
 427   /// InstructionSelectBasicBlock - This callback is invoked by
 428   /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
 429   virtual void InstructionSelectBasicBlock(SelectionDAG &DAG) {
 430     DEBUG(BB->dump());
 431     // Codegen the basic block.
 432     Select(DAG.getRoot());
 433
 434     // Clear state used for selection.
 435     ExprMap.clear();
 436   }
 437
 438   unsigned ISel::getGlobalBaseReg();
 439   unsigned SelectExpr(SDOperand N);
 440   unsigned SelectExprFP(SDOperand N, unsigned Result);
 441   void Select(SDOperand N);
 442
 443   void SelectAddr(SDOperand N, unsigned& Reg, int& offset);
 444   void SelectBranchCC(SDOperand N);
 445 };
 446
 447 /// canUseAsImmediateForOpcode - This method returns a value indicating whether
 448 /// the ConstantSDNode N can be used as an immediate to Opcode.  The return
 449 /// values are either 0, 1 or 2.  0 indicates that either N is not a
 450 /// ConstantSDNode, or is not suitable for use by that opcode.  A return value
 451 /// of 1 indicates that the constant may be used in normal immediate form.  A
 452 /// return value of 2 indicates that the constant may be used in shifted
 453 /// immediate form.  If the return value is nonzero, the constant value is
 454 /// placed in Imm.
 455 ///
 456 static unsigned canUseAsImmediateForOpcode(SDOperand N, unsigned Opcode,
 457                                            unsigned& Imm) {
 458   if (N.getOpcode() != ISD::Constant) return 0;
 459
 460   int v = (int)cast<ConstantSDNode>(N)->getSignExtended();
 461
 462   switch(Opcode) {
 463   default: return 0;
 464   case ISD::ADD:
 465     if (v <= 32767 && v >= -32768) { Imm = v & 0xFFFF; return 1; }
 466     if ((v & 0x0000FFFF) == 0) { Imm = v >> 16; return 2; }
 467     break;
 468   case ISD::AND:
 469   case ISD::XOR:
 470   case ISD::OR:
 471     if (v >= 0 && v <= 65535) { Imm = v & 0xFFFF; return 1; }
 472     if ((v & 0x0000FFFF) == 0) { Imm = v >> 16; return 2; }
 473     break;
 474   case ISD::MUL:
 475     if (v <= 32767 && v >= -32768) { Imm = v & 0xFFFF; return 1; }
 476     break;
 477   }
 478   return 0;
 479 }
 480 }
 481
 482 /// getGlobalBaseReg - Output the instructions required to put the
 483 /// base address to use for accessing globals into a register.
 484 ///
 485 unsigned ISel::getGlobalBaseReg() {
 486   if (!GlobalBaseInitialized) {
 487     // Insert the set of GlobalBaseReg into the first MBB of the function
 488     MachineBasicBlock &FirstMBB = BB->getParent()->front();
 489     MachineBasicBlock::iterator MBBI = FirstMBB.begin();
 490     GlobalBaseReg = MakeReg(MVT::i32);
 491     BuildMI(FirstMBB, MBBI, PPC::MovePCtoLR, 0, PPC::LR);
 492     BuildMI(FirstMBB, MBBI, PPC::MFLR, 1, GlobalBaseReg).addReg(PPC::LR);
 493     GlobalBaseInitialized = true;
 494   }
 495   return GlobalBaseReg;
 496 }
 497
 498 //Check to see if the load is a constant offset from a base register
 499 void ISel::SelectAddr(SDOperand N, unsigned& Reg, int& offset)
 500 {
 501   Reg = SelectExpr(N);
 502   offset = 0;
 503   return;
 504 }
 505
 506 void ISel::SelectBranchCC(SDOperand N)
 507 {
 508   assert(N.getOpcode() == ISD::BRCOND && "Not a BranchCC???");
 509   MachineBasicBlock *Dest =
 510     cast<BasicBlockSDNode>(N.getOperand(2))->getBasicBlock();
 511   unsigned Opc;
 512
 513   Select(N.getOperand(0));  //chain
 514   SDOperand CC = N.getOperand(1);
 515
 516   //Giveup and do the stupid thing
 517   unsigned Tmp1 = SelectExpr(CC);
 518   BuildMI(BB, PPC::BNE, 2).addReg(Tmp1).addMBB(Dest);
 519   return;
 520 }
 521
 522 unsigned ISel::SelectExprFP(SDOperand N, unsigned Result)
 523 {
 524   unsigned Tmp1, Tmp2, Tmp3;
 525   unsigned Opc = 0;
 526   SDNode *Node = N.Val;
 527   MVT::ValueType DestType = N.getValueType();
 528   unsigned opcode = N.getOpcode();
 529
 530   switch (opcode) {
 531   default:
 532     Node->dump();
 533     assert(0 && "Node not handled!\n");
 534
 535   case ISD::SELECT:
 536     abort();
 537
 538   case ISD::FP_ROUND:
 539     assert (DestType == MVT::f32 &&
 540             N.getOperand(0).getValueType() == MVT::f64 &&
 541             "only f64 to f32 conversion supported here");
 542     Tmp1 = SelectExpr(N.getOperand(0));
 543     BuildMI(BB, PPC::FRSP, 1, Result).addReg(Tmp1);
 544     return Result;
 545
 546   case ISD::FP_EXTEND:
 547     assert (DestType == MVT::f64 &&
 548             N.getOperand(0).getValueType() == MVT::f32 &&
 549             "only f32 to f64 conversion supported here");
 550     Tmp1 = SelectExpr(N.getOperand(0));
 551     BuildMI(BB, PPC::FMR, 1, Result).addReg(Tmp1);
 552     return Result;
 553
 554   case ISD::CopyFromReg:
 555     if (Result == 1)
 556       Result = ExprMap[N.getValue(0)] = MakeReg(N.getValue(0).getValueType());
 557     Tmp1 = dyn_cast<RegSDNode>(Node)->getReg();
 558     BuildMI(BB, PPC::FMR, 1, Result).addReg(Tmp1);
 559     return Result;
 560
 561   case ISD::LOAD:
 562   case ISD::EXTLOAD:
 563     abort();
 564
 565   case ISD::ConstantFP:
 566     abort();
 567
 568   case ISD::MUL:
 569   case ISD::ADD:
 570   case ISD::SUB:
 571   case ISD::SDIV:
 572     switch( opcode ) {
 573     case ISD::MUL:  Opc = DestType == MVT::f64 ? PPC::FMUL : PPC::FMULS; break;
 574     case ISD::ADD:  Opc = DestType == MVT::f64 ? PPC::FADD : PPC::FADDS; break;
 575     case ISD::SUB:  Opc = DestType == MVT::f64 ? PPC::FSUB : PPC::FSUBS; break;
 576     case ISD::SDIV: Opc = DestType == MVT::f64 ? PPC::FDIV : PPC::FDIVS; break;
 577     };
 578
 579     Tmp1 = SelectExpr(N.getOperand(0));
 580     Tmp2 = SelectExpr(N.getOperand(1));
 581     BuildMI(BB, Opc, 2, Result).addReg(Tmp1).addReg(Tmp2);
 582     return Result;
 583
 584   case ISD::UINT_TO_FP:
 585   case ISD::SINT_TO_FP:
 586     abort();
 587   }
 588   assert(0 && "should not get here");
 589   return 0;
 590 }
 591
 592 unsigned ISel::SelectExpr(SDOperand N) {
 593   unsigned Result;
 594   unsigned Tmp1, Tmp2, Tmp3;
 595   unsigned Opc = 0;
 596   unsigned opcode = N.getOpcode();
 597
 598   SDNode *Node = N.Val;
 599   MVT::ValueType DestType = N.getValueType();
 600
 601   unsigned &Reg = ExprMap[N];
 602   if (Reg) return Reg;
 603
 604   if (N.getOpcode() != ISD::CALL && N.getOpcode() != ISD::ADD_PARTS &&
 605       N.getOpcode() != ISD::SUB_PARTS)
 606     Reg = Result = (N.getValueType() != MVT::Other) ?
 607       MakeReg(N.getValueType()) : 1;
 608   else {
 609     // If this is a call instruction, make sure to prepare ALL of the result
 610     // values as well as the chain.
 611     if (N.getOpcode() == ISD::CALL) {
 612       if (Node->getNumValues() == 1)
 613         Reg = Result = 1;  // Void call, just a chain.
 614       else {
 615         Result = MakeReg(Node->getValueType(0));
 616         ExprMap[N.getValue(0)] = Result;
 617         for (unsigned i = 1, e = N.Val->getNumValues()-1; i != e; ++i)
 618           ExprMap[N.getValue(i)] = MakeReg(Node->getValueType(i));
 619         ExprMap[SDOperand(Node, Node->getNumValues()-1)] = 1;
 620       }
 621     } else {
 622       Result = MakeReg(Node->getValueType(0));
 623       ExprMap[N.getValue(0)] = Result;
 624       for (unsigned i = 1, e = N.Val->getNumValues(); i != e; ++i)
 625         ExprMap[N.getValue(i)] = MakeReg(Node->getValueType(i));
 626     }
 627   }
 628
 629   if (DestType == MVT::f64 || DestType == MVT::f32)
 630     return SelectExprFP(N, Result);
 631
 632   switch (opcode) {
 633   default:
 634     Node->dump();
 635     assert(0 && "Node not handled!\n");
 636
 637   case ISD::DYNAMIC_STACKALLOC:
 638     // Generate both result values.  FIXME: Need a better commment here?
 639     if (Result != 1)
 640       ExprMap[N.getValue(1)] = 1;
 641     else
 642       Result = ExprMap[N.getValue(0)] = MakeReg(N.getValue(0).getValueType());
 643
 644     // FIXME: We are currently ignoring the requested alignment for handling
 645     // greater than the stack alignment.  This will need to be revisited at some
 646     // point.  Align = N.getOperand(2);
 647     if (!isa<ConstantSDNode>(N.getOperand(2)) ||
 648         cast<ConstantSDNode>(N.getOperand(2))->getValue() != 0) {
 649       std::cerr << "Cannot allocate stack object with greater alignment than"
 650                 << " the stack alignment yet!";
 651       abort();
 652     }
 653     Select(N.getOperand(0));
 654     Tmp1 = SelectExpr(N.getOperand(1));
 655     // Subtract size from stack pointer, thereby allocating some space.
 656     BuildMI(BB, PPC::SUBF, 2, PPC::R1).addReg(Tmp1).addReg(PPC::R1);
 657     // Put a pointer to the space into the result register by copying the SP
 658     BuildMI(BB, PPC::OR, 2, Result).addReg(PPC::R1).addReg(PPC::R1);
 659     return Result;
 660
 661   case ISD::ConstantPool:
 662     abort();
 663
 664   case ISD::FrameIndex:
 665     abort();
 666
 667   case ISD::GlobalAddress: {
 668     GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal();
 669     unsigned Tmp1 = MakeReg(MVT::i32);
 670     BuildMI(BB, PPC::LOADHiAddr, 2, Tmp1).addReg(getGlobalBaseReg())
 671       .addGlobalAddress(GV);
 672     if (GV->hasWeakLinkage() || GV->isExternal()) {
 673       BuildMI(BB, PPC::LWZ, 2, Result).addGlobalAddress(GV).addReg(Tmp1);
 674     } else {
 675       BuildMI(BB, PPC::LA, 2, Result).addReg(Tmp1).addGlobalAddress(GV);
 676     }
 677     return Result;
 678   }
 679
 680   case ISD::LOAD:
 681   case ISD::EXTLOAD:
 682   case ISD::ZEXTLOAD:
 683   case ISD::SEXTLOAD: {
 684     // Make sure we generate both values.
 685     if (Result != 1)
 686       ExprMap[N.getValue(1)] = 1;   // Generate the token
 687     else
 688       Result = ExprMap[N.getValue(0)] = MakeReg(N.getValue(0).getValueType());
 689
 690     SDOperand Chain   = N.getOperand(0);
 691     SDOperand Address = N.getOperand(1);
 692     Select(Chain);
 693
 694     switch (Node->getValueType(0)) {
 695     default: assert(0 && "Cannot load this type!");
 696     case MVT::i1:  Opc = PPC::LBZ; Tmp3 = 0; break;
 697     case MVT::i8:  Opc = PPC::LBZ; Tmp3 = 1; break;
 698     case MVT::i16: Opc = PPC::LHZ; Tmp3 = 0; break;
 699     case MVT::i32: Opc = PPC::LWZ; Tmp3 = 0; break;
 700     }
 701
 702     if(Address.getOpcode() == ISD::FrameIndex) {
 703       BuildMI(BB, Opc, 2, Result)
 704       .addFrameIndex(cast<FrameIndexSDNode>(Address)->getIndex())
 705       .addReg(PPC::R1);
 706     } else {
 707       int offset;
 708       SelectAddr(Address, Tmp1, offset);
 709       BuildMI(BB, Opc, 2, Result).addSImm(offset).addReg(Tmp1);
 710     }
 711     return Result;
 712   }
 713
 714   case ISD::CALL: {
 715     // Lower the chain for this call.
 716     Select(N.getOperand(0));
 717     ExprMap[N.getValue(Node->getNumValues()-1)] = 1;
 718
 719     // get the virtual reg for each argument
 720     std::vector<unsigned> VRegs;
 721     for(int i = 2, e = Node->getNumOperands(); i < e; ++i)
 722       VRegs.push_back(SelectExpr(N.getOperand(i)));
 723
 724     // The ABI specifies that the first 32 bytes of args may be passed in GPRs,
 725     // and that 13 FPRs may also be used for passing any floating point args.
 726     int GPR_remaining = 8, FPR_remaining = 13;
 727     unsigned GPR_idx = 0, FPR_idx = 0;
 728     static const unsigned GPR[] = {
 729       PPC::R3, PPC::R4, PPC::R5, PPC::R6,
 730       PPC::R7, PPC::R8, PPC::R9, PPC::R10,
 731     };
 732     static const unsigned FPR[] = {
 733       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6,
 734       PPC::F7, PPC::F8, PPC::F9, PPC::F10, PPC::F11, PPC::F12,
 735       PPC::F13
 736     };
 737
 738     // move the vregs into the appropriate architected register or stack slot
 739     for(int i = 0, e = VRegs.size(); i < e; ++i) {
 740         unsigned OperandType = N.getOperand(i+2).getValueType();
 741         switch(OperandType) {
 742         default:
 743           Node->dump();
 744           N.getOperand(i).Val->dump();
 745           std::cerr << "Type for " << i << " is: " <<
 746             N.getOperand(i+2).getValueType() << "\n";
 747           assert(0 && "Unknown value type for call");
 748         case MVT::i1:
 749         case MVT::i8:
 750         case MVT::i16:
 751         case MVT::i32:
 752           if (GPR_remaining > 0)
 753             BuildMI(BB, PPC::OR, 2, GPR[GPR_idx]).addReg(VRegs[i])
 754               .addReg(VRegs[i]);
 755           break;
 756         case MVT::f32:
 757         case MVT::f64:
 758           if (FPR_remaining > 0) {
 759             BuildMI(BB, PPC::FMR, 1, FPR[FPR_idx]).addReg(VRegs[i]);
 760             ++FPR_idx;
 761             --FPR_remaining;
 762           }
 763           break;
 764         }
 765         // All arguments consume GPRs available for argument passing
 766         if (GPR_remaining > 0) {
 767           ++GPR_idx;
 768           --GPR_remaining;
 769         }
 770         if (MVT::f64 == OperandType && GPR_remaining > 0) {
 771           ++GPR_idx;
 772           --GPR_remaining;
 773         }
 774     }
 775
 776     // Emit the correct call instruction based on the type of symbol called.
 777     if (GlobalAddressSDNode *GASD =
 778         dyn_cast<GlobalAddressSDNode>(N.getOperand(1))) {
 779       BuildMI(BB, PPC::CALLpcrel, 1).addGlobalAddress(GASD->getGlobal(), true);
 780     } else if (ExternalSymbolSDNode *ESSDN =
 781                dyn_cast<ExternalSymbolSDNode>(N.getOperand(1))) {
 782       BuildMI(BB, PPC::CALLpcrel, 1).addExternalSymbol(ESSDN->getSymbol(), true);
 783     } else {
 784       Tmp1 = SelectExpr(N.getOperand(1));
 785       BuildMI(BB, PPC::OR, 2, PPC::R12).addReg(Tmp1).addReg(Tmp1);
 786       BuildMI(BB, PPC::MTCTR, 1).addReg(PPC::R12);
 787       BuildMI(BB, PPC::CALLindirect, 3).addImm(20).addImm(0).addReg(PPC::R12);
 788     }
 789
 790     switch (Node->getValueType(0)) {
 791     default: assert(0 && "Unknown value type for call result!");
 792     case MVT::Other: return 1;
 793     case MVT::i1:
 794     case MVT::i8:
 795     case MVT::i16:
 796     case MVT::i32:
 797       BuildMI(BB, PPC::OR, 2, Result).addReg(PPC::R3).addReg(PPC::R3);
 798       if (Node->getValueType(1) == MVT::i32)
 799         BuildMI(BB, PPC::OR, 2, Result+1).addReg(PPC::R4).addReg(PPC::R4);
 800       break;
 801     case MVT::f32:
 802     case MVT::f64:
 803       BuildMI(BB, PPC::FMR, 1, Result).addReg(PPC::F1);
 804       break;
 805     }
 806     return Result+N.ResNo;
 807   }
 808
 809   case ISD::SIGN_EXTEND:
 810   case ISD::SIGN_EXTEND_INREG:
 811     Tmp1 = SelectExpr(N.getOperand(0));
 812     BuildMI(BB, PPC::EXTSH, 1, Result).addReg(Tmp1);
 813     return Result;
 814
 815   case ISD::ZERO_EXTEND_INREG:
 816     Tmp1 = SelectExpr(N.getOperand(0));
 817     switch(cast<MVTSDNode>(Node)->getExtraValueType()) {
 818     default:
 819       Node->dump();
 820       assert(0 && "Zero Extend InReg not there yet");
 821       break;
 822     case MVT::i16:  Tmp2 = 16; break;
 823     case MVT::i8:   Tmp2 = 24; break;
 824     case MVT::i1:   Tmp2 = 31; break;
 825     }
 826     BuildMI(BB, PPC::RLWINM, 5, Result).addReg(Tmp1).addImm(0).addImm(0)
 827       .addImm(Tmp2).addImm(31);
 828     return Result;
 829
 830   case ISD::CopyFromReg:
 831     if (Result == 1)
 832       Result = ExprMap[N.getValue(0)] = MakeReg(N.getValue(0).getValueType());
 833     Tmp1 = dyn_cast<RegSDNode>(Node)->getReg();
 834     BuildMI(BB, PPC::OR, 2, Result).addReg(Tmp1).addReg(Tmp1);
 835     return Result;
 836
 837   case ISD::SHL:
 838     Tmp1 = SelectExpr(N.getOperand(0));
 839     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 840       Tmp2 = CN->getValue() & 0x1F;
 841       BuildMI(BB, PPC::RLWINM, 5, Result).addReg(Tmp1).addImm(Tmp2).addImm(0)
 842         .addImm(31-Tmp2);
 843     } else {
 844       Tmp2 = SelectExpr(N.getOperand(1));
 845       BuildMI(BB, PPC::SLW, 2, Result).addReg(Tmp1).addReg(Tmp2);
 846     }
 847     return Result;
 848
 849   case ISD::SRL:
 850     Tmp1 = SelectExpr(N.getOperand(0));
 851     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 852       Tmp2 = CN->getValue() & 0x1F;
 853       BuildMI(BB, PPC::RLWINM, 5, Result).addReg(Tmp1).addImm(32-Tmp2)
 854         .addImm(Tmp2).addImm(31);
 855     } else {
 856       Tmp2 = SelectExpr(N.getOperand(1));
 857       BuildMI(BB, PPC::SRW, 2, Result).addReg(Tmp1).addReg(Tmp2);
 858     }
 859     return Result;
 860
 861   case ISD::SRA:
 862     Tmp1 = SelectExpr(N.getOperand(0));
 863     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 864       Tmp2 = CN->getValue() & 0x1F;
 865       BuildMI(BB, PPC::SRAWI, 2, Result).addReg(Tmp1).addImm(Tmp2);
 866     } else {
 867       Tmp2 = SelectExpr(N.getOperand(1));
 868       BuildMI(BB, PPC::SRAW, 2, Result).addReg(Tmp1).addReg(Tmp2);
 869     }
 870     return Result;
 871
 872   case ISD::ADD:
 873     assert (DestType == MVT::i32 && "Only do arithmetic on i32s!");
 874     Tmp1 = SelectExpr(N.getOperand(0));
 875     switch(canUseAsImmediateForOpcode(N.getOperand(1), opcode, Tmp2)) {
 876       default: assert(0 && "unhandled result code");
 877       case 0: // No immediate
 878         Tmp2 = SelectExpr(N.getOperand(1));
 879         BuildMI(BB, PPC::ADD, 2, Result).addReg(Tmp1).addReg(Tmp2);
 880         break;
 881       case 1: // Low immediate
 882         BuildMI(BB, PPC::ADDI, 2, Result).addReg(Tmp1).addSImm(Tmp2);
 883         break;
 884       case 2: // Shifted immediate
 885         BuildMI(BB, PPC::ADDIS, 2, Result).addReg(Tmp1).addSImm(Tmp2);
 886         break;
 887     }
 888     return Result;
 889
 890   case ISD::AND:
 891   case ISD::OR:
 892   case ISD::XOR:
 893     assert (DestType == MVT::i32 && "Only do arithmetic on i32s!");
 894     Tmp1 = SelectExpr(N.getOperand(0));
 895     switch(canUseAsImmediateForOpcode(N.getOperand(1), opcode, Tmp2)) {
 896       default: assert(0 && "unhandled result code");
 897       case 0: // No immediate
 898         Tmp2 = SelectExpr(N.getOperand(1));
 899         switch (opcode) {
 900         case ISD::AND: Opc = PPC::AND; break;
 901         case ISD::OR:  Opc = PPC::OR;  break;
 902         case ISD::XOR: Opc = PPC::XOR; break;
 903         }
 904         BuildMI(BB, Opc, 2, Result).addReg(Tmp1).addReg(Tmp2);
 905         break;
 906       case 1: // Low immediate
 907         switch (opcode) {
 908         case ISD::AND: Opc = PPC::ANDIo; break;
 909         case ISD::OR:  Opc = PPC::ORI;   break;
 910         case ISD::XOR: Opc = PPC::XORI;  break;
 911         }
 912         BuildMI(BB, Opc, 2, Result).addReg(Tmp1).addImm(Tmp2);
 913         break;
 914       case 2: // Shifted immediate
 915         switch (opcode) {
 916         case ISD::AND: Opc = PPC::ANDISo;  break;
 917         case ISD::OR:  Opc = PPC::ORIS;    break;
 918         case ISD::XOR: Opc = PPC::XORIS;   break;
 919         }
 920         BuildMI(BB, Opc, 2, Result).addReg(Tmp1).addImm(Tmp2);
 921         break;
 922     }
 923     return Result;
 924
 925   case ISD::SUB:
 926     assert (DestType == MVT::i32 && "Only do arithmetic on i32s!");
 927     Tmp1 = SelectExpr(N.getOperand(0));
 928     Tmp2 = SelectExpr(N.getOperand(1));
 929     BuildMI(BB, PPC::SUBF, 2, Result).addReg(Tmp2).addReg(Tmp1);
 930     return Result;
 931
 932   case ISD::MUL:
 933     assert (DestType == MVT::i32 && "Only do arithmetic on i32s!");
 934     Tmp1 = SelectExpr(N.getOperand(0));
 935     if (1 == canUseAsImmediateForOpcode(N.getOperand(1), opcode, Tmp2))
 936       BuildMI(BB, PPC::MULLI, 2, Result).addReg(Tmp1).addSImm(Tmp2);
 937     else {
 938       Tmp2 = SelectExpr(N.getOperand(1));
 939       BuildMI(BB, PPC::MULLW, 2, Result).addReg(Tmp1).addReg(Tmp2);
 940     }
 941     return Result;
 942
 943   case ISD::ADD_PARTS:
 944   case ISD::SUB_PARTS:
 945   case ISD::UREM:
 946   case ISD::SREM:
 947   case ISD::SDIV:
 948   case ISD::UDIV:
 949     abort();
 950
 951   case ISD::FP_TO_UINT:
 952   case ISD::FP_TO_SINT:
 953     abort();
 954
 955   case ISD::SETCC:
 956     abort();
 957
 958   case ISD::SELECT:
 959     abort();
 960
 961   case ISD::Constant:
 962     switch (N.getValueType()) {
 963     default: assert(0 && "Cannot use constants of this type!");
 964     case MVT::i1:
 965       BuildMI(BB, PPC::LI, 1, Result)
 966         .addSImm(!cast<ConstantSDNode>(N)->isNullValue());
 967       break;
 968     case MVT::i32:
 969       {
 970         int v = (int)cast<ConstantSDNode>(N)->getSignExtended();
 971         if (v < 32768 && v >= -32768) {
 972           BuildMI(BB, PPC::LI, 1, Result).addSImm(v);
 973         } else {
 974           Tmp1 = MakeReg(MVT::i32);
 975           BuildMI(BB, PPC::LIS, 1, Tmp1).addSImm(v >> 16);
 976           BuildMI(BB, PPC::ORI, 2, Result).addReg(Tmp1).addImm(v & 0xFFFF);
 977         }
 978       }
 979     }
 980     return Result;
 981   }
 982
 983   return 0;
 984 }
 985
 986 void ISel::Select(SDOperand N) {
 987   unsigned Tmp1, Tmp2, Opc;
 988   unsigned opcode = N.getOpcode();
 989
 990   if (!ExprMap.insert(std::make_pair(N, 1)).second)
 991     return;  // Already selected.
 992
 993   SDNode *Node = N.Val;
 994
 995   switch (Node->getOpcode()) {
 996   default:
 997     Node->dump(); std::cerr << "\n";
 998     assert(0 && "Node not handled yet!");
 999   case ISD::EntryToken: return;  // Noop
1000   case ISD::TokenFactor:
1001     for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i)
1002       Select(Node->getOperand(i));
1003     return;
1004   case ISD::ADJCALLSTACKDOWN:
1005   case ISD::ADJCALLSTACKUP:
1006     Select(N.getOperand(0));
1007     Tmp1 = cast<ConstantSDNode>(N.getOperand(1))->getValue();
1008     Opc = N.getOpcode() == ISD::ADJCALLSTACKDOWN ? PPC::ADJCALLSTACKDOWN :
1009       PPC::ADJCALLSTACKUP;
1010     BuildMI(BB, Opc, 1).addImm(Tmp1);
1011     return;
1012   case ISD::BR: {
1013     MachineBasicBlock *Dest =
1014       cast<BasicBlockSDNode>(N.getOperand(1))->getBasicBlock();
1015     Select(N.getOperand(0));
1016     BuildMI(BB, PPC::B, 1).addMBB(Dest);
1017     return;
1018   }
1019   case ISD::BRCOND:
1020     SelectBranchCC(N);
1021     return;
1022   case ISD::CopyToReg:
1023     Select(N.getOperand(0));
1024     Tmp1 = SelectExpr(N.getOperand(1));
1025     Tmp2 = cast<RegSDNode>(N)->getReg();
1026
1027     if (Tmp1 != Tmp2) {
1028       if (N.getOperand(1).getValueType() == MVT::f64 ||
1029           N.getOperand(1).getValueType() == MVT::f32)
1030         BuildMI(BB, PPC::FMR, 1, Tmp2).addReg(Tmp1);
1031       else
1032         BuildMI(BB, PPC::OR, 2, Tmp2).addReg(Tmp1).addReg(Tmp1);
1033     }
1034     return;
1035   case ISD::ImplicitDef:
1036     Select(N.getOperand(0));
1037     BuildMI(BB, PPC::IMPLICIT_DEF, 0, cast<RegSDNode>(N)->getReg());
1038     return;
1039   case ISD::RET:
1040     switch (N.getNumOperands()) {
1041     default:
1042       assert(0 && "Unknown return instruction!");
1043     case 3:
1044       assert(N.getOperand(1).getValueType() == MVT::i32 &&
1045              N.getOperand(2).getValueType() == MVT::i32 &&
1046                    "Unknown two-register value!");
1047       Select(N.getOperand(0));
1048       Tmp1 = SelectExpr(N.getOperand(1));
1049       Tmp2 = SelectExpr(N.getOperand(2));
1050       BuildMI(BB, PPC::OR, 2, PPC::R3).addReg(Tmp1).addReg(Tmp1);
1051       BuildMI(BB, PPC::OR, 2, PPC::R4).addReg(Tmp2).addReg(Tmp2);
1052       break;
1053     case 2:
1054       Select(N.getOperand(0));
1055       Tmp1 = SelectExpr(N.getOperand(1));
1056       switch (N.getOperand(1).getValueType()) {
1057         default:
1058           assert(0 && "Unknown return type!");
1059         case MVT::f64:
1060         case MVT::f32:
1061           BuildMI(BB, PPC::FMR, 1, PPC::F1).addReg(Tmp1);
1062           break;
1063         case MVT::i32:
1064           BuildMI(BB, PPC::OR, 2, PPC::R3).addReg(Tmp1).addReg(Tmp1);
1065           break;
1066       }
1067     case 1:
1068       Select(N.getOperand(0));
1069       break;
1070     }
1071     BuildMI(BB, PPC::BLR, 0); // Just emit a 'ret' instruction
1072     return;
1073   case ISD::TRUNCSTORE:
1074   case ISD::STORE:
1075     {
1076       SDOperand Chain   = N.getOperand(0);
1077       SDOperand Value   = N.getOperand(1);
1078       SDOperand Address = N.getOperand(2);
1079       Select(Chain);
1080
1081       Tmp1 = SelectExpr(Value); //value
1082
1083       if (opcode == ISD::STORE) {
1084         switch(Value.getValueType()) {
1085         default: assert(0 && "unknown Type in store");
1086         case MVT::i32: Opc = PPC::STW; break;
1087         case MVT::f64: Opc = PPC::STFD; break;
1088         case MVT::f32: Opc = PPC::STFS; break;
1089         }
1090       } else { //ISD::TRUNCSTORE
1091         switch(cast<MVTSDNode>(Node)->getExtraValueType()) {
1092         default: assert(0 && "unknown Type in store");
1093         case MVT::i1: //FIXME: DAG does not promote this load
1094         case MVT::i8: Opc  = PPC::STB; break;
1095         case MVT::i16: Opc = PPC::STH; break;
1096         }
1097       }
1098
1099       if (Address.getOpcode() == ISD::GlobalAddress)
1100       {
1101         BuildMI(BB, Opc, 2).addReg(Tmp1)
1102           .addGlobalAddress(cast<GlobalAddressSDNode>(Address)->getGlobal());
1103       }
1104       else if(Address.getOpcode() == ISD::FrameIndex)
1105       {
1106         BuildMI(BB, Opc, 2).addReg(Tmp1)
1107           .addFrameIndex(cast<FrameIndexSDNode>(Address)->getIndex());
1108       }
1109       else
1110       {
1111         int offset;
1112         SelectAddr(Address, Tmp2, offset);
1113         BuildMI(BB, Opc, 3).addReg(Tmp1).addImm(offset).addReg(Tmp2);
1114       }
1115       return;
1116     }
1117   case ISD::EXTLOAD:
1118   case ISD::SEXTLOAD:
1119   case ISD::ZEXTLOAD:
1120   case ISD::LOAD:
1121   case ISD::CopyFromReg:
1122   case ISD::CALL:
1123   case ISD::DYNAMIC_STACKALLOC:
1124     ExprMap.erase(N);
1125     SelectExpr(N);
1126     return;
1127   }
1128   assert(0 && "Should not be reached!");
1129 }
1130
1131
1132 /// createPPC32PatternInstructionSelector - This pass converts an LLVM function
1133 /// into a machine code representation using pattern matching and a machine
1134 /// description file.
1135 ///
1136 FunctionPass *llvm::createPPC32ISelPattern(TargetMachine &TM) {
1137   return new ISel(TM);
1138 }
1139