fix2fix

Signed-off-by: Zhigang Gong <zhigang.gong@intel.com>

2 files changed, 30 insertions, 251 deletions

diff --git a/backend/src/CMakeLists.txt b/backend/src/CMakeLists.txt
index 47504822..85b5e21e 100644
--- a/backend/src/CMakeLists.txt
+++ b/backend/src/CMakeLists.txt
@@ -136,6 +136,8 @@ else (GBE_USE_BLOB)
     ir/printf.hpp
     ir/structural_analysis.cpp
     ir/structural_analysis.hpp
+    ir/immediate.hpp
+    ir/immediate.cpp
     backend/context.cpp
     backend/context.hpp
     backend/program.cpp
diff --git a/backend/src/ir/immediate.hpp b/backend/src/ir/immediate.hpp
index ea44d980..04fcf39e 100644
--- a/backend/src/ir/immediate.hpp
+++ b/backend/src/ir/immediate.hpp
@@ -18,7 +18,7 @@
  */
 
 /**
- * \file value.hpp
+ * \file Immediate.hpp
  *
  * \author Benjamin Segovia <benjamin.segovia@intel.com>
  */
@@ -67,17 +67,17 @@ namespace ir {
   class Immediate
   {
   public:
-    INLINE Immediate(void) {}
+    INLINE Immediate(void) { }
 
-    Type getType(void) const {
+    INLINE Type getType(void) const {
       return (Type)type;
     }
 
-    bool isCompType(void) const {
+    INLINE bool isCompType(void) const {
       return type == IMM_TYPE_COMP;
     }
 
-    uint32_t getElemNum(void) const {
+    INLINE uint32_t getElemNum(void) const {
       return elemNum;
     }
 
@@ -147,35 +147,9 @@ namespace ir {
     DECL_CONSTRUCTOR(double, f64, TYPE_DOUBLE, elemNum)
 #undef DECL_CONSTRUCTOR
 
-    Immediate(const vector<const Immediate*> immVec) {
-      if (immVec.size() == 1) {
-        *this = *immVec[0];
-      } else if (!(immVec[0]->isCompType()) && immVec[0]->elemNum == 1) {
-        this->type = immVec[0]->type;
-        this->elemNum = immVec.size();
-        if (immVec[0]->getTypeSize() * immVec.size() < 8)
-          this->data.p = &this->defaultData;
-        else
-          this->data.p = malloc(immVec[0]->getTypeSize() * immVec.size());
-        uint8_t *p = (uint8_t*)this->data.p;
-        for(uint32_t i = 0; i < immVec.size(); i++) {
-          GBE_ASSERT(immVec[i]->type == immVec[0]->type && immVec[i]->elemNum == 1);
-          memcpy(p, immVec[i]->data.p, immVec[i]->getTypeSize());
-          p += immVec[i]->getTypeSize();
-        }
-      } else {
-        this->type = IMM_TYPE_COMP;
-        if (immVec.size() * sizeof(Immediate*) < 8)
-          this->data.p = &this->defaultData;
-        else
-          this->data.p = malloc(immVec.size() * sizeof(Immediate*));
-        this->elemNum = immVec.size();
-        for(uint32_t i = 0; i < immVec.size(); i++)
-          this->data.immVec[i] = immVec[i];
-      }
-    }
+    Immediate(const vector<const Immediate*> immVec);
 
-    int64_t getIntegerValue(void) const {
+    INLINE int64_t getIntegerValue(void) const {
       switch (type) {
         default:
           GBE_ASSERT(0 && "Invalid immediate type.\n");
@@ -191,27 +165,27 @@ namespace ir {
       }
     }
 
-    float getFloatValue(void) const {
+    INLINE float getFloatValue(void) const {
       GBE_ASSERT(type == IMM_TYPE_FLOAT);
       return *data.f32;
     }
 
-    float asFloatValue(void) const {
+    INLINE float asFloatValue(void) const {
       GBE_ASSERT(type == IMM_TYPE_FLOAT || type == IMM_TYPE_U32 || type == IMM_TYPE_S32);
       return *data.f32;
     }
 
-    int64_t asIntegerValue(void) const {
+    INLINE int64_t asIntegerValue(void) const {
       GBE_ASSERT(elemNum == 1);
       return *data.s64;
     }
 
-    double getDoubleValue(void) const {
+    INLINE double getDoubleValue(void) const {
       GBE_ASSERT(type == IMM_TYPE_DOUBLE);
       return *data.f64;
     }
    
-    Immediate(const Immediate & other) {
+    INLINE Immediate(const Immediate & other) {
       *this = other;
     }
 
@@ -224,69 +198,7 @@ namespace ir {
       }
     }
 
-    Immediate(ImmOpCode op, const Immediate &left, const Immediate &right, Type dstType) {
-      switch (op) {
-        default:
-          GBE_ASSERT(0 && "unsupported imm op\n");
-        case IMM_ADD: *this = left + right; break;
-        case IMM_SUB: *this = left - right; break;
-        case IMM_MUL: *this = left * right; break;
-        case IMM_DIV: *this = left / right; break;
-        case IMM_AND: *this = left & right; break;
-        case IMM_OR:  *this = left | right; break;
-        case IMM_XOR: *this = left ^ right; break;
-        case IMM_REM:
-        {
-          if (left.getType() > TYPE_BOOL && left.getType() <= TYPE_U64)
-            *this = left % right;
-          else if (left.getType() == TYPE_FLOAT && right.getType() == TYPE_FLOAT) {
-            *this = Immediate(left);
-            *this->data.f32 = fmodf(left.getFloatValue(), right.getFloatValue());
-          }
-          else if (left.getType() == TYPE_DOUBLE && right.getType() == TYPE_DOUBLE) {
-            *this = Immediate(left);
-            *this->data.f64 += fmod(left.getDoubleValue(), right.getDoubleValue());
-          }
-          else
-            GBE_ASSERT(0);
-          break;
-        }
-        case IMM_LSHR:
-        {
-          if (left.getElemNum() == 1)
-            lshr(left, right);
-          else {
-            GBE_ASSERT(right.getIntegerValue() <= (left.getElemNum() * left.getTypeSize() * 8));
-            GBE_ASSERT(right.getIntegerValue() % (left.getTypeSize() * 8) == 0);
-            copy(left, right.getIntegerValue() / (left.getTypeSize() * 8), left.getElemNum());
-          }
-          break;
-        }
-        case IMM_ASHR:
-        {
-          if (left.getElemNum() == 1)
-            *this = left >> right;
-          else {
-            GBE_ASSERT(0 && "Doesn't support ashr on array constant.");
-            copy(left, right.getIntegerValue() / (left.getTypeSize() * 8), left.getElemNum());
-          }
-          break;
-        }
-        case IMM_SHL:
-        {
-          if (left.getElemNum() == 1)
-            *this = left << right;
-          else {
-            GBE_ASSERT(right.getIntegerValue() <= (left.getElemNum() * left.getTypeSize() * 8));
-            GBE_ASSERT(right.getIntegerValue() % (left.getTypeSize() * 8) == 0);
-            copy(left, -right.getIntegerValue() / (left.getTypeSize() * 8), left.getElemNum());
-          }
-          break;
-        }
-      }
-      // If the dst type is large int, we will not change the imm type to large int.
-      GBE_ASSERT(type == (ImmType)dstType || dstType == TYPE_LARGE_INT);
-    }
+    Immediate(ImmOpCode op, const Immediate &left, const Immediate &right, Type dstType);
 
     ~Immediate() {
       if (data.p != &defaultData) {
@@ -314,156 +226,21 @@ namespace ir {
     ImmType type;  //!< Type of the value
     uint32_t elemNum; //!< vector imm data type
     uint64_t defaultData;
-#define SCALAR_SAME_TYPE_ASSERT()                           \
-      GBE_ASSERT(this->getType() == right.getType()       && \
-                 this->getElemNum() == right.getElemNum() && \
-                 this->getElemNum() == 1                  && \
-                 this->getType() != TYPE_BOOL);
-
-#define DECLAR_BINARY_ALL_TYPE_OP(OP) \
-    Immediate operator OP (const Immediate &right) const { \
-      SCALAR_SAME_TYPE_ASSERT(); \
-      switch (this->getType()) { \
-        default: \
-          GBE_ASSERT(0); \
-        case TYPE_S8:     return Immediate(*this->data.s8 OP *right.data.s8);   \
-        case TYPE_U8:     return Immediate(*this->data.u8 OP *right.data.u8);   \
-        case TYPE_S16:    return Immediate(*this->data.s16 OP *right.data.s16); \
-        case TYPE_U16:    return Immediate(*this->data.u16 OP *right.data.u16); \
-        case TYPE_S32:    return Immediate(*this->data.s32 OP *right.data.s32); \
-        case TYPE_U32:    return Immediate(*this->data.u32 OP *right.data.u32); \
-        case TYPE_S64:    return Immediate(*this->data.s64 OP *right.data.s64); \
-        case TYPE_U64:    return Immediate(*this->data.u64 OP *right.data.u64); \
-        case TYPE_FLOAT:  return Immediate(*this->data.f32 OP *right.data.f32); \
-        case TYPE_DOUBLE: return Immediate(*this->data.f64 OP *right.data.f64); \
-      }\
-      return *this;\
-    }
-
-    DECLAR_BINARY_ALL_TYPE_OP(+)
-    DECLAR_BINARY_ALL_TYPE_OP(-)
-    DECLAR_BINARY_ALL_TYPE_OP(*)
-    DECLAR_BINARY_ALL_TYPE_OP(/)
-
-#undef DECLAR_BINARY_ALL_TYPE_OP
-
-#define DECLAR_BINARY_INT_TYPE_OP(OP) \
-    Immediate operator OP (const Immediate &right) const { \
-      SCALAR_SAME_TYPE_ASSERT(); \
-      switch (this->getType()) { \
-        default: \
-          GBE_ASSERT(0); \
-        case TYPE_S8:     return Immediate(*this->data.s8 OP *right.data.s8);   \
-        case TYPE_U8:     return Immediate(*this->data.u8 OP *right.data.u8);   \
-        case TYPE_S16:    return Immediate(*this->data.s16 OP *right.data.s16); \
-        case TYPE_U16:    return Immediate(*this->data.u16 OP *right.data.u16); \
-        case TYPE_S32:    return Immediate(*this->data.s32 OP *right.data.s32); \
-        case TYPE_U32:    return Immediate(*this->data.u32 OP *right.data.u32); \
-        case TYPE_S64:    return Immediate(*this->data.s64 OP *right.data.s64); \
-        case TYPE_U64:    return Immediate(*this->data.u64 OP *right.data.u64); \
-      }\
-      return *this;\
-    }
-    DECLAR_BINARY_INT_TYPE_OP(%)
-    DECLAR_BINARY_INT_TYPE_OP(&)
-    DECLAR_BINARY_INT_TYPE_OP(|)
-    DECLAR_BINARY_INT_TYPE_OP(^)
-#undef DECLAR_BINARY_INT_TYPE_OP
-
-
-#define DECLAR_BINARY_ASHIFT_OP(OP) \
-    Immediate operator OP (const Immediate &right) const { \
-      GBE_ASSERT(this->getType() > TYPE_BOOL && this->getType() <= TYPE_U64); \
-      int32_t shift = right.getIntegerValue(); \
-      if (shift == 0) \
-        return *this; \
-      else \
-        switch (this->getType()) { \
-          default: \
-            GBE_ASSERT(0); \
-          case TYPE_S8:  return Immediate((*this->data.s8 OP shift));  \
-          case TYPE_U8:  return Immediate((*this->data.u8 OP shift));  \
-          case TYPE_S16: return Immediate((*this->data.s16 OP shift)); \
-          case TYPE_U16: return Immediate((*this->data.u16 OP shift)); \
-          case TYPE_S32: return Immediate((*this->data.s32 OP shift)); \
-          case TYPE_U32: return Immediate((*this->data.u32 OP shift)); \
-          case TYPE_S64: return Immediate((*this->data.s64 OP shift)); \
-          case TYPE_U64: return Immediate((*this->data.u64 OP shift)); \
-        } \
-    }
-
-    DECLAR_BINARY_ASHIFT_OP(>>)
-    DECLAR_BINARY_ASHIFT_OP(<<)
-
-#undef DECLAR_BINARY_ASHIFT_OP
-
-    static Immediate lshr (const Immediate &left, const Immediate &right) {
-      GBE_ASSERT(left.getType() > TYPE_BOOL && left.getType() <= TYPE_U64);
-      int32_t shift = right.getIntegerValue();
-      if (shift == 0)
-        return left;
-      else
-        switch (left.getType()) {
-          default:
-            GBE_ASSERT(0);
-          case TYPE_S8:  
-          case TYPE_U8:  return Immediate((*left.data.u8 >> shift));
-          case TYPE_S16: 
-          case TYPE_U16: return Immediate((*left.data.u16 >> shift));
-          case TYPE_S32: 
-          case TYPE_U32: return Immediate((*left.data.u32 >> shift));
-          case TYPE_S64: 
-          case TYPE_U64: return Immediate((*left.data.u64 >> shift));
-        }
-    }
-
-    // operator = and copy() are only called from constructor functions
-    // which this never hold a memory pointer, we don't need to bother
-    // to check the data.p before assignment.
-    Immediate & operator= (const Immediate & other) {
-      if (this != &other) {
-        type = other.type;
-        elemNum = other.elemNum;
-        if (other.data.p != &other.defaultData) {
-          data.p = malloc(other.elemNum * other.getTypeSize());
-          memcpy(data.p, other.data.p, other.elemNum * other.getTypeSize());
-        }
-        else {
-          defaultData = other.defaultData;
-          data.p = &defaultData;
-        }
-      }
-      return *this;
-    }
-
-    void copy(const Immediate &other, int32_t offset, uint32_t num) {
-      if (this != &other) {
-        if (other.type == IMM_TYPE_COMP && num == 1) {
-          GBE_ASSERT(offset >= 0 && offset <= (int32_t)other.elemNum);
-          *this = *other.data.immVec[offset];
-          return;
-        }
-        type = other.type;
-        elemNum = num;
-        if (num * other.getTypeSize() < 8)
-          data.p = &defaultData;
-        else
-          data.p = malloc(num * other.getTypeSize());
-        uint8_t* datap = (uint8_t*)data.p;
-        memset(datap, 0, num * other.getTypeSize());
-        if (offset < 0) {
-          datap += (-offset) * other.getTypeSize();
-          num -= num < (uint32_t)(-offset) ? num : (-offset);
-          offset = 0;
-        } else if (offset > 0 && num > 1) {
-          GBE_ASSERT((int32_t)num > offset);
-          num -= offset;
-        }
-        memcpy(datap, (uint8_t*)other.data.p + offset * other.getTypeSize(),
-               num * other.getTypeSize());
-      }
-    }
-
+    Immediate & operator= (const Immediate &);
+    Immediate operator+ (const Immediate &) const; 
+    Immediate operator- (const Immediate &) const; 
+    Immediate operator* (const Immediate &) const; 
+    Immediate operator/ (const Immediate &) const; 
+    Immediate operator% (const Immediate &) const; 
+    Immediate operator& (const Immediate &) const; 
+    Immediate operator| (const Immediate &) const; 
+    Immediate operator^ (const Immediate &) const; 
+    Immediate operator<< (const Immediate &) const; 
+    Immediate operator>> (const Immediate &) const; 
+    static Immediate lshr (const Immediate &left, const Immediate &right);
+
+
+    void copy(const Immediate &other, int32_t offset, uint32_t num);
     GBE_CLASS(Immediate);
   };