Remove newValueProxy from scalarize pass to genWriter pass.

If call newValueProxy in scalarize pass, the realValue maybe been deleted by
the following pass, cause assert. Move to genWriter pass, can fix this bug and
make code more clean.

Signed-off-by: Yang Rong <rong.r.yang@intel.com>
Reviewed-by: Zhigang Gong <zhigang.gong@linux.intel.com>

diff --git a/backend/src/ir/unit.hpp b/backend/src/ir/unit.hpp
index 9e3d66a..d8eab79 100644 (file)
--- a/backend/src/ir/unit.hpp
+++ b/backend/src/ir/unit.hpp
@@ -42,7 +42,6 @@ namespace ir {
   {
   public:
     typedef hash_map<std::string, Function*> FunctionSet;
-    typedef std::pair<void*, uint32_t> ValueIndex;
     /*! Create an empty unit */
     Unit(PointerSize pointerSize = POINTER_32_BITS);
     /*! Release everything (*including* the function pointers) */
@@ -73,30 +72,11 @@ namespace ir {
     ConstantSet& getConstantSet(void) { return constantSet; }
     /*! Return the constant set */
     const ConstantSet& getConstantSet(void) const { return constantSet; }
-
-    /*! Some values will not be allocated. For example a vector extract and
-     * a vector insertion when scalarize the vector load/store
-     */
-    void newValueProxy(void *real,
-                       void *fake,
-                       uint32_t realIndex = 0u,
-                       uint32_t fakeIndex = 0u) {
-      const ValueIndex key(fake, fakeIndex);
-      const ValueIndex value(real, realIndex);
-      GBE_ASSERT(valueMap.find(key) == valueMap.end()); // Do not insert twice
-      valueMap[key] = value;
-    }
-
-    void clearValueMap() { valueMap.clear(); }
-
-    /*! Return the value map */
-    const map<ValueIndex, ValueIndex> &getValueMap(void) const { return valueMap; }
   private:
     friend class ContextInterface; //!< Can free modify the unit
     hash_map<std::string, Function*> functions; //!< All the defined functions
     ConstantSet constantSet; //!< All the constants defined in the unit
     PointerSize pointerSize; //!< Size shared by all pointers
-    map<ValueIndex, ValueIndex> valueMap; //!< fake to real value map for vector load/store
     GBE_CLASS(Unit);
   };
 

diff --git a/backend/src/llvm/llvm_gen_backend.cpp b/backend/src/llvm/llvm_gen_backend.cpp
index 7519ff1..ea34675 100644 (file)
--- a/backend/src/llvm/llvm_gen_backend.cpp
+++ b/backend/src/llvm/llvm_gen_backend.cpp
@@ -305,13 +305,6 @@ namespace gbe
       GBE_ASSERT(valueMap.find(key) == valueMap.end()); // Do not insert twice
       valueMap[key] = value;
     }
-    /*! After scalarize pass, there are some valueMap in unit,
-     *  use this function to copy from unit valueMap */
-    void initValueMap(const map<ir::Unit::ValueIndex, ir::Unit::ValueIndex> &vMap) {
-      for(auto &it : vMap)
-        newValueProxy((Value*)it.second.first, (Value*)it.first.first,
-                      it.second.second, it.first.second);
-    }
     /*! Mostly used for the preallocated registers (lids, gids) */
     void newScalarProxy(ir::Register reg, Value *value, uint32_t index = 0u) {
       const ValueIndex key(value, index);
@@ -1362,7 +1355,6 @@ namespace gbe
 
     ctx.startFunction(F.getName());
     this->regTranslator.clear();
-    this->regTranslator.initValueMap(unit.getValueMap());
     this->labelMap.clear();
     this->emitFunctionPrototype(F);
 
@@ -1685,10 +1677,34 @@ namespace gbe
   /*! Because there are still fake insert/extract instruction for
    *  load/store, so keep empty function here */
   void GenWriter::regAllocateInsertElement(InsertElementInst &I) {}
-  void GenWriter::emitInsertElement(InsertElementInst &I) {}
+  void GenWriter::emitInsertElement(InsertElementInst &I) {
+    const VectorType *type = dyn_cast<VectorType>(I.getType());
+    GBE_ASSERT(type);
+    const int elemNum = type->getNumElements();
+
+    Value *vec = I.getOperand(0);
+    Value *value = I.getOperand(1);
+    const Value *index = I.getOperand(2);
+    const ConstantInt *c = dyn_cast<ConstantInt>(index);
+    int i = c->getValue().getSExtValue();
+
+    for(int j=0; j<elemNum; j++) {
+      if(i == j)
+        regTranslator.newValueProxy(value, &I, 0, i);
+      else
+        regTranslator.newValueProxy(vec, &I, j, j);
+    }
+  }
 
   void GenWriter::regAllocateExtractElement(ExtractElementInst &I) {}
-  void GenWriter::emitExtractElement(ExtractElementInst &I) {}
+  void GenWriter::emitExtractElement(ExtractElementInst &I) {
+    Value *vec = I.getVectorOperand();
+    const Value *index = I.getIndexOperand();
+    const ConstantInt *c = dyn_cast<ConstantInt>(index);
+    GBE_ASSERT(c);
+    int i = c->getValue().getSExtValue();
+    regTranslator.newValueProxy(vec, &I, i, 0);
+  }
 
   void GenWriter::regAllocateShuffleVectorInst(ShuffleVectorInst &I) {}
   void GenWriter::emitShuffleVectorInst(ShuffleVectorInst &I) {}

diff --git a/backend/src/llvm/llvm_gen_backend.hpp b/backend/src/llvm/llvm_gen_backend.hpp
index d6c98dd..55079f5 100644 (file)
--- a/backend/src/llvm/llvm_gen_backend.hpp
+++ b/backend/src/llvm/llvm_gen_backend.hpp
@@ -84,7 +84,7 @@ namespace gbe
   /*! Remove the GEP instructions */
   llvm::BasicBlockPass *createRemoveGEPPass(const ir::Unit &unit);
 
-  llvm::FunctionPass* createScalarizePass(ir::Unit &unit);
+  llvm::FunctionPass* createScalarizePass();
 
 } /* namespace gbe */
 

diff --git a/backend/src/llvm/llvm_scalarize.cpp b/backend/src/llvm/llvm_scalarize.cpp
index edfc369..a29bc59 100644 (file)
--- a/backend/src/llvm/llvm_scalarize.cpp
+++ b/backend/src/llvm/llvm_scalarize.cpp
@@ -92,7 +92,6 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include "llvm/llvm_gen_backend.hpp"
-#include "ir/unit.hpp"
 #include "sys/map.hpp"
 
 
@@ -126,7 +125,7 @@ namespace gbe {
     // Standard pass stuff
     static char ID;
 
-    Scalarize(ir::Unit& unit) : FunctionPass(ID), unit(unit)
+    Scalarize() : FunctionPass(ID)
     {
       initializeLoopInfoPass(*PassRegistry::getPassRegistry());
       initializeDominatorTreePass(*PassRegistry::getPassRegistry());
@@ -228,7 +227,6 @@ namespace gbe {
 
     Type* intTy;
     Type* floatTy;
-    ir::Unit &unit;
 
     std::vector<Instruction*> deadList;
 
@@ -598,14 +596,11 @@ namespace gbe {
       Value *cv = ConstantInt::get(intTy, i);
       Value *EI = builder->CreateExtractElement(insn, cv);
       vVals.setComponent(i, EI);
-      //unit.fakeInsnMap[EI] = insn;
-      unit.newValueProxy(insn, EI, i, 0);
     }
   }
 
   Value* Scalarize::InsertToVector(Value * insn, Value* vecValue) {
     //VectorValues& vVals = vectorVals[writeValue];
-    //unit.vecValuesMap[call] = vectorVals[writeValue];
 
     //add fake insert instructions to avoid removed
     Value *II = NULL;
@@ -613,14 +608,8 @@ namespace gbe {
       Value *vec = II ? II : UndefValue::get(vecValue->getType());
       Value *cv = ConstantInt::get(intTy, i);
       II = builder->CreateInsertElement(vec, getComponent(i, vecValue), cv);
-      //unit.vecValuesMap[insn].setComponent(i, getComponent(i, writeValue));
-      //unit.newValueProxy(getComponent(i, vecValue), vecValue, 0, i);
-      //unit.fakeInsnMap[II] = insn;
     }
 
-    for (int i = 0; i < GetComponentCount(vecValue); ++i) {
-      unit.newValueProxy(getComponent(i, vecValue), II, 0, i);
-    }
     return II;
   }
 
@@ -776,7 +765,6 @@ namespace gbe {
     intTy = IntegerType::get(module->getContext(), 32);
     floatTy = Type::getFloatTy(module->getContext());
     builder = new IRBuilder<>(module->getContext());
-    unit.clearValueMap();
 
     scalarizeArgs(F);
     typedef ReversePostOrderTraversal<Function*> RPOTType;
@@ -848,9 +836,9 @@ namespace gbe {
   {
       return;
   }
-  FunctionPass* createScalarizePass(ir::Unit &unit)
+  FunctionPass* createScalarizePass()
   {
-      return new Scalarize(unit);
+    return new Scalarize();
   }
   char Scalarize::ID = 0;
 

diff --git a/backend/src/llvm/llvm_to_gen.cpp b/backend/src/llvm/llvm_to_gen.cpp
index 788a3dd..111514f 100644 (file)
--- a/backend/src/llvm/llvm_to_gen.cpp
+++ b/backend/src/llvm/llvm_to_gen.cpp
@@ -80,7 +80,7 @@ namespace gbe
     // Print the code before further optimizations
     if (OCL_OUTPUT_LLVM_BEFORE_EXTRA_PASS)
       passes.add(createPrintModulePass(&*o));
-    passes.add(createScalarizePass(unit));        // Expand all vector ops
+    passes.add(createScalarizePass());        // Expand all vector ops
     passes.add(createScalarReplAggregatesPass()); // Break up allocas
     passes.add(createRemoveGEPPass(unit));
     passes.add(createConstantPropagationPass());