1. Simplfy bit operations.

2. Coalesce instruction cases.


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

utils/TableGen/CodeEmitterGen.cpp

@@ -16,64 +16,58 @@
 #include "CodeEmitterGen.h"
 #include "CodeGenTarget.h"
 #include "Record.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
 using namespace llvm;
 
-void CodeEmitterGen::emitInstrOpBits(std::ostream &o,
+void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
-                                     const std::vector<RecordVal> &Vals,
+  for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end();
-                                     std::map<std::string, unsigned> &OpOrder,
+       I != E; ++I) {
-                                     std::map<std::string, bool> &OpContinuous)
+    Record *R = *I;
-{
+    if (R->getName() == "PHI" || R->getName() == "INLINEASM") continue;
-  for (unsigned f = 0, e = Vals.size(); f != e; ++f) {
+    
-    if (Vals[f].getPrefix()) {
+    BitsInit *BI = R->getValueAsBitsInit("Inst");
-      BitsInit *FieldInitializer = (BitsInit*)Vals[f].getValue();
 
-      // Scan through the field looking for bit initializers of the current
+    unsigned numBits = BI->getNumBits();
-      // variable...
+    BitsInit *NewBI = new BitsInit(numBits);
-      for (int i = FieldInitializer->getNumBits()-1; i >= 0; --i) {
+    for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
-        Init *I = FieldInitializer->getBit(i);
+      unsigned bitSwapIdx = numBits - bit - 1;
-        if (BitInit *BI = dynamic_cast<BitInit*>(I)) {
+      Init *OrigBit = BI->getBit(bit);
-          DEBUG(o << "      // bit init: f: " << f << ", i: " << i << "\n");
+      Init *BitSwap = BI->getBit(bitSwapIdx);
-        } else if (UnsetInit *UI = dynamic_cast<UnsetInit*>(I)) {
+      NewBI->setBit(bit, BitSwap);
-          DEBUG(o << "      // unset init: f: " << f << ", i: " << i << "\n");
+      NewBI->setBit(bitSwapIdx, OrigBit);
-        } else if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(I)) {
-          TypedInit *TI = VBI->getVariable();
-          if (VarInit *VI = dynamic_cast<VarInit*>(TI)) {
-            // If the bits of the field are laid out consecutively in the
-            // instruction, then instead of separately ORing in bits, just
-            // mask and shift the entire field for efficiency.
-            if (OpContinuous[VI->getName()]) {
-              // already taken care of in the loop above, thus there is no
-              // need to individually OR in the bits
-
-              // for debugging, output the regular version anyway, commented
-              DEBUG(o << "      // Value |= getValueBit(op"
-                      << OpOrder[VI->getName()] << ", " << VBI->getBitNum()
-                      << ")" << " << " << i << ";\n");
-            } else {
-              o << "      Value |= getValueBit(op" << OpOrder[VI->getName()]
-                << ", " << VBI->getBitNum()
-                << ")" << " << " << i << ";\n";
-            }
-          } else if (FieldInit *FI = dynamic_cast<FieldInit*>(TI)) {
-            // FIXME: implement this!
-            std::cerr << "Error: FieldInit not implemented!\n";
-            abort();
-          } else {
-            std::cerr << "Error: unimplemented case in "
-                      << "CodeEmitterGen::emitInstrOpBits()\n";
-            abort();
-          }
-        }
-      }
     }
+    if (numBits % 2) {
+      unsigned middle = (numBits + 1) / 2;
+      NewBI->setBit(middle, BI->getBit(middle));
+    }
+    
+    // Update the bits in reversed order so that emitInstrOpBits will get the
+    // correct endianness.
+    R->getValue("Inst")->setValue(NewBI);
   }
 }
 
 
+int CodeEmitterGen::getVariableBit(const std::string &VarName, BitsInit *BI, int bit){
+  if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) {
+    TypedInit *TI = VBI->getVariable();
+    
+    if (VarInit *VI = dynamic_cast<VarInit*>(TI)) {
+      if (VI->getName() == VarName) return VBI->getBitNum();
+    }
+  }
+  
+  return -1;
+} 
+
+
 void CodeEmitterGen::run(std::ostream &o) {
   CodeGenTarget Target;
   std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction");
+  
+  // For little-endian instruction bit encodings, reverse the bit order
+  if (Target.isLittleEndianEncoding()) reverseBits(Insts);
 
   EmitSourceFileHeader("Machine Code Emitter", o);
   std::string Namespace = Insts[0]->getValueAsString("Namespace") + "::";
@@ -103,28 +97,6 @@ void CodeEmitterGen::run(std::ostream &o) {
     
     BitsInit *BI = R->getValueAsBitsInit("Inst");
 
-    // For little-endian instruction bit encodings, reverse the bit order
-    if (Target.isLittleEndianEncoding()) {
-      unsigned numBits = BI->getNumBits();
-      BitsInit *NewBI = new BitsInit(numBits);
-      for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
-        unsigned bitSwapIdx = numBits - bit - 1;
-        Init *OrigBit = BI->getBit(bit);
-        Init *BitSwap = BI->getBit(bitSwapIdx);
-        NewBI->setBit(bit, BitSwap);
-        NewBI->setBit(bitSwapIdx, OrigBit);
-      }
-      if (numBits % 2) {
-        unsigned middle = (numBits + 1) / 2;
-        NewBI->setBit(middle, BI->getBit(middle));
-      }
-      BI = NewBI;
-      
-      // Update the bits in reversed order so that emitInstrOpBits will get the
-      // correct endianness.
-      R->getValue("Inst")->setValue(NewBI);
-    }
-
     unsigned Value = 0;
     const std::vector<RecordVal> &Vals = R->getValues();
 
@@ -137,136 +109,99 @@ void CodeEmitterGen::run(std::ostream &o) {
     o << "    " << Value << "U";
   }
   o << "\n  };\n";
-
+  
-  // Emit initial function code
+  // Map to accumulate all the cases.
-  o << "  const unsigned opcode = MI.getOpcode();\n"
+  std::map<std::string, std::vector<std::string> > CaseMap;
-    << "  unsigned Value = InstBits[opcode];\n"
+  
-    << "  switch (opcode) {\n";
+  // Construct all cases statement for each opcode
-
+  for (std::vector<Record*>::iterator IC = Insts.begin(), EC = Insts.end();
-  // Emit a case statement for each opcode
+        IC != EC; ++IC) {
-  for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end();
+    Record *R = *IC;
-       I != E; ++I) {
+    const std::string &InstName = R->getName();
-    Record *R = *I;
+    std::string Case("");
-    if (R->getName() == "PHI" || R->getName() == "INLINEASM") continue;
+    
+    if (InstName == "PHI" || InstName == "INLINEASM") continue;
     
-    o << "    case " << Namespace << R->getName() << ": {\n";
-
     BitsInit *BI = R->getValueAsBitsInit("Inst");
     const std::vector<RecordVal> &Vals = R->getValues();
 
     // Loop over all of the fields in the instruction, determining which are the
     // operands to the instruction.
     unsigned op = 0;
-    std::map<std::string, unsigned> OpOrder;
-    std::map<std::string, bool> OpContinuous;
     for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
       if (!Vals[i].getPrefix() && !Vals[i].getValue()->isComplete()) {
         // Is the operand continuous? If so, we can just mask and OR it in
         // instead of doing it bit-by-bit, saving a lot in runtime cost.
-        BitsInit *InstInit = BI;
+        const std::string &VarName = Vals[i].getName();
-        int beginBitInVar = -1, endBitInVar = -1;
+        bool gotOp = false;
-        int beginBitInInst = -1, endBitInInst = -1;
+        
-        bool continuous = true;
+        for (int bit = BI->getNumBits()-1; bit >= 0; ) {
-
+          int varBit = getVariableBit(VarName, BI, bit);
-        for (int bit = InstInit->getNumBits()-1; bit >= 0; --bit) {
+          
-          if (VarBitInit *VBI =
+          if (varBit == -1) {
-              dynamic_cast<VarBitInit*>(InstInit->getBit(bit))) {
+            --bit;
-            TypedInit *TI = VBI->getVariable();
+          } else {
-            if (VarInit *VI = dynamic_cast<VarInit*>(TI)) {
+            int beginInstBit = bit;
-              // only process the current variable
+            int beginVarBit = varBit;
-              if (VI->getName() != Vals[i].getName())
+            int N = 1;
-                continue;
+            
-
+            for (--bit; bit >= 0;) {
-              if (beginBitInVar == -1)
+              varBit = getVariableBit(VarName, BI, bit);
-                beginBitInVar = VBI->getBitNum();
+              if (varBit == -1 || varBit != (beginVarBit - N)) break;
-
+              ++N;
-              if (endBitInVar == -1)
+              --bit;
-                endBitInVar = VBI->getBitNum();
-              else {
-                if (endBitInVar == (int)VBI->getBitNum() + 1)
-                  endBitInVar = VBI->getBitNum();
-                else {
-                  continuous = false;
-                  break;
-                }
-              }
-
-              if (beginBitInInst == -1)
-                beginBitInInst = bit;
-              if (endBitInInst == -1)
-                endBitInInst = bit;
-              else {
-                if (endBitInInst == bit + 1)
-                  endBitInInst = bit;
-                else {
-                  continuous = false;
-                  break;
-                }
-              }
-
-              // maintain same distance between bits in field and bits in
-              // instruction. if the relative distances stay the same
-              // throughout,
-              if (beginBitInVar - (int)VBI->getBitNum() !=
-                  beginBitInInst - bit) {
-                continuous = false;
-                break;
-              }
-            }
-          }
-        }
-
-        // If we have found no bit in "Inst" which comes from this field, then
-        // this is not an operand!!
-        if (beginBitInInst != -1) {
-          o << "      // op" << op << ": " << Vals[i].getName() << "\n"
-            << "      int op" << op
-            <<" = getMachineOpValue(MI, MI.getOperand("<<op<<"));\n";
-          //<< "   MachineOperand &op" << op <<" = MI.getOperand("<<op<<");\n";
-          OpOrder[Vals[i].getName()] = op++;
-
-          DEBUG(o << "      // Var: begin = " << beginBitInVar
-                  << ", end = " << endBitInVar
-                  << "; Inst: begin = " << beginBitInInst
-                  << ", end = " << endBitInInst << "\n");
-
-          if (continuous) {
-            DEBUG(o << "      // continuous: op" << OpOrder[Vals[i].getName()]
-                    << "\n");
-
-            // Mask off the right bits
-            // Low mask (ie. shift, if necessary)
-            assert(endBitInVar >= 0 && "Negative shift amount in masking!");
-            if (endBitInVar != 0) {
-              o << "      op" << OpOrder[Vals[i].getName()]
-                << " >>= " << endBitInVar << ";\n";
-              beginBitInVar -= endBitInVar;
-              endBitInVar = 0;
             }
 
-            // High mask
+            if (!gotOp) {
-            o << "      op" << OpOrder[Vals[i].getName()]
+              Case += "      // op: " + VarName + "\n"
-              << " &= (1<<" << beginBitInVar+1 << ") - 1;\n";
+                   +  "      op = getMachineOpValue(MI, MI.getOperand("
-
+                   +  utostr(op++)
-            // Shift the value to the correct place (according to place in inst)
+                   +  "));\n";
-            assert(endBitInInst >= 0 && "Negative shift amount!");
+              gotOp = true;
-            if (endBitInInst != 0)
+            }
-              o << "      op" << OpOrder[Vals[i].getName()]
+            
-              << " <<= " << endBitInInst << ";\n";
+            unsigned opMask = (1 << N) - 1;
-
+            int opShift = beginVarBit - N + 1;
-            // Just OR in the result
+            opMask <<= opShift;
-            o << "      Value |= op" << OpOrder[Vals[i].getName()] << ";\n";
+            opShift = beginInstBit - beginVarBit;
+            
+            if (opShift > 0) {
+              Case += "      Value |= (op & " + utostr(opMask) + "U) << "
+                   +  itostr(opShift) + ";\n";
+            } else if (opShift < 0) {
+              Case += "      Value |= (op & " + utostr(opMask) + "U) >> "
+                   +  itostr(-opShift) + ";\n";
+            } else {
+              Case += "      Value |= op & " + utostr(opMask) + "U;\n";
+            }
           }
-
-          // otherwise, will be taken care of in the loop below using this
-          // value:
-          OpContinuous[Vals[i].getName()] = continuous;
         }
       }
     }
 
-    emitInstrOpBits(o, Vals, OpOrder, OpContinuous);
+    std::vector<std::string> &InstList =  CaseMap[Case];
+    InstList.push_back(InstName);
+  }
 
+
+  // Emit initial function code
+  o << "  const unsigned opcode = MI.getOpcode();\n"
+    << "  unsigned Value = InstBits[opcode];\n"
+    << "  unsigned op;\n"
+    << "  switch (opcode) {\n";
+
+  // Emit each case statement
+  std::map<std::string, std::vector<std::string> >::iterator IE, EE;
+  for (IE = CaseMap.begin(), EE = CaseMap.end(); IE != EE; ++IE) {
+    const std::string &Case = IE->first;
+    std::vector<std::string> &InstList = IE->second;
+
+    for (int i = 0, N = InstList.size(); i < N; i++) {
+      if (i) o << "\n";
+      o << "    case " << Namespace << InstList[i]  << ":";
+    }
+    o << " {\n";
+    o << Case;
     o << "      break;\n"
       << "    }\n";
   }

utils/TableGen/CodeEmitterGen.h

@@ -17,10 +17,12 @@
 #include "TableGenBackend.h"
 #include <map>
 #include <vector>
+#include <string>
 
 namespace llvm {
 
 class RecordVal;
+class BitsInit;
 
 class CodeEmitterGen : public TableGenBackend {
   RecordKeeper &Records;
@@ -32,10 +34,8 @@ public:
 private:
   void emitMachineOpEmitter(std::ostream &o, const std::string &Namespace);
   void emitGetValueBit(std::ostream &o, const std::string &Namespace);
-  void emitInstrOpBits(std::ostream &o,
+  void reverseBits(std::vector<Record*> &Insts);
-                       const std::vector<RecordVal> &Vals,
+  int getVariableBit(const std::string &VarName, BitsInit *BI, int bit);
-                       std::map<std::string, unsigned> &OpOrder,
-                       std::map<std::string, bool> &OpContinuous);
 };
 
 } // End llvm namespace