X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FX86%2FX86FloatingPoint.cpp;h=5c6e6ebfddec041c301587ceb97b6980aef99ccd;hb=52b62de10063a15dfbcfb8b61504df826c76e03c;hp=f37b65fe05852f3054062d42bf218357d8117e86;hpb=cb5335877804fe9e555be8955314935f35c26f30;p=oota-llvm.git

diff --git a/lib/Target/X86/X86FloatingPoint.cpp b/lib/Target/X86/X86FloatingPoint.cpp
index f37b65fe058..5c6e6ebfdde 100644
--- a/lib/Target/X86/X86FloatingPoint.cpp
+++ b/lib/Target/X86/X86FloatingPoint.cpp
@@ -1,4 +1,11 @@
 //===-- FloatingPoint.cpp - Floating point Reg -> Stack converter ---------===//
+// 
+//                     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 defines the pass which converts floating point instructions from
 // virtual registers into register stack instructions.
@@ -18,6 +25,8 @@
 #include <algorithm>
 #include <iostream>
 
+namespace llvm {
+
 namespace {
   Statistic<> NumFXCH("x86-codegen", "Number of fxch instructions inserted");
   Statistic<> NumFP  ("x86-codegen", "Number of floating point instructions");
@@ -63,7 +72,7 @@ namespace {
     // getSTReg - Return the X86::ST(i) register which contains the specified
     // FP<RegNo> register
     unsigned getSTReg(unsigned RegNo) const {
-      return StackTop - 1 - getSlot(RegNo) + X86::ST0;
+      return StackTop - 1 - getSlot(RegNo) + llvm::X86::ST0;
     }
 
     // pushReg - Push the specifiex FP<n> register onto the stack
@@ -117,7 +126,7 @@ namespace {
   };
 }
 
-Pass *createX86FloatingPointStackifierPass() { return new FPS(); }
+FunctionPass *createX86FloatingPointStackifierPass() { return new FPS(); }
 
 /// runOnMachineFunction - Loop over all of the basic blocks, transforming FP
 /// register references into FP stack references.
@@ -185,7 +194,7 @@ bool FPS::processBasicBlock(MachineFunction &MF, MachineBasicBlock &BB) {
       if (Reg >= X86::FP0 && Reg <= X86::FP6) {
 	DEBUG(std::cerr << "Register FP#" << Reg-X86::FP0 << " is dead!\n");
 	++I;                         // Insert fxch AFTER the instruction
-	moveToTop(Reg-X86::FP0, I);  // Insert fxch if neccesary
+	moveToTop(Reg-X86::FP0, I);  // Insert fxch if necessary
 	--I;                         // Move to fxch or old instruction
 	popStackAfter(I);            // Pop the top of the stack, killing value
       }
@@ -259,21 +268,25 @@ static int Lookup(const TableEntry *Table, unsigned N, unsigned Opcode) {
 // element is an instruction, the second is the version which pops.
 //
 static const TableEntry PopTable[] = {
+  { X86::FADDrST0 , X86::FADDPrST0  },
+
+  { X86::FDIVRrST0, X86::FDIVRPrST0 },
+  { X86::FDIVrST0 , X86::FDIVPrST0  },
+
+  { X86::FISTr16  , X86::FISTPr16   },
+  { X86::FISTr32  , X86::FISTPr32   },
+
+  { X86::FMULrST0 , X86::FMULPrST0  },
+
   { X86::FSTr32   , X86::FSTPr32    },
   { X86::FSTr64   , X86::FSTPr64    },
   { X86::FSTrr    , X86::FSTPrr     },
-  { X86::FISTr16  , X86::FISTPr16   },
-  { X86::FISTr32  , X86::FISTPr32   },
 
-  { X86::FADDrST0 , X86::FADDPrST0  },
-  { X86::FSUBrST0 , X86::FSUBPrST0  },
   { X86::FSUBRrST0, X86::FSUBRPrST0 },
-  { X86::FMULrST0 , X86::FMULPrST0  },
-  { X86::FDIVrST0 , X86::FDIVPrST0  },
-  { X86::FDIVRrST0, X86::FDIVRPrST0 },
+  { X86::FSUBrST0 , X86::FSUBPrST0  },
 
-  { X86::FUCOMr   , X86::FUCOMPr    },
   { X86::FUCOMPr  , X86::FUCOMPPr   },
+  { X86::FUCOMr   , X86::FUCOMPr    },
 };
 
 /// popStackAfter - Pop the current value off of the top of the FP stack after
@@ -363,36 +376,36 @@ void FPS::handleOneArgFP(MachineBasicBlock::iterator &I) {
 // ForwardST0Table - Map: A = B op C  into: ST(0) = ST(0) op ST(i)
 static const TableEntry ForwardST0Table[] = {
   { X86::FpADD,  X86::FADDST0r  },
-  { X86::FpSUB,  X86::FSUBST0r  },
-  { X86::FpMUL,  X86::FMULST0r  },
   { X86::FpDIV,  X86::FDIVST0r  },
+  { X86::FpMUL,  X86::FMULST0r  },
+  { X86::FpSUB,  X86::FSUBST0r  },
   { X86::FpUCOM, X86::FUCOMr    },
 };
 
 // ReverseST0Table - Map: A = B op C  into: ST(0) = ST(i) op ST(0)
 static const TableEntry ReverseST0Table[] = {
   { X86::FpADD,  X86::FADDST0r  },   // commutative
-  { X86::FpSUB,  X86::FSUBRST0r },
-  { X86::FpMUL,  X86::FMULST0r  },   // commutative
   { X86::FpDIV,  X86::FDIVRST0r },
+  { X86::FpMUL,  X86::FMULST0r  },   // commutative
+  { X86::FpSUB,  X86::FSUBRST0r },
   { X86::FpUCOM, ~0             },
 };
 
 // ForwardSTiTable - Map: A = B op C  into: ST(i) = ST(0) op ST(i)
 static const TableEntry ForwardSTiTable[] = {
   { X86::FpADD,  X86::FADDrST0  },   // commutative
-  { X86::FpSUB,  X86::FSUBRrST0 },
-  { X86::FpMUL,  X86::FMULrST0  },   // commutative
   { X86::FpDIV,  X86::FDIVRrST0 },
+  { X86::FpMUL,  X86::FMULrST0  },   // commutative
+  { X86::FpSUB,  X86::FSUBRrST0 },
   { X86::FpUCOM, X86::FUCOMr    },
 };
 
 // ReverseSTiTable - Map: A = B op C  into: ST(i) = ST(i) op ST(0)
 static const TableEntry ReverseSTiTable[] = {
   { X86::FpADD,  X86::FADDrST0 },
-  { X86::FpSUB,  X86::FSUBrST0 },
-  { X86::FpMUL,  X86::FMULrST0 },
   { X86::FpDIV,  X86::FDIVrST0 },
+  { X86::FpMUL,  X86::FMULrST0 },
+  { X86::FpSUB,  X86::FSUBrST0 },
   { X86::FpUCOM, ~0            },
 };
 
@@ -545,7 +558,7 @@ void FPS::handleTwoArgFP(MachineBasicBlock::iterator &I) {
 
 
 /// handleSpecialFP - Handle special instructions which behave unlike other
-/// floating point instructions.  This is primarily inteaded for use by pseudo
+/// floating point instructions.  This is primarily intended for use by pseudo
 /// instructions.
 ///
 void FPS::handleSpecialFP(MachineBasicBlock::iterator &I) {
@@ -587,3 +600,5 @@ void FPS::handleSpecialFP(MachineBasicBlock::iterator &I) {
 
   I = MBB->erase(I)-1;  // Remove the pseudo instruction
 }
+
+} // End llvm namespace