Remove some of the obvious v9-specific cruft

[oota-llvm.git] / include / llvm / CodeGen / MachineInstrBuilder.h

diff --git a/include/llvm/CodeGen/MachineInstrBuilder.h b/include/llvm/CodeGen/MachineInstrBuilder.h
index 4d63d99e45bfafef1303d45fe8e860eb32dbe3dc..1f877c0809fe32614bbcc544d962f23ba42af366 100644 (file)
--- a/include/llvm/CodeGen/MachineInstrBuilder.h
+++ b/include/llvm/CodeGen/MachineInstrBuilder.h
@@ -1,16 +1,16 @@
 //===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file exposes a function named BuildMI, which is useful for dramatically
 // simplifying how MachineInstr's are created.  Instead of using code like this:
 //
-//   M = new MachineInstr(X86::ADDrr32);
+//   M = new MachineInstr(X86::ADDrr8);
 //   M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
 //   M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
 //
@@ -35,6 +35,7 @@ public:
   /// Allow automatic conversion to the machine instruction we are working on.
   ///
   operator MachineInstr*() const { return MI; }
+  operator MachineBasicBlock::iterator() const { return MI; }
 
   /// addReg - Add a new virtual register operand...
   ///
@@ -85,7 +86,7 @@ public:
     MI->addMachineRegOperand(Reg, Ty);
     return *this;
   }
-  
+
   /// addImm - Add a new immediate operand.
   ///
   const MachineInstrBuilder &addImm(int Val) const {
@@ -107,6 +108,13 @@ public:
     return *this;
   }
 
+  /// addImm64 - Add a new 64-bit immediate operand...
+  ///
+  const MachineInstrBuilder &addImm64(uint64_t Val) const {
+    MI->addZeroExtImm64Operand(Val);
+    return *this;
+  }
+
   const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB) const {
     MI->addMachineBasicBlockOperand(MBB);
     return *this;
@@ -117,20 +125,22 @@ public:
     return *this;
   }
 
-  const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx) const {
-    MI->addConstantPoolIndexOperand(Idx);
+  const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
+                                                  int Offset = 0) const {
+    MI->addConstantPoolIndexOperand(Idx, Offset);
     return *this;
   }
 
   const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV,
-                                             bool isPCRelative = false) const {
-    MI->addGlobalAddressOperand(GV, isPCRelative);
+                                              bool isPCRelative = false,
+                                              int Offset = 0) const {
+    MI->addGlobalAddressOperand(GV, isPCRelative, Offset);
     return *this;
   }
 
-  const MachineInstrBuilder &addExternalSymbol(const std::string &Name,
-                                              bool isPCRelative = false) const{
-    MI->addExternalSymbolOperand(Name, isPCRelative);
+  const MachineInstrBuilder &addExternalSymbol(const char *FnName,
+                                               bool isPCRelative = false) const{
+    MI->addExternalSymbolOperand(FnName, isPCRelative);
     return *this;
   }
 };
@@ -143,9 +153,9 @@ inline MachineInstrBuilder BuildMI(int Opcode, unsigned NumOperands) {
   return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands, true, true));
 }
 
-/// BuildMI - This version of the builder also sets up the first "operand" as a
+/// BuildMI - This version of the builder sets up the first operand as a
 /// destination virtual register.  NumOperands is the number of additional add*
-/// calls that are expected, it does not include the destination register.
+/// calls that are expected, not including the destination register.
 ///
 inline MachineInstrBuilder BuildMI(
   int Opcode, unsigned NumOperands,
@@ -155,9 +165,12 @@ inline MachineInstrBuilder BuildMI(
                                    true, true)).addReg(DestReg, useType);
 }
 
-
-/// BuildMI - Insert the instruction before a specified location in the basic
-/// block.
+/// BuildMI - This version of the builder inserts the newly-built
+/// instruction before the given position in the given MachineBasicBlock, and
+/// sets up the first operand as a destination virtual register.
+/// NumOperands is the number of additional add* calls that are expected,
+/// not including the destination register.
+///
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                                    MachineBasicBlock::iterator I,
                                    int Opcode, unsigned NumOperands,
@@ -167,8 +180,10 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
   return MachineInstrBuilder(MI).addReg(DestReg, MachineOperand::Def);
 }
 
-/// BMI - A special BuildMI variant that takes an iterator to insert the
-/// instruction at as well as a basic block.
+/// BuildMI - This version of the builder inserts the newly-built
+/// instruction before the given position in the given MachineBasicBlock, and
+/// does NOT take a destination register.
+///
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                                    MachineBasicBlock::iterator I,
                                    int Opcode, unsigned NumOperands) {
@@ -177,18 +192,20 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
   return MachineInstrBuilder(MI);
 }
 
-/// BuildMI - This version of the builder inserts the built MachineInstr into
-/// the specified MachineBasicBlock.
+/// BuildMI - This version of the builder inserts the newly-built
+/// instruction at the end of the given MachineBasicBlock, and does NOT take a
+/// destination register.
 ///
 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode,
                                    unsigned NumOperands) {
   return BuildMI(*BB, BB->end(), Opcode, NumOperands);
 }
 
-/// BuildMI - This version of the builder inserts the built MachineInstr into
-/// the specified MachineBasicBlock, and also sets up the first "operand" as a
-/// destination virtual register.  NumOperands is the number of additional add*
-/// calls that are expected, it does not include the destination register.
+/// BuildMI - This version of the builder inserts the newly-built
+/// instruction at the end of the given MachineBasicBlock, and sets up the first
+/// operand as a destination virtual register. NumOperands is the number of
+/// additional add* calls that are expected, not including the destination
+/// register.
 ///
 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode,
                                    unsigned NumOperands, unsigned DestReg) {