From 2c49b307dfb9fca7943632d5b9de704c036da4ba Mon Sep 17 00:00:00 2001
From: Benjamin Segovia <benjamin.segovia@intel.com>
Date: Fri, 2 Nov 2012 19:36:17 -0700
Subject: [PATCH] - Made ribbon test pass (still need to generate the golden
 image) - Fixed a corner case with the register allocator. Actually, the insn
 selection is able to remove dead code automatically. So, I handle this case
 now. - Added a first support for undef values in vectors in the llvm to gen
 IR compiler

---
 backend/src/backend/gen_insn_selection.cpp |  4 +++-
 backend/src/backend/gen_reg_allocation.cpp | 12 +++++++++++
 backend/src/llvm/llvm_gen_backend.cpp      | 32 ++++++++++++++++++++----------
 3 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/backend/src/backend/gen_insn_selection.cpp b/backend/src/backend/gen_insn_selection.cpp
index 6a9aa53..7117552 100644
--- a/backend/src/backend/gen_insn_selection.cpp
+++ b/backend/src/backend/gen_insn_selection.cpp
@@ -992,6 +992,7 @@ namespace gbe
       const GenRegister dst = sel.selReg(insn.getDst(0));
       const GenRegister src = sel.selReg(insn.getSrc(0));
       switch (opcode) {
+        case ir::OP_ABS: sel.MOV(dst, GenRegister::abs(src)); break;
         case ir::OP_MOV: sel.MOV(dst, src); break;
         case ir::OP_RNDD: sel.RNDD(dst, src); break;
         case ir::OP_RNDE: sel.RNDE(dst, src); break;
@@ -1504,7 +1505,7 @@ namespace gbe
       const Opcode opcode = insn.getOpcode();
       const Type type = insn.getType();
       const uint32_t genCmp = getGenCompare(opcode);
-      const Register dst  = insn.getDst(0);
+      const Register dst = insn.getDst(0);
       const GenRegister src0 = sel.selReg(insn.getSrc(0), type);
       const GenRegister src1 = sel.selReg(insn.getSrc(1), type);
 
@@ -1522,6 +1523,7 @@ namespace gbe
       sel.push();
         sel.curr.physicalFlag = 0;
         sel.curr.flagIndex = uint16_t(dst);
+        printf("%i\n",(int) dst);
         sel.CMP(genCmp, src0, src1);
       sel.pop();
       return true;
diff --git a/backend/src/backend/gen_reg_allocation.cpp b/backend/src/backend/gen_reg_allocation.cpp
index 56664d6..bbfb65e 100644
--- a/backend/src/backend/gen_reg_allocation.cpp
+++ b/backend/src/backend/gen_reg_allocation.cpp
@@ -253,12 +253,19 @@ namespace gbe
       const GenRegInterval *toExpire = this->ending[this->expiringID];
       const ir::Register reg = toExpire->reg;
 
+      // Dead code produced by the insn selection -> we skip it
+      if (toExpire->minID > toExpire->maxID) {
+        this->expiringID++;
+        continue;
+      }
+
       // Ignore booleans that were allocated with flags
       // if (ctx.getRegisterFamily(reg) == ir::FAMILY_BOOL && !grfBooleans.contains(reg)) {
       if (ctx.sel->getRegisterFamily(reg) == ir::FAMILY_BOOL) {
         this->expiringID++;
         continue;
       }
+
       if (toExpire->maxID >= limit.minID)
         return false;
       auto it = RA.find(reg);
@@ -326,6 +333,11 @@ namespace gbe
         while (endID != ending.size()) {
           const GenRegInterval *toExpire = this->ending[endID];
           const ir::Register reg = toExpire->reg;
+          // Dead code produced by the insn selection -> we skip it
+          if (toExpire->minID > toExpire->maxID) {
+            endID++;
+            continue;
+          }
           // We cannot expire this interval and the next ones
           if (toExpire->maxID >= interval.minID)
             break;
diff --git a/backend/src/llvm/llvm_gen_backend.cpp b/backend/src/llvm/llvm_gen_backend.cpp
index 19719a9..61c2435 100644
--- a/backend/src/llvm/llvm_gen_backend.cpp
+++ b/backend/src/llvm/llvm_gen_backend.cpp
@@ -470,6 +470,17 @@ namespace gbe
     return false;
   }
 
+  static Constant *extractConstantElem(Constant *CPV, uint32_t index) {
+    ConstantVector *CV = dyn_cast<ConstantVector>(CPV);
+    GBE_ASSERT(CV != NULL);
+#if GBE_DEBUG
+    const uint32_t elemNum = CV->getNumOperands();
+    GBE_ASSERTM(index < elemNum, "Out-of-bound constant vector access");
+#endif /* GBE_DEBUG */
+    CPV = cast<Constant>(CV->getOperand(index));
+    return CPV;
+  }
+
   template <typename U, typename T>
   static U processConstant(Constant *CPV, T doIt, uint32_t index = 0u)
   {
@@ -478,13 +489,8 @@ namespace gbe
     else if (isa<UndefValue>(CPV) && CPV->getType()->isSingleValueType())
       GBE_ASSERTM(false, "Unsupported constant expression");
 
-    if (ConstantVector *CV = dyn_cast<ConstantVector>(CPV)) {
-#if GBE_DEBUG
-      const uint32_t elemNum = CV->getNumOperands();
-      GBE_ASSERTM(index < elemNum, "Out-of-bound constant vector access");
-#endif /* GBE_DEBUG */
-      CPV = cast<Constant>(CV->getOperand(index));
-    }
+    if (dyn_cast<ConstantVector>(CPV))
+      CPV = extractConstantElem(CPV, index);
 
     // Integers
     if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
@@ -516,6 +522,8 @@ namespace gbe
       case Type::DoubleTyID:
       {
         ConstantFP *FPC = cast<ConstantFP>(CPV);
+        GBE_ASSERT(isa<UndefValue>(CPV) == false);
+
         if (FPC->getType() == Type::getFloatTy(CPV->getContext())) {
           const float f32 = FPC->getValueAPF().convertToFloat();
           return doIt(f32);
@@ -1231,10 +1239,12 @@ namespace gbe
       for (uint32_t elemID = 0; elemID < elemNum; ++elemID)
         if (elemID != modifiedID) {
           Constant *sourceCPV = dyn_cast<Constant>(modified);
-          const ir::ImmediateIndex immIndex = this->newImmediate(sourceCPV, elemID);
-          const ir::Immediate imm = ctx.getImmediate(immIndex);
-          const ir::Register reg = regTranslator.getScalar(&I, elemID);
-          ctx.LOADI(imm.type, reg, immIndex);
+          if (isa<UndefValue>(extractConstantElem(sourceCPV, elemID)) == false) {
+            const ir::ImmediateIndex immIndex = this->newImmediate(sourceCPV, elemID);
+            const ir::Immediate imm = ctx.getImmediate(immIndex);
+            const ir::Register reg = regTranslator.getScalar(&I, elemID);
+            ctx.LOADI(imm.type, reg, immIndex);
+          }
         }
     }
 
-- 
2.7.4