Support a new type of MachineOperand, MO_FPImmediate, used for holding

FP Immediates, crazily enough

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47117 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/CodeGen/MachineOperand.h b/include/llvm/CodeGen/MachineOperand.h
index 7fb2b9e7674d59e2b7f48c674258d5b6744ffa92..d62c8f8b4749d2372bd32ac1cc1a58db2cb4f92b 100644 (file)
--- a/include/llvm/CodeGen/MachineOperand.h
+++ b/include/llvm/CodeGen/MachineOperand.h
@@ -21,6 +21,7 @@
 
 namespace llvm {
   
+class ConstantFP;
 class MachineBasicBlock;
 class GlobalValue;
 class MachineInstr;
@@ -34,6 +35,7 @@ public:
   enum MachineOperandType {
     MO_Register,                // Register operand.
     MO_Immediate,               // Immediate Operand
+    MO_FPImmediate,
     MO_MachineBasicBlock,       // MachineBasicBlock reference
     MO_FrameIndex,              // Abstract Stack Frame Index
     MO_ConstantPoolIndex,       // Address of indexed Constant in Constant Pool
@@ -77,6 +79,7 @@ private:
   /// Contents union - This contains the payload for the various operand types.
   union {
     MachineBasicBlock *MBB;   // For MO_MachineBasicBlock.
+    ConstantFP *CFP;          // For MO_FPImmediate.
     int64_t ImmVal;           // For MO_Immediate.
 
     struct {                  // For MO_Register.
@@ -120,6 +123,7 @@ public:
   ///
   bool isRegister() const { return OpKind == MO_Register; }
   bool isImmediate() const { return OpKind == MO_Immediate; }
+  bool isFPImmediate() const { return OpKind == MO_FPImmediate; }
   bool isMachineBasicBlock() const { return OpKind == MO_MachineBasicBlock; }
   bool isFrameIndex() const { return OpKind == MO_FrameIndex; }
   bool isConstantPoolIndex() const { return OpKind == MO_ConstantPoolIndex; }
@@ -231,6 +235,11 @@ public:
     return Contents.ImmVal;
   }
   
+  ConstantFP *getFPImm() const {
+    assert(isFPImmediate() && "Wrong MachineOperand accessor");
+    return Contents.CFP;
+  }
+  
   MachineBasicBlock *getMBB() const {
     assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
     return Contents.MBB;
@@ -313,6 +322,12 @@ public:
     return Op;
   }
   
+  static MachineOperand CreateFPImm(ConstantFP *CFP) {
+    MachineOperand Op(MachineOperand::MO_FPImmediate);
+    Op.Contents.CFP = CFP;
+    return Op;
+  }
+  
   static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
                                   bool isKill = false, bool isDead = false,
                                   unsigned SubReg = 0) {

diff --git a/lib/CodeGen/MachineInstr.cpp b/lib/CodeGen/MachineInstr.cpp
index d576caf7f9b0149ee45d9eb55f21f64c576f3641..911d5caa1d331d5267a569acd336552d00db3582 100644 (file)
--- a/lib/CodeGen/MachineInstr.cpp
+++ b/lib/CodeGen/MachineInstr.cpp
@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Constants.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/Value.h"
 #include "llvm/CodeGen/MachineFunction.h"
@@ -138,6 +139,8 @@ bool MachineOperand::isIdenticalTo(const MachineOperand &Other) const {
            getSubReg() == Other.getSubReg();
   case MachineOperand::MO_Immediate:
     return getImm() == Other.getImm();
+  case MachineOperand::MO_FPImmediate:
+    return getFPImm() == Other.getFPImm();
   case MachineOperand::MO_MachineBasicBlock:
     return getMBB() == Other.getMBB();
   case MachineOperand::MO_FrameIndex:
@@ -197,6 +200,13 @@ void MachineOperand::print(std::ostream &OS, const TargetMachine *TM) const {
   case MachineOperand::MO_Immediate:
     OS << getImm();
     break;
+  case MachineOperand::MO_FPImmediate:
+    if (getFPImm()->getType() == Type::FloatTy) {
+      OS << getFPImm()->getValueAPF().convertToFloat();
+    } else {
+      OS << getFPImm()->getValueAPF().convertToDouble();
+    }
+    break;
   case MachineOperand::MO_MachineBasicBlock:
     OS << "mbb<"
        << ((Value*)getMBB()->getBasicBlock())->getName()