diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h
index 2902c64..1335e97 100644
--- a/src/include/midend/IR.h
+++ b/src/include/midend/IR.h
@@ -1061,12 +1061,10 @@ class UncondBrInst : public Instruction {
   friend class Function;
 
 protected:
-  UncondBrInst(BasicBlock *block, std::vector<Value *> args,
+  UncondBrInst(BasicBlock *block,
                BasicBlock *parent = nullptr)
       : Instruction(kBr, Type::getVoidType(), parent, "") {
-    // assert(block->getNumArguments() == args.size());
     addOperand(block);
-    addOperands(args);
   }
 
 public:
@@ -1095,17 +1093,12 @@ class CondBrInst : public Instruction {
   friend class Function;
   
 protected:
-  CondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock,
-             const std::vector<Value *> &thenArgs,
-             const std::vector<Value *> &elseArgs, BasicBlock *parent = nullptr)
+  CondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock, 
+              BasicBlock *parent = nullptr)
       : Instruction(kCondBr, Type::getVoidType(), parent, "") {
-    // assert(thenBlock->getNumArguments() == thenArgs.size() and
-    //        elseBlock->getNumArguments() == elseArgs.size());
     addOperand(condition);
     addOperand(thenBlock);
     addOperand(elseBlock);
-    addOperands(thenArgs);
-    addOperands(elseArgs);
   }
 public:
   Value* getCondition() const { return getOperand(0); }
@@ -1129,17 +1122,6 @@ public:
     }
     return succs;
   }
-  // auto getThenArguments() const {
-  //   auto begin = std::next(operand_begin(), 3);
-  //   // auto end = std::next(begin, getThenBlock()->getNumArguments());
-  //   return make_range(begin, end);
-  // }
-  // auto getElseArguments() const {
-  //   auto begin =
-  //       std::next(operand_begin(), 3 + getThenBlock()->getNumArguments());
-  //   auto end = operand_end();
-  //   return make_range(begin, end);
-  // }
 
 }; // class CondBrInst
 
@@ -1156,10 +1138,9 @@ class AllocaInst : public Instruction {
   friend class IRBuilder;
   friend class Function;
 protected:
-  AllocaInst(Type *type, const std::vector<Value *> &dims = {},
+  AllocaInst(Type *type,
              BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kAlloca, type, parent, name) {
-    addOperands(dims);
   }
 
 public:
@@ -1168,8 +1149,6 @@ public:
     return getType()->as<PointerType>()->getBaseType();
   }  ///< 获取分配的类型
   int getNumDims() const { return getNumOperands(); }
-  auto getDims() const { return getOperands(); }
-  Value* getDim(int index) { return getOperand(index); }
 
 }; // class AllocaInst
 
@@ -1216,12 +1195,11 @@ class LoadInst : public Instruction {
   friend class Function;
 
 protected:
-  LoadInst(Value *pointer, const std::vector<Value *> &indices = {},
+  LoadInst(Value *pointer,
            BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kLoad, pointer->getType()->as<PointerType>()->getBaseType(),
                     parent, name) {
     addOperand(pointer);
-    addOperands(indices);
   }
 
 public:
@@ -1241,22 +1219,15 @@ class StoreInst : public Instruction {
 
 protected:
   StoreInst(Value *value, Value *pointer,
-            const std::vector<Value *> &indices = {},
             BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kStore, Type::getVoidType(), parent, name) {
     addOperand(value);
     addOperand(pointer);
-    addOperands(indices);
   }
 
 public:
-  int getNumIndices() const { return getNumOperands() - 2; }
   Value* getValue() const { return getOperand(0); }
   Value* getPointer() const { return getOperand(1); }
-  auto getIndices() const {
-    return make_range(std::next(operand_begin(), 2), operand_end());
-  }
-  Value* getIndex(int index) const { return getOperand(index + 2); }
 
 }; // class StoreInst
 
@@ -1395,20 +1366,18 @@ protected:
 
 protected:
   GlobalValue(Module *parent, Type *type, const std::string &name,
-              const std::vector<Value *> &dims = {}, 
               ValueCounter init = {})
       : Value(type, name), parent(parent) {
     assert(type->isPointer());
-    // addOperands(dims); 
     // 维度信息已经被记录到Type中，dim只是为了方便初始化
-    numDims = dims.size();
+    numDims = 0;
     if (init.size() == 0) {
       unsigned num = 1;
-      for (unsigned i = 0; i < numDims; i++) {
-        // Assume dims elements are ConstantInteger and cast appropriately
-        auto dim_val = dynamic_cast<ConstantInteger*>(dims[i]);
-        assert(dim_val && "GlobalValue dims must be constant integers");
-        num *= dim_val->getInt();
+      auto arrayType = type->as<ArrayType>();
+      while (arrayType) {
+        numDims++;
+        num *= arrayType->getNumElements();
+        arrayType = arrayType->getElementType()->as<ArrayType>();
       }
       if (dynamic_cast<PointerType *>(type)->getBaseType() == Type::getFloatType()) {
         init.push_back(ConstantFloating::get(0.0F), num); // Use new constant factory
@@ -1420,9 +1389,6 @@ protected:
   }
 
 public:
-  // unsigned getNumDims() const  { return numDims; }                     ///< 获取维度数量
-  // Value* getDim(unsigned index) const { return getOperand(index); }  ///< 获取位置为index的维度
-  // auto getDims() const { return getOperands(); }                              ///< 获取维度列表
   unsigned getNumIndices() const {
     return numDims;
   } ///< 获取维度数量
@@ -1464,13 +1430,19 @@ class ConstantVariable : public Value {
   ValueCounter initValues;  ///< 值
 
  protected:
-  ConstantVariable(Module *parent, Type *type, const std::string &name, const ValueCounter &init,
-                   const std::vector<Value *> &dims = {})
+  ConstantVariable(Module *parent, Type *type, const std::string &name, const ValueCounter &init)
       : Value(type, name), parent(parent) {
     assert(type->isPointer());
-    numDims = dims.size();
+    // numDims = dims.size();
+    numDims = 0;
+    if(type->as<PointerType>()->getBaseType()->isArray()) {
+      auto arrayType = type->as<ArrayType>();
+      while (arrayType) {
+        numDims++;
+        arrayType = arrayType->getElementType()->as<ArrayType>();
+      }
+    }
     initValues = init;
-    // addOperands(dims); 同GlobalValue，维度信息已经被记录到Type中，dim只是为了方便初始化
   }
 
  public:
@@ -1563,13 +1535,12 @@ class Module {
     return result.first->second.get();
   }  ///< 创建外部函数
   ///< 变量创建伴随着符号表的更新
-  GlobalValue* createGlobalValue(const std::string &name, Type *type, const std::vector<Value *> &dims = {},
-                         const ValueCounter &init = {}) {
+  GlobalValue* createGlobalValue(const std::string &name, Type *type, const ValueCounter &init = {}) {
     bool isFinished = variableTable.isCurNodeNull();
     if (isFinished) {
       variableTable.enterGlobalScope();
     }
-    auto result = variableTable.addVariable(name, new GlobalValue(this, type, name, dims, init));
+    auto result = variableTable.addVariable(name, new GlobalValue(this, type, name, init));
     if (isFinished) {
       variableTable.leaveScope();
     }
@@ -1578,9 +1549,8 @@ class Module {
     }
     return dynamic_cast<GlobalValue *>(result);
   }  ///< 创建全局变量
-  ConstantVariable* createConstVar(const std::string &name, Type *type, const ValueCounter &init,
-                      const std::vector<Value *> &dims = {}) {
-    auto result = variableTable.addVariable(name, new ConstantVariable(this, type, name, init, dims));
+  ConstantVariable* createConstVar(const std::string &name, Type *type, const ValueCounter &init) {
+    auto result = variableTable.addVariable(name, new ConstantVariable(this, type, name, init));
     if (result == nullptr) {
       return nullptr;
     }
diff --git a/src/include/midend/IRBuilder.h b/src/include/midend/IRBuilder.h
index f761d57..5cbf096 100644
--- a/src/include/midend/IRBuilder.h
+++ b/src/include/midend/IRBuilder.h
@@ -239,15 +239,14 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建return指令
-  UncondBrInst * createUncondBrInst(BasicBlock *thenBlock, const std::vector<Value *> &args = {}) {
-    auto inst = new UncondBrInst(thenBlock, args, block);
+  UncondBrInst * createUncondBrInst(BasicBlock *thenBlock) {
+    auto inst = new UncondBrInst(thenBlock, block);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建无条件指令
-  CondBrInst * createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock,
-                        const std::vector<Value *> &thenArgs = {}, const std::vector<Value *> &elseArgs = {}) {
-    auto inst = new CondBrInst(condition, thenBlock, elseBlock, thenArgs, elseArgs, block);
+  CondBrInst * createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock) {
+    auto inst = new CondBrInst(condition, thenBlock, elseBlock, block);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
@@ -258,18 +257,12 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建不可达指令
-  AllocaInst * createAllocaInst(Type *type, const std::vector<Value *> &dims = {}, const std::string &name = "") {
-    auto inst = new AllocaInst(type, dims, block, name);
+  AllocaInst * createAllocaInst(Type *type, const std::string &name = "") {
+    auto inst = new AllocaInst(type, block, name);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建分配指令
-  AllocaInst * createAllocaInstWithoutInsert(Type *type, const std::vector<Value *> &dims = {}, BasicBlock *parent = nullptr,
-                                     const std::string &name = "") {
-    auto inst = new AllocaInst(type, dims, parent, name);
-    assert(inst);
-    return inst;
-  }  ///< 创建不插入指令列表的分配指令[仅用于phi指令]
   LoadInst * createLoadInst(Value *pointer, const std::vector<Value *> &indices = {}, const std::string &name = "") {
     std::string newName;
     if (name.empty()) {
@@ -281,7 +274,7 @@ class IRBuilder {
       newName = name;
     }
 
-    auto inst = new LoadInst(pointer, indices, block, newName);
+    auto inst = new LoadInst(pointer, block, newName);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
@@ -292,9 +285,8 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建memset指令
-  StoreInst * createStoreInst(Value *value, Value *pointer, const std::vector<Value *> &indices = {},
-                       const std::string &name = "") {
-    auto inst = new StoreInst(value, pointer, indices, block, name);
+  StoreInst * createStoreInst(Value *value, Value *pointer, const std::string &name = "") {
+    auto inst = new StoreInst(value, pointer, block, name);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
@@ -314,24 +306,6 @@ class IRBuilder {
     block->getInstructions().emplace(block->begin(), inst);
     return inst;
   }  ///< 创建Phi指令
-  // GetElementPtrInst* createGetElementPtrInst(Value *basePointer,
-  //                                const std::vector<Value *> &indices = {},
-  //                                const std::string &name = "") {
-  //   std::string newName;
-  //   if (name.empty()) {
-  //     std::stringstream ss;
-  //     ss << tmpIndex;
-  //     newName = ss.str();
-  //     tmpIndex++;
-  //   } else {
-  //     newName = name;
-  //   }
-
-  //   auto inst = new GetElementPtrInst(basePointer, indices, block, newName);
-  //   assert(inst);
-  //   block->getInstructions().emplace(position, inst);
-  //   return inst;
-  // }
   /**
      * @brief 根据 LLVM 设计模式创建 GEP 指令。
      * 它会自动推断返回类型，无需手动指定。
diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp
index 1b32eaf..2cc34dc 100644
--- a/src/midend/IR.cpp
+++ b/src/midend/IR.cpp
@@ -227,9 +227,10 @@ Function * Function::clone(const std::string &suffix) const  {
           auto oldAllocInst = dynamic_cast<AllocaInst *>(value);
           if (oldAllocInst != nullptr) {
             std::vector<Value *> dims;
-            for (const auto &dim : oldAllocInst->getDims()) {
-              dims.emplace_back(dim->getValue());
-            }
+            // TODO: 这里的dims用type推断
+            // for (const auto &dim : oldAllocInst->getDims()) {
+            //   dims.emplace_back(dim->getValue());
+            // }
             ss << oldAllocInst->getName() << suffix;
             auto newAllocInst =
                 new AllocaInst(oldAllocInst->getType(), dims, oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
@@ -252,9 +253,10 @@ Function * Function::clone(const std::string &suffix) const  {
         if (oldNewValueMap.find(inst.get()) == oldNewValueMap.end()) {
           auto oldAllocInst = dynamic_cast<AllocaInst *>(inst.get());
           std::vector<Value *> dims;
-          for (const auto &dim : oldAllocInst->getDims()) {
-            dims.emplace_back(dim->getValue());
-          }
+          // TODO: 这里的dims用type推断
+          // for (const auto &dim : oldAllocInst->getDims()) {
+          //   dims.emplace_back(dim->getValue());
+          // }
           ss << oldAllocInst->getName() << suffix;
           auto newAllocInst =
               new AllocaInst(oldAllocInst->getType(), dims, oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
@@ -422,7 +424,7 @@ Function * Function::clone(const std::string &suffix) const  {
         Value *newCond;
         newCond = oldNewValueMap.at(oldCond);
         auto newCondBrInst = new CondBrInst(newCond, oldNewBlockMap.at(oldCondBrInst->getThenBlock()),
-                                            oldNewBlockMap.at(oldCondBrInst->getElseBlock()), {}, {},
+                                            oldNewBlockMap.at(oldCondBrInst->getElseBlock()),
                                             oldNewBlockMap.at(oldCondBrInst->getParent()));
         oldNewValueMap.emplace(oldCondBrInst, newCondBrInst);
         break;
@@ -431,7 +433,7 @@ Function * Function::clone(const std::string &suffix) const  {
       case Instruction::kBr: {
         auto oldBrInst = dynamic_cast<UncondBrInst *>(inst);
         auto newBrInst =
-            new UncondBrInst(oldNewBlockMap.at(oldBrInst->getBlock()), {}, oldNewBlockMap.at(oldBrInst->getParent()));
+            new UncondBrInst(oldNewBlockMap.at(oldBrInst->getBlock()), oldNewBlockMap.at(oldBrInst->getParent()));
         oldNewValueMap.emplace(oldBrInst, newBrInst);
         break;
       }
@@ -464,7 +466,8 @@ Function * Function::clone(const std::string &suffix) const  {
           newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
         }
         ss << oldLoadInst->getName() << suffix;
-        auto newLoadInst = new LoadInst(newPointer, newIndices, oldNewBlockMap.at(oldLoadInst->getParent()), ss.str());
+        // TODO : 这里的newLoadInst的类型需要根据oldLoadInst的类型来推断
+        auto newLoadInst = new LoadInst(newPointer, oldNewBlockMap.at(oldLoadInst->getParent()), ss.str());
         ss.str("");
         oldNewValueMap.emplace(oldLoadInst, newLoadInst);
         break;
@@ -479,9 +482,10 @@ Function * Function::clone(const std::string &suffix) const  {
         std::vector<Value *> newIndices;
         newPointer = oldNewValueMap.at(oldPointer);
         newValue = oldNewValueMap.at(oldValue);
-        for (const auto &index : oldStoreInst->getIndices()) {
-          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
-        }
+        // TODO: 这里的newIndices需要根据oldStoreInst的类型来推断
+        // for (const auto &index : oldStoreInst->getIndices()) {
+        //   newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
+        // }
         auto newStoreInst = new StoreInst(newValue, newPointer, newIndices,
                                           oldNewBlockMap.at(oldStoreInst->getParent()), oldStoreInst->getName());
         oldNewValueMap.emplace(oldStoreInst, newStoreInst);
diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp
index 03f382b..64d0d92 100644
--- a/src/midend/SysYIRGenerator.cpp
+++ b/src/midend/SysYIRGenerator.cpp
@@ -98,7 +98,7 @@ std::any SysYIRGenerator::visitGlobalConstDecl(SysYParser::GlobalConstDeclContex
     if (!dims.empty()) { // 如果有维度，说明是数组
         variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
     }
-    module->createConstVar(name, Type::getPointerType(variableType), values, dims);
+    module->createConstVar(name, Type::getPointerType(variableType), values);
   }
   return std::any();
 }
@@ -127,7 +127,7 @@ std::any SysYIRGenerator::visitGlobalVarDecl(SysYParser::GlobalVarDeclContext *c
     if (!dims.empty()) { // 如果有维度，说明是数组
         variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
     }
-    module->createGlobalValue(name, Type::getPointerType(variableType), dims, values);
+    module->createGlobalValue(name, Type::getPointerType(variableType), values);
   }
   return std::any();
 }
@@ -151,7 +151,7 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
 
     // 显式地为局部常量在栈上分配空间
     // alloca 的类型将是指针指向常量类型，例如 `int*` 或 `int[2][3]*`
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), {}, name);
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
 
     ArrayValueTree *root = std::any_cast<ArrayValueTree *>(constDef->constInitVal()->accept(this));
     ValueCounter values;
@@ -272,7 +272,7 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
     // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
     // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
     AllocaInst* alloca =
-        builder.createAllocaInst(Type::getPointerType(variableType), {}, name);
+        builder.createAllocaInst(Type::getPointerType(variableType), name);
 
     if (varDef->initVal() != nullptr) {
       ValueCounter values;
@@ -510,7 +510,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   auto funcArgs = function->getArguments();
   std::vector<AllocaInst *> allocas;
   for (int i = 0; i < paramActualTypes.size(); ++i) {
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), {}, paramNames[i]);
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), paramNames[i]);
     allocas.push_back(alloca);
     module->addVariable(paramNames[i], alloca);
   }
@@ -525,7 +525,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   BasicBlock* funcBodyEntry = function->addBasicBlock("funcBodyEntry_" + name);
   
   // 从 entryBB 无条件跳转到 funcBodyEntry
-  builder.createUncondBrInst(funcBodyEntry, {});
+  builder.createUncondBrInst(funcBodyEntry);
   builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
 
   for (auto item : ctx->blockStmt()->blockItem()) {
@@ -690,7 +690,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(0)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock, {});
+    builder.createUncondBrInst(exitBlock);
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_else.L" << builder.getLabelIndex();
@@ -707,7 +707,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(1)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock, {});
+    builder.createUncondBrInst(exitBlock);
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_exit.L" << builder.getLabelIndex();
@@ -737,7 +737,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(0)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock, {});
+    builder.createUncondBrInst(exitBlock);
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_exit.L" << builder.getLabelIndex();
@@ -759,7 +759,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
   labelstring << "while_head.L" << builder.getLabelIndex();
   BasicBlock *headBlock = function->addBasicBlock(labelstring.str());
   labelstring.str("");
-  builder.createUncondBrInst(headBlock, {});
+  builder.createUncondBrInst(headBlock);
   BasicBlock::conectBlocks(curBlock, headBlock);
   builder.setPosition(headBlock, headBlock->end());
 
@@ -792,7 +792,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
     module->leaveScope();
   }
 
-  builder.createUncondBrInst(headBlock, {});
+  builder.createUncondBrInst(headBlock);
   BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
   builder.popBreakBlock();
   builder.popContinueBlock();
@@ -808,14 +808,14 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
 
 std::any SysYIRGenerator::visitBreakStmt(SysYParser::BreakStmtContext *ctx) {
   BasicBlock* breakBlock = builder.getBreakBlock();
-  builder.createUncondBrInst(breakBlock, {});
+  builder.createUncondBrInst(breakBlock);
   BasicBlock::conectBlocks(builder.getBasicBlock(), breakBlock);
   return std::any();
 }
 
 std::any SysYIRGenerator::visitContinueStmt(SysYParser::ContinueStmtContext *ctx) {
   BasicBlock* continueBlock = builder.getContinueBlock();
-  builder.createUncondBrInst(continueBlock, {});
+  builder.createUncondBrInst(continueBlock);
   BasicBlock::conectBlocks(builder.getBasicBlock(), continueBlock);
   return std::any();
 }
@@ -1504,7 +1504,7 @@ std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext *ctx){
     labelstring.str("");
 
     auto cond = std::any_cast<Value *>(visitEqExp(ctx->eqExp(i)));
-    builder.createCondBrInst(cond, newtrueBlock, falseBlock, {}, {});
+    builder.createCondBrInst(cond, newtrueBlock, falseBlock);
 
     BasicBlock::conectBlocks(curBlock, newtrueBlock);
     BasicBlock::conectBlocks(curBlock, falseBlock);
@@ -1514,7 +1514,7 @@ std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext *ctx){
   }
 
   auto cond = std::any_cast<Value *>(visitEqExp(conds.back()));
-  builder.createCondBrInst(cond, trueBlock, falseBlock, {}, {});
+  builder.createCondBrInst(cond, trueBlock, falseBlock);
 
   BasicBlock::conectBlocks(curBlock, trueBlock);
   BasicBlock::conectBlocks(curBlock, falseBlock);
@@ -1631,7 +1631,7 @@ void Utils::createExternalFunction(
   for (int i = 0; i < paramTypes.size(); ++i) {
     auto arg = new Argument(paramTypes[i], function, i, paramNames[i]);
     auto alloca = pBuilder->createAllocaInst(
-        Type::getPointerType(paramTypes[i]), {}, paramNames[i]);
+        Type::getPointerType(paramTypes[i]), paramNames[i]);
     function->insertArgument(arg);
     auto store = pBuilder->createStoreInst(arg, alloca);
     pModule->addVariable(paramNames[i], alloca);