Add the private linkage.

[oota-llvm.git] / lib / Target / PowerPC / PPCBranchSelector.cpp

diff --git a/lib/Target/PowerPC/PPCBranchSelector.cpp b/lib/Target/PowerPC/PPCBranchSelector.cpp
index edd2857921b4b4e261393ba5c7ba6a2f7db2c8d7..add37e11f3fcffbe63354a1a46f7babfa8de4bb9 100644 (file)
--- a/lib/Target/PowerPC/PPCBranchSelector.cpp
+++ b/lib/Target/PowerPC/PPCBranchSelector.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Nate Baegeman and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,23 +15,25 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "ppc-branch-select"
 #include "PPC.h"
 #include "PPCInstrBuilder.h"
 #include "PPCInstrInfo.h"
 #include "PPCPredicates.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetAsmInfo.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
 using namespace llvm;
 
-static Statistic<> NumExpanded("ppc-branch-select",
-                               "Num branches expanded to long format");
+STATISTIC(NumExpanded, "Number of branches expanded to long format");
 
 namespace {
   struct VISIBILITY_HIDDEN PPCBSel : public MachineFunctionPass {
+    static char ID;
+    PPCBSel() : MachineFunctionPass(&ID) {}
+
     /// BlockSizes - The sizes of the basic blocks in the function.
     std::vector<unsigned> BlockSizes;
 
@@ -41,6 +43,7 @@ namespace {
       return "PowerPC Branch Selector";
     }
   };
+  char PPCBSel::ID = 0;
 }
 
 /// createPPCBranchSelectionPass - returns an instance of the Branch Selection
@@ -50,28 +53,6 @@ FunctionPass *llvm::createPPCBranchSelectionPass() {
   return new PPCBSel();
 }
 
-/// getNumBytesForInstruction - Return the number of bytes of code the specified
-/// instruction may be.  This returns the maximum number of bytes.
-///
-static unsigned getNumBytesForInstruction(MachineInstr *MI) {
-  switch (MI->getOpcode()) {
-  case PPC::IMPLICIT_DEF_GPRC: // no asm emitted
-  case PPC::IMPLICIT_DEF_G8RC: // no asm emitted
-  case PPC::IMPLICIT_DEF_F4:   // no asm emitted
-  case PPC::IMPLICIT_DEF_F8:   // no asm emitted
-  case PPC::IMPLICIT_DEF_VRRC: // no asm emitted
-    return 0;
-  case PPC::INLINEASM: {       // Inline Asm: Variable size.
-    MachineFunction *MF = MI->getParent()->getParent();
-    const char *AsmStr = MI->getOperand(0).getSymbolName();
-    return MF->getTarget().getTargetAsmInfo()->getInlineAsmLength(AsmStr);
-  }
-  default:
-    return 4; // PowerPC instructions are all 4 bytes
-  }
-}
-
-
 bool PPCBSel::runOnMachineFunction(MachineFunction &Fn) {
   const TargetInstrInfo *TII = Fn.getTarget().getInstrInfo();
   // Give the blocks of the function a dense, in-order, numbering.
@@ -87,7 +68,7 @@ bool PPCBSel::runOnMachineFunction(MachineFunction &Fn) {
     unsigned BlockSize = 0;
     for (MachineBasicBlock::iterator MBBI = MBB->begin(), EE = MBB->end();
          MBBI != EE; ++MBBI)
-      BlockSize += getNumBytesForInstruction(MBBI);
+      BlockSize += TII->GetInstSizeInBytes(MBBI);
     
     BlockSizes[MBB->getNumber()] = BlockSize;
     FuncSize += BlockSize;
@@ -123,13 +104,13 @@ bool PPCBSel::runOnMachineFunction(MachineFunction &Fn) {
       for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
            I != E; ++I) {
         if (I->getOpcode() != PPC::BCC || I->getOperand(2).isImm()) {
-          MBBStartOffset += getNumBytesForInstruction(I);
+          MBBStartOffset += TII->GetInstSizeInBytes(I);
           continue;
         }
         
         // Determine the offset from the current branch to the destination
         // block.
-        MachineBasicBlock *Dest = I->getOperand(2).getMachineBasicBlock();
+        MachineBasicBlock *Dest = I->getOperand(2).getMBB();
         
         int BranchSize;
         if (Dest->getNumber() <= MBB.getNumber()) {