From 3ed1c7fecdf8bfad15eda1ecf78e977a85b62428 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sat, 21 Jun 2025 16:39:13 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E5=89=8D=E7=BD=AE=E5=A3=B0?= =?UTF-8?q?=E6=98=8E=EF=BC=8CIR=E7=94=9F=E6=88=90=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/SysYIRGenerator.cpp | 348 ++++++++++++++++++++++++++++++++++++ src/include/IR.h | 386 ++++++++++++++++++++-------------------- src/include/IRBuilder.h | 129 +++++++------- 3 files changed, 602 insertions(+), 261 deletions(-) diff --git a/src/SysYIRGenerator.cpp b/src/SysYIRGenerator.cpp index c70869f..d23bf28 100644 --- a/src/SysYIRGenerator.cpp +++ b/src/SysYIRGenerator.cpp @@ -83,6 +83,354 @@ std::any SysYIRGenerator::visitGlobalVarDecl(SysYParser::GlobalVarDeclContext *c return std::any(); } +std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx){ + Type* type = std::any_cast(visitBType(ctx->bType())); + for (const auto constDef : ctx->constDef()) { + std::vector dims = {}; + std::string name = constDef->Ident()->getText(); + auto constExps = constDef->constExp(); + if (!constExps.empty()) { + for (const auto constExp : constExps) { + dims.push_back(std::any_cast(visitConstExp(constExp))); + } + } + + ArrayValueTree* root = std::any_cast(constDef->constInitVal()->accept(this)); + ValueCounter values; + Utils::tree2Array(type, root, dims, dims.size(), values, &builder); + delete root; + + module->createConstVar(name, Type::getPointerType(type), values, dims); + } + return 0; +} + +std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) { + Type* type = std::any_cast(visitBType(ctx->bType())); + for (const auto varDef : ctx->varDef()) { + std::vector dims = {}; + std::string name = varDef->Ident()->getText(); + auto constExps = varDef->constExp(); + if (!constExps.empty()) { + for (const auto &constExp : constExps) { + dims.push_back(std::any_cast(visitConstExp(constExp))); + } + } + + AllocaInst* alloca = + builder.createAllocaInst(Type::getPointerType(type), dims, name); + + if (varDef->initVal() != nullptr) { + ValueCounter values; + // 这里的varDef->initVal()可能是ScalarInitValue或ArrayInitValue + ArrayValueTree* root = std::any_cast(varDef->initVal()->accept(this)); + Utils::tree2Array(type, root, dims, dims.size(), values, &builder); + delete root; + if (dims.empty()) { + builder.createStoreInst(values.getValue(0), alloca); + } else { + // 对于多维数组，使用memset初始化 + // 计算每个维度的大小 + // 这里的values.getNumbers()返回的是每个维度的大小 + // 这里的values.getValues()返回的是每个维度对应的值 + // 例如：对于一个二维数组，values.getNumbers()可能是[3, 4]，表示3行4列 + // values.getValues()可能是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + // 对于每个维度，使用memset将对应的值填充到数组中 + // 这里的alloca是一个指向数组的指针 + std::vector & counterNumbers = values.getNumbers(); + std::vector & counterValues = values.getValues(); + unsigned begin = 0; + for (size_t i = 0; i < counterNumbers.size(); i++) { + + builder.createMemsetInst( + alloca, ConstantValue::get(static_cast(begin)), + ConstantValue::get(static_cast(counterNumbers[i])), + counterValues[i]); + begin += counterNumbers[i]; + } + } + } + module->addVariable(name, alloca); + } + return std::any(); +} + +std::any SysYIRGenerator::visitBType(SysYParser::BTypeContext *ctx) { + return ctx->INT() != nullptr ? Type::getIntType() : Type::getFloatType(); +} + +std::any SysYIRGenerator::visitScalarInitValue(SysYParser::ScalarInitValueContext *ctx) { + AllocaInst* alloca = std::any_cast(visitExp(ctx->exp())); + ArrayValueTree* result = new ArrayValueTree(); + result->setValue(alloca); + return result; +} + +std::any SysYIRGenerator::visitArrayInitValue(SysYParser::ArrayInitValueContext *ctx) { + std::vector children; + for (const auto &initVal : ctx->initVal()) + children.push_back(std::any_cast(initVal->accept(this))); + ArrayValueTree* result = new ArrayValueTree(); + result->addChildren(children); + return result; +} + +std::any SysYIRGenerator::visitConstScalarInitValue(SysYParser::ConstScalarInitValueContext *ctx) { + AllocaInst* alloca = std::any_cast(visitConstExp(ctx->constExp())); + ArrayValueTree* result = new ArrayValueTree(); + result->setValue(alloca); + return result; +} + +std::any SysYIRGenerator::visitConstArrayInitValue(SysYParser::ConstArrayInitValueContext *ctx) { + std::vector children; + for (const auto &constInitVal : ctx->constInitVal()) + children.push_back(std::any_cast(constInitVal->accept(this))); + ArrayValueTree* result = new ArrayValueTree(); + result->addChildren(children); + return result; +} + +std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext *ctx) { + if (ctx->INT() != nullptr) + return Type::getIntType(); + if (ctx->FLOAT() != nullptr) + return Type::getFloatType(); + return Type::getVoidType(); +} + +std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){ + // 更新作用域 + module->enterNewScope(); + + auto name = ctx->Ident()->getText(); + std::vector paramTypes; + std::vector paramNames; + std::vector> paramDims; + + if (ctx->funcFParams() != nullptr) { + auto params = ctx->funcFParams()->funcFParam(); + for (const auto ¶m : params) { + paramTypes.push_back(std::any_cast(visitBType(param->bType()))); + paramNames.push_back(param->Ident()->getText()); + std::vector dims = {}; + if (param->exp() != nullptr) { + dims.push_back(ConstantValue::get(-1)); // 第一个维度不确定 + for (const auto &exp : param->exp()) { + dims.push_back(std::any_cast(visitExp(exp))); + } + } + paramDims.emplace_back(dims); + } + } + + Type *returnType = std::any_cast(visitFuncType(ctx->funcType())); + FunctionType* funcType = Type::getFunctionType(returnType, paramTypes); + Function* function = module->createFunction(name, funcType); + BasicBlock* entry = function->getEntryBlock(); + builder.setPosition(entry, entry->end()); + + for (size_t i = 0; i < paramTypes.size(); ++i) { + AllocaInst* alloca = builder.createAllocaInst(Type::getPointerType(paramTypes[i]), + paramDims[i], paramNames[i]); + entry->insertArgument(alloca); + module->addVariable(paramNames[i], alloca); + } + + for (auto item : ctx->blockStmt()->blockItem()) { + visitBlockItem(item); + } + + module->leaveScope(); + + return std::any; +} + +std::any SysYIRGenerator::visitBlockStmt(SysYParser::BlockStmtContext *ctx) { + module->enterNewScope(); + for (auto item : ctx->blockItem()) + visitBlockItem(item); + module->leaveScope(); + return 0; +} + +std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { + auto lVal = ctx->lValue(); + std::string name = lVal->Ident()->getText(); + std::vector dims; + for (const auto &exp : lVal->exp()) { + dims.push_back(std::any_cast(visitExp(exp))); + } + + User* variable = module->getVariable(name); + Value* value = std::any_cast(visitExp(ctx->exp())); + PointerType* variableType =dynamic_cast(variable->getType())->getBaseType(); + + // 左值右值类型不同处理 + if (variableType != value->getType()) { + ConstantValue * constValue = dynamic_cast(value); + if (constValue != nullptr) { + if (variableType == Type::getFloatType()) { + value = ConstantValue::get(static_cast(constValue->getInt())); + } else { + value = ConstantValue::get(static_cast(constValue->getFloat())); + } + } else { + if (variableType == Type::getFloatType()) { + value = builder.createIToFInst(value); + } else { + value = builder.createFtoIInst(value); + } + } + } + builder.createStoreInst(value, variable, dims, variable->getName()); + + return std::any(); +} + + +std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { + // labels string stream + + std::stringstream labelstring; + Function * function = builder.getBasicBlock()->getParent(); + + BasicBlock* thenBlock = new BasicBlock(function); + BasicBlock* exitBlock = new BasicBlock(function); + + if (ctx->stmt().size() > 1) { + BasicBlock* elseBlock = new BasicBlock(function); + + builder.pushTrueBlock(thenBlock); + builder.pushFalseBlock(elseBlock); + // 访问条件表达式 + visitCond(ctx->cond()); + builder.popTrueBlock(); + builder.popFalseBlock(); + + labelstring << "then.L" << builder.getLabelIndex(); + thenBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(thenBlock); + builder.setPosition(thenBlock, thenBlock->end()); + + auto block = dynamic_cast(ctx->stmt(0)); + // 如果是块语句，直接访问 + // 否则访问语句 + if (block != nullptr) { + visitBlockStmt(block); + } else { + module->enterNewScope(); + ctx->stmt(0)->accept(this); + module->leaveScope(); + } + builder.createUncondBrInst(exitBlock, {}); + BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock); + + labelstring << "else.L" << builder.getLabelIndex(); + elseBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(elseBlock); + builder.setPosition(elseBlock, elseBlock->end()); + + block = dynamic_cast(ctx->stmt(1)); + if (block != nullptr) { + visitBlockStmt(block); + } else { + module->enterNewScope(); + ctx->stmt(1)->accept(this); + module->leaveScope(); + } + BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock); + + labelstring << "exit.L" << builder.getLabelIndex(); + exitBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(exitBlock); + builder.setPosition(exitBlock, exitBlock->end()); + + } else { + builder.pushTrueBlock(thenBlock); + builder.pushFalseBlock(exitBlock); + visitCond(ctx->cond()); + builder.popTrueBlock(); + builder.popFalseBlock(); + + labelstring << "then.L" << builder.getLabelIndex(); + thenBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(thenBlock); + builder.setPosition(thenBlock, thenBlock->end()); + + auto block = dynamic_cast(ctx->stmt(0)); + if (block != nullptr) { + visitBlockStmt(block); + } else { + module->enterNewScope(); + ctx->stmt(0)->accept(this); + module->leaveScope(); + } + BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock); + + labelstring << "exit.L" << builder.getLabelIndex(); + exitBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(exitBlock); + builder.setPosition(exitBlock, exitBlock->end()); + } + return std::any(); +} + +std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) { + + BasicBlock* curBlock = builder.getBasicBlock(); + Function* function = builder.getBasicBlock()->getParent(); + + std::stringstream labelstring; + labelstring << "head.L" << builder.getLabelIndex(); + BasicBlock *headBlock = function->addBasicBlock(labelstring.str()); + labelstring.str(""); + + BasicBlock::conectBlocks(curBlock, headBlock); + builder.setPosition(headBlock, headBlock->end()) + + function->addBasicBlock(condBlock); + builder.setPosition(condBlock, condBlock->end()); + + builder.pushTrueBlock(bodyBlock); + builder.pushFalseBlock(exitBlock); + + visitCond(ctx->cond()); + + builder.popTrueBlock(); + builder.popFalseBlock(); + + labelstring << "body.L" << builder.getLabelIndex(); + bodyBlock->setName(labelstring.str()); + labelstring.str(""); + function->addBasicBlock(bodyBlock); + builder.setPosition(bodyBlock, bodyBlock->end()); + + module->enterNewScope(); + for (auto item : ctx->blockStmt()->blockItem()) { + visitBlockItem(item); + } + module->leaveScope(); + + builder.createUncondBrInst(condBlock, {}); + + BasicBlock::conectBlocks(builder.getBasicBlock(), condBlock); + + labelstring << "exit.L" << builder.getLabelIndex(); + exitBlock->setName(labelstring.str()); + labelstring.str(""); + + function->addBasicBlock(exitBlock); + + builder.setPosition(exitBlock, exitBlock->end()); + + return std::any(); +} void Utils::tree2Array(Type *type, ArrayValueTree *root, const std::vector &dims, unsigned numDims, diff --git a/src/include/IR.h b/src/include/IR.h index 60db35a..1de2e23 100644 --- a/src/include/IR.h +++ b/src/include/IR.h @@ -58,23 +58,23 @@ class Type { virtual ~Type() = default; public: - static auto getIntType() -> Type *; ///< 返回表示Int类型的Type指针 - static auto getFloatType() -> Type *; ///< 返回表示Float类型的Type指针 - static auto getVoidType() -> Type *; ///< 返回表示Void类型的Type指针 - static auto getLabelType() -> Type *; ///< 返回表示Label类型的Type指针 - static auto getPointerType(Type *baseType) -> Type *; ///< 返回表示指向baseType类型的Pointer类型的Type指针 - static auto getFunctionType(Type *returnType, const std::vector ¶mTypes = {}) -> Type *; + static Type* getIntType(); ///< 返回表示Int类型的Type指针 + static Type* getFloatType(); ///< 返回表示Float类型的Type指针 + static Type* getVoidType(); ///< 返回表示Void类型的Type指针 + static Type* getLabelType(); ///< 返回表示Label类型的Type指针 + static Type* getPointerType(Type *baseType); ///< 返回表示指向baseType类型的Pointer类型的Type指针 + static Type* getFunctionType(Type *returnType, const std::vector ¶mTypes = {}); ///< 返回表示返回类型为returnType,形参类型列表为paramTypes的函数类型的Type指针 public: - auto getKind() const -> Kind { return kind; } ///< 返回Type对象代表原始标量类型 - auto isInt() const -> bool { return kind == kInt; } ///< 判定是否为Int类型 - auto isFloat() const -> bool { return kind == kFloat; } ///< 判定是否为Float类型 - auto isVoid() const -> bool { return kind == kVoid; } ///< 判定是否为Void类型 - auto isLabel() const -> bool { return kind == kLabel; } ///< 判定是否为Label类型 - auto isPointer() const -> bool { return kind == kPointer; } ///< 判定是否为Pointer类型 - auto isFunction() const -> bool { return kind == kFunction; } ///< 判定是否为Function类型 - auto getSize() const -> unsigned; ///< 返回类型所占的空间大小(字节) + Kind getKind() const { return kind; } ///< 返回Type对象代表原始标量类型 + bool isInt() const { return kind == kInt; } ///< 判定是否为Int类型 + bool isFloat() const { return kind == kFloat; } ///< 判定是否为Float类型 + bool isVoid() const { return kind == kVoid; } ///< 判定是否为Void类型 + bool isLabel() const { return kind == kLabel; } ///< 判定是否为Label类型 + bool isPointer() const { return kind == kPointer; } ///< 判定是否为Pointer类型 + bool isFunction() const { return kind == kFunction; } ///< 判定是否为Function类型 + unsigned getSize() const; ///< 返回类型所占的空间大小(字节) /// 尝试将一个变量转换为给定的Type及其派生类类型的变量 template auto as() const -> std::enable_if_t, T *> { @@ -90,10 +90,10 @@ class PointerType : public Type { explicit PointerType(Type *baseType) : Type(kPointer), baseType(baseType) {} public: - static auto get(Type *baseType) -> PointerType *; ///< 获取指向baseType的Pointer类型 + static PointerType* get(Type *baseType); ///< 获取指向baseType的Pointer类型 public: - auto getBaseType() const -> Type * { return baseType; } ///< 获取指向的类型 + Type* getBaseType() const { return baseType; } ///< 获取指向的类型 }; class FunctionType : public Type { @@ -107,12 +107,12 @@ class FunctionType : public Type { public: /// 获取返回值类型为returnType， 形参类型列表为paramTypes的Function类型 - static auto get(Type *returnType, const std::vector ¶mTypes = {}) -> FunctionType *; + static FunctionType* get(Type *returnType, const std::vector ¶mTypes = {}); public: - auto getReturnType() const -> Type * { return returnType; } ///< 获取返回值类信息 + Type* getReturnType() const { return returnType; } ///< 获取返回值类信息 auto getParamTypes() const { return make_range(paramTypes); } ///< 获取形参类型列表 - auto getNumParams() const -> unsigned { return paramTypes.size(); } ///< 获取形参数量 + unsigned getNumParams() const { return paramTypes.size(); } ///< 获取形参数量 }; /*! @@ -182,9 +182,9 @@ class Use { Use(unsigned index, User *user, Value *value) : index(index), user(user), value(value) {} public: - auto getIndex() const -> unsigned { return index; } ///< 返回value在User操作数中的位置 - auto getUser() const -> User * { return user; } ///< 返回使用者 - auto getValue() const -> Value * { return value; } ///< 返回被使用的值 + unsigned getIndex() const { return index; } ///< 返回value在User操作数中的位置 + User* getUser() const { return user; } ///< 返回使用者 + Value* getValue() const { return value; } ///< 返回被使用的值 void setValue(Value *newValue) { value = newValue; } ///< 将被使用的值设置为newValue }; @@ -202,19 +202,17 @@ class Value { public: void setName(const std::string &newName) { name = newName; } ///< 设置名字 - auto getName() const -> const std::string & { return name; } ///< 获取名字 - auto getType() const -> Type * { return type; } ///< 返回值的类型 - auto isInt() const -> bool { return type->isInt(); } ///< 判定是否为Int类型 - auto isFloat() const -> bool { return type->isFloat(); } ///< 判定是否为Float类型 - auto isPointer() const -> bool { return type->isPointer(); } ///< 判定是否为Pointer类型 - auto getUses() -> std::list> & { return uses; } ///< 获取使用关系列表 + const std::string& getName() const { return name; } ///< 获取名字 + Type* getType() const { return type; } ///< 返回值的类型 + bool isInt() const { return type->isInt(); } ///< 判定是否为Int类型 + bool isFloat() const { return type->isFloat(); } ///< 判定是否为Float类型 + bool isPointer() const { return type->isPointer(); } ///< 判定是否为Pointer类型 + std::list>& getUses() { return uses; } ///< 获取使用关系列表 void addUse(const std::shared_ptr &use) { uses.push_back(use); } ///< 添加使用关系 void replaceAllUsesWith(Value *value); ///< 将原来使用该value的使用者全变为使用给定参数value并修改相应use关系 void removeUse(const std::shared_ptr &use) { uses.remove(use); } ///< 删除使用关系use }; - - /** * ValueCounter 需要理解为一个Value *的计数器。 * 它的主要目的是为了节省存储空间和方便Memset指令的创建。 @@ -236,8 +234,8 @@ class ValueCounter { ValueCounter() = default; public: - auto size() const -> unsigned { return __size; } ///< 返回总的Value数量 - auto getValue(unsigned index) const -> Value * { + unsigned size() const { return __size; } ///< 返回总的Value数量 + Value* getValue(unsigned index) const { if (index >= __size) { return nullptr; } @@ -252,8 +250,8 @@ class ValueCounter { return nullptr; } ///< 根据位置index获取Value * - auto getValues() const -> const std::vector & { return __counterValues; } ///< 获取互异Value *列表 - auto getNumbers() const -> const std::vector & { return __counterNumbers; } ///< 获取Value *重复数量列表 + const std::vector& getValues() const { return __counterValues; } ///< 获取互异Value *列表 + const std::vector& getNumbers() const { return __counterNumbers; } ///< 获取Value *重复数量列表 void push_back(Value *value, unsigned num = 1) { if (__size != 0 && __counterValues.back() == value) { *(__counterNumbers.end() - 1) += num; @@ -293,20 +291,20 @@ class ConstantValue : public Value { : Value(Type::getFloatType(), name), fScalar(value) {} public: - static auto get(int value) -> ConstantValue *; ///< 获取一个int类型的ConstValue *，其值为value - static auto get(float value) -> ConstantValue *; ///< 获取一个float类型的ConstValue *，其值为value + static ConstantValue* get(int value); ///< 获取一个int类型的ConstValue *，其值为value + static ConstantValue* get(float value); ///< 获取一个float类型的ConstValue *，其值为value public: - auto getInt() const -> int { + int getInt() const { assert(isInt()); return iScalar; } ///< 返回int类型的值 - auto getFloat() const -> float { + float getFloat() const { assert(isFloat()); return fScalar; } ///< 返回float类型的值 template - auto getValue() const -> T { + T getValue() const { if (std::is_same::value && isInt()) { return getInt(); } @@ -369,23 +367,23 @@ class BasicBlock; } ///< 基本块的析构函数，同时删除其前驱后继关系 public: - auto getNumInstructions() const -> unsigned { return instructions.size(); } ///< 获取指令数量 - auto getNumArguments() const -> unsigned { return arguments.size(); } ///< 获取形式参数数量 - auto getNumPredecessors() const -> unsigned { return predecessors.size(); } ///< 获取前驱数量 - auto getNumSuccessors() const -> unsigned { return successors.size(); } ///< 获取后继数量 - auto getParent() const -> Function * { return parent; } ///< 获取父函数 + unsigned getNumInstructions() const { return instructions.size(); } ///< 获取指令数量 + unsigned getNumArguments() const { return arguments.size(); } ///< 获取形式参数数量 + unsigned getNumPredecessors() const { return predecessors.size(); } ///< 获取前驱数量 + unsigned getNumSuccessors() const { return successors.size(); } ///< 获取后继数量 + Function* getParent() const { return parent; } ///< 获取父函数 void setParent(Function *func) { parent = func; } ///< 设置父函数 - auto getInstructions() -> inst_list & { return instructions; } ///< 获取指令列表 - auto getArguments() -> arg_list & { return arguments; } ///< 获取分配空间后的形式参数列表 - auto getPredecessors() const -> const block_list & { return predecessors; } ///< 获取前驱列表 - auto getSuccessors() -> block_list & { return successors; } ///< 获取后继列表 - auto getDominants() -> block_set & { return dominants; } - auto getIdom() -> BasicBlock * { return idom; } - auto getSdoms() -> block_list & { return sdoms; } - auto getDFs() -> block_set & { return dominant_frontiers; } - auto begin() -> iterator { return instructions.begin(); } ///< 返回指向指令列表开头的迭代器 - auto end() -> iterator { return instructions.end(); } ///< 返回指向指令列表末尾的迭代器 - auto terminator() -> iterator { return std::prev(end()); } ///< 基本块最后的IR + inst_list& getInstructions() { return instructions; } ///< 获取指令列表 + arg_list& getArguments() { return arguments; } ///< 获取分配空间后的形式参数列表 + const block_list& getPredecessors() const { return predecessors; } ///< 获取前驱列表 + block_list& getSuccessors() { return successors; } ///< 获取后继列表 + block_set& getDominants() { return dominants; } + BasicBlock* getIdom() { return idom; } + block_list& getSdoms() { return sdoms; } + block_set& getDFs() { return dominant_frontiers; } + iterator begin() { return instructions.begin(); } ///< 返回指向指令列表开头的迭代器 + iterator end() { return instructions.end(); } ///< 返回指向指令列表末尾的迭代器 + iterator terminator() { return std::prev(end()); } ///< 基本块最后的IR void insertArgument(AllocaInst *inst) { arguments.push_back(inst); } ///< 插入分配空间后的形式参数 void addPredecessor(BasicBlock *block) { if (std::find(predecessors.begin(), predecessors.end(), block) == predecessors.end()) { @@ -411,18 +409,18 @@ class BasicBlock; void addSdoms(BasicBlock *block) { sdoms.push_back(block); } void clearSdoms() { sdoms.clear(); } // 重载1，参数为 BasicBlock* - auto addDominants(BasicBlock *block) -> void { dominants.emplace(block); } + void addDominants(BasicBlock *block) { dominants.emplace(block); } // 重载2，参数为 block_set - auto addDominants(const block_set &blocks) -> void { dominants.insert(blocks.begin(), blocks.end()); } - auto setDominants(BasicBlock *block) -> void { + void addDominants(const block_set &blocks) { dominants.insert(blocks.begin(), blocks.end()); } + void setDominants(BasicBlock *block) { dominants.clear(); addDominants(block); } - auto setDominants(const block_set &doms) -> void { + void setDominants(const block_set &doms) { dominants.clear(); addDominants(doms); } - auto setDFs(const block_set &df) -> void { + void setDFs(const block_set &df) { dominant_frontiers.clear(); for (auto elem : df) { dominant_frontiers.emplace(elem); @@ -453,7 +451,7 @@ class BasicBlock; } } ///< 替换前驱 // 获取支配树中该块的所有子节点，包括子节点的子节点等，迭代实现 - auto getChildren() -> block_list { + block_list getChildren() { std::queue q; block_list children; for (auto sdom : sdoms) { @@ -472,22 +470,20 @@ class BasicBlock; return children; } - auto setreachableTrue() -> void { reachable = true; } ///< 设置可达 - - auto setreachableFalse() -> void { reachable = false; } ///< 设置不可达 - - auto getreachable() -> bool { return reachable; } ///< 返回可达状态 + void setreachableTrue() { reachable = true; } ///< 设置可达 + void setreachableFalse() { reachable = false; } ///< 设置不可达 + bool getreachable() { return reachable; } ///< 返回可达状态 static void conectBlocks(BasicBlock *prev, BasicBlock *next) { prev->addSuccessor(next); next->addPredecessor(prev); } ///< 连接两个块，即设置两个基本块的前驱后继关系 void setLoop(Loop *loop2set) { loopbelong = loop2set; } ///< 设置所属循环 - auto getLoop() { return loopbelong; } ///< 获得所属循环 + Loop* getLoop() { return loopbelong; } ///< 获得所属循环 void setLoopDepth(int loopdepth2set) { loopdepth = loopdepth2set; } ///< 设置循环深度 - auto getLoopDepth() { return loopdepth; } ///< 获得其在循环的深度 + int getLoopDepth() { return loopdepth; } ///< 获得其在循环的深度 void removeInst(iterator pos) { instructions.erase(pos); } ///< 删除指令 - auto moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block) -> iterator; ///< 移动指令 + iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block); ///< 移动指令 }; //! User is the abstract base type of `Value` types which use other `Value` as @@ -504,11 +500,11 @@ class User : public Value { explicit User(Type *type, const std::string &name = "") : Value(type, name) {} public: - auto getNumOperands() const -> unsigned { return operands.size(); } ///< 获取操作数数量 + unsigned getNumOperands() const { return operands.size(); } ///< 获取操作数数量 auto operand_begin() const { return operands.begin(); } ///< 返回操作数列表的开头迭代器 auto operand_end() const { return operands.end(); } ///< 返回操作数列表的结尾迭代器 auto getOperands() const { return make_range(operand_begin(), operand_end()); } ///< 获取操作数列表 - auto getOperand(unsigned index) const -> Value * { return operands[index]->getValue(); } ///< 获取位置为index的操作数 + Value* getOperand(unsigned index) const { return operands[index]->getValue(); } ///< 获取位置为index的操作数 void addOperand(Value *value) { operands.emplace_back(std::make_shared(operands.size(), this, value)); value->addUse(operands.back()); @@ -528,8 +524,6 @@ class User : public Value { void setOperand(unsigned index, Value *value); ///< 设置操作数 }; - - class GetSubArrayInst; /** * 左值 具有地址的对象 @@ -551,11 +545,11 @@ class LVal { virtual unsigned getLValNumDims() const = 0; ///< 获取左值的维度数量 public: - auto getFatherLVal() const -> LVal * { return fatherLVal; } ///< 获取父左值 - auto getChildrenLVals() const -> const std::list> & { + LVal* getFatherLVal() const { return fatherLVal; } ///< 获取父左值 + const std::list>& getChildrenLVals() const { return childrenLVals; } ///< 获取子左值列表 - auto getAncestorLVal() const -> LVal * { + LVal* getAncestorLVal() const { auto curLVal = const_cast(this); while (curLVal->getFatherLVal() != nullptr) { curLVal = curLVal->getFatherLVal(); @@ -570,7 +564,7 @@ class LVal { [child](const std::unique_ptr &ptr) { return ptr.get() == child; }); childrenLVals.erase(iter); } ///< 移除子左值 - auto getDefineInst() const -> GetSubArrayInst * { return defineInst; } ///< 获取定义指令 + GetSubArrayInst* getDefineInst() const { return defineInst; } ///< 获取定义指令 }; /*! @@ -734,8 +728,8 @@ public: } } ///< 根据指令标识码获取字符串 - BasicBlock *getParent() const { return parent; } - Function *getFunction() const { return parent->getParent(); } + BasicBlock* getParent() const { return parent; } + Function* getFunction() const { return parent->getParent(); } void setParent(BasicBlock *bb) { parent = bb; } bool isBinary() const { @@ -809,10 +803,10 @@ class LaInst : public Instruction { } public: - auto getNumIndices() const -> unsigned { return getNumOperands() - 1; } ///< 获取索引长度 - auto getPointer() const -> Value * { return getOperand(0); } ///< 获取目标变量的Value指针 + unsigned getNumIndices() const { return getNumOperands() - 1; } ///< 获取索引长度 + Value* getPointer() const { return getOperand(0); } ///< 获取目标变量的Value指针 auto getIndices() const { return make_range(std::next(operand_begin()), operand_end()); } ///< 获取索引列表 - auto getIndex(unsigned index) const -> Value * { return getOperand(index + 1); } ///< 获取位置为index的索引分量 + Value* getIndex(unsigned index) const { return getOperand(index + 1); } ///< 获取位置为index的索引分量 }; class PhiInst : public Instruction { @@ -832,10 +826,10 @@ class PhiInst : public Instruction { } public: - Value * getMapVal() { return map_val; } - Value * getPointer() const { return getOperand(0); } + Value* getMapVal() { return map_val; } + Value* getPointer() const { return getOperand(0); } auto getValues() { return make_range(std::next(operand_begin()), operand_end()); } - Value * getValue(unsigned index) const { return getOperand(index + 1); } + Value* getValue(unsigned index) const { return getOperand(index + 1); } }; @@ -849,7 +843,7 @@ protected: public: - Function *getCallee() const; + Function* getCallee() const; auto getArguments() const { return make_range(std::next(operand_begin()), operand_end()); } @@ -870,7 +864,7 @@ protected: public: - Value *getOperand() const { return User::getOperand(0); } + Value* getOperand() const { return User::getOperand(0); } }; // class UnaryInst @@ -887,10 +881,10 @@ class BinaryInst : public Instruction { } public: - Value *getLhs() const { return getOperand(0); } - Value *getRhs() const { return getOperand(1); } + Value* getLhs() const { return getOperand(0); } + Value* getRhs() const { return getOperand(1); } template - auto eval(T lhs, T rhs) -> T { + T eval(T lhs, T rhs) { switch (getKind()) { case kAdd: return lhs + rhs; @@ -963,7 +957,7 @@ class ReturnInst : public Instruction { public: bool hasReturnValue() const { return not operands.empty(); } - Value *getReturnValue() const { + Value* getReturnValue() const { return hasReturnValue() ? getOperand(0) : nullptr; } }; @@ -983,7 +977,7 @@ protected: } public: - BasicBlock *getBlock() const { return dynamic_cast(getOperand(0)); } + BasicBlock* getBlock() const { return dynamic_cast(getOperand(0)); } auto getArguments() const { return make_range(std::next(operand_begin()), operand_end()); } @@ -1009,11 +1003,11 @@ protected: addOperands(elseArgs); } public: - Value *getCondition() const { return getOperand(0); } - BasicBlock *getThenBlock() const { + Value* getCondition() const { return getOperand(0); } + BasicBlock* getThenBlock() const { return dynamic_cast(getOperand(1)); } - BasicBlock *getElseBlock() const { + BasicBlock* getElseBlock() const { return dynamic_cast(getOperand(2)); } auto getThenArguments() const { @@ -1053,7 +1047,7 @@ public: int getNumDims() const { return getNumOperands(); } auto getDims() const { return getOperands(); } - Value *getDim(int index) { return getOperand(index); } + Value* getDim(int index) { return getOperand(index); } }; // class AllocaInst @@ -1083,12 +1077,12 @@ class GetSubArrayInst : public Instruction { } public: - auto getFatherArray() const -> Value * { return getOperand(0); } ///< 获取父数组 - auto getChildArray() const -> Value * { return getOperand(1); } ///< 获取子数组 - auto getFatherLVal() const -> LVal * { return dynamic_cast(getOperand(0)); } ///< 获取父左值 - auto getChildLVal() const -> LVal * { return dynamic_cast(getOperand(1)); } ///< 获取子左值 + Value* getFatherArray() const { return getOperand(0); } ///< 获取父数组 + Value* getChildArray() const { return getOperand(1); } ///< 获取子数组 + LVal* getFatherLVal() const { return dynamic_cast(getOperand(0)); } ///< 获取父左值 + LVal* getChildLVal() const { return dynamic_cast(getOperand(1)); } ///< 获取子左值 auto getIndices() const { return make_range(std::next(operand_begin(), 2), operand_end()); } ///< 获取索引 - auto getNumIndices() const -> unsigned { return getNumOperands() - 2; } ///< 获取索引数量 + unsigned getNumIndices() const { return getNumOperands() - 2; } ///< 获取索引数量 }; //! Load a value from memory address specified by a pointer value @@ -1107,11 +1101,11 @@ protected: public: int getNumIndices() const { return getNumOperands() - 1; } - Value *getPointer() const { return getOperand(0); } + Value* getPointer() const { return getOperand(0); } auto getIndices() const { return make_range(std::next(operand_begin()), operand_end()); } - Value *getIndex(int index) const { return getOperand(index + 1); } + Value* getIndex(int index) const { return getOperand(index + 1); } std::list getAncestorIndices() const { std::list indices; for (const auto &index : getIndices()) { @@ -1147,12 +1141,12 @@ protected: public: int getNumIndices() const { return getNumOperands() - 2; } - Value *getValue() const { return getOperand(0); } - Value *getPointer() const { return getOperand(1); } + 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); } + Value* getIndex(int index) const { return getOperand(index + 2); } std::list getAncestorIndices() const { std::list indices; for (const auto &index : getIndices()) { @@ -1178,6 +1172,13 @@ class MemsetInst : public Instruction { friend class Function; protected: + //! Create a memset instruction. + //! \param pointer The pointer to the memory location to be set. + //! \param begin The starting address of the memory region to be set. + //! \param size The size of the memory region to be set. + //! \param value The value to set the memory region to. + //! \param parent The parent basic block of this instruction. + //! \param name The name of this instruction. MemsetInst(Value *pointer, Value *begin, Value *size, Value *value, BasicBlock *parent = nullptr, const std::string &name = "") : Instruction(kMemset, Type::getVoidType(), parent, name) { @@ -1188,10 +1189,10 @@ protected: } public: - Value *getPointer() const { return getOperand(0); } - Value *getBegin() const { return getOperand(1); } - Value *getSize() const { return getOperand(2); } - Value *getValue() const { return getOperand(3); } + Value* getPointer() const { return getOperand(0); } + Value* getBegin() const { return getOperand(1); } + Value* getSize() const { return getOperand(2); } + Value* getValue() const { return getOperand(3); } }; @@ -1241,26 +1242,26 @@ public: loopCount = loopCount + 1; loopID = loopCount; } - auto getindBegin() { return indBegin; } ///< 获得循环开始值 - auto getindStep() { return indStep; } ///< 获得循环步长 - auto setindBegin(ConstantValue *indBegin2set) { indBegin = indBegin2set; } ///< 设置循环开始值 - auto setindStep(ConstantValue *indStep2set) { indStep = indStep2set; } ///< 设置循环步长 - auto setStepType(int StepType2Set) { StepType = StepType2Set; } ///< 设置循环变量规则 - auto getStepType() { return StepType; } ///< 获得循环变量规则 - auto getLoopID() -> size_t { return loopID; } + ConstantValue* getindBegin() { return indBegin; } ///< 获得循环开始值 + ConstantValue* getindStep() { return indStep; } ///< 获得循环步长 + void setindBegin(ConstantValue *indBegin2set) { indBegin = indBegin2set; } ///< 设置循环开始值 + void setindStep(ConstantValue *indStep2set) { indStep = indStep2set; } ///< 设置循环步长 + void setStepType(int StepType2Set) { StepType = StepType2Set; } ///< 设置循环变量规则 + int getStepType() { return StepType; } ///< 获得循环变量规则 + size_t getLoopID() { return loopID; } - BasicBlock *getHeader() const { return headerBlock; } - BasicBlock *getPreheaderBlock() const { return preheaderBlock; } - block_list &getLatchBlocks() { return latchBlock; } - block_set &getExitingBlocks() { return exitingBlocks; } - block_set &getExitBlocks() { return exitBlocks; } - Loop *getParentLoop() const { return parentloop; } + BasicBlock* getHeader() const { return headerBlock; } + BasicBlock* getPreheaderBlock() const { return preheaderBlock; } + block_list& getLatchBlocks() { return latchBlock; } + block_set& getExitingBlocks() { return exitingBlocks; } + block_set& getExitBlocks() { return exitBlocks; } + Loop* getParentLoop() const { return parentloop; } void setParentLoop(Loop *parent) { parentloop = parent; } void addBasicBlock(BasicBlock *bb) { blocksInLoop.push_back(bb); } void addSubLoop(Loop *loop) { subLoops.push_back(loop); } void setLoopDepth(unsigned depth) { loopDepth = depth; } - block_list &getBasicBlocks() { return blocksInLoop; } - Loop_list &getSubLoops() { return subLoops; } + block_list& getBasicBlocks() { return blocksInLoop; } + Loop_list& getSubLoops() { return subLoops; } unsigned getLoopDepth() const { return loopDepth; } bool isLoopContainsBasicBlock(BasicBlock *bb) const { @@ -1280,14 +1281,14 @@ public: void setIndEnd(Value *value) { indEnd = value; } void setIndPhi(AllocaInst *phi) { IndPhi = phi; } - Value *getIndEnd() const { return indEnd; } - AllocaInst *getIndPhi() const { return IndPhi; } - Instruction *getIndCondVar() const { return indCondVar; } + Value* getIndEnd() const { return indEnd; } + AllocaInst* getIndPhi() const { return IndPhi; } + Instruction* getIndCondVar() const { return indCondVar; } - auto addGlobalValuechange(GlobalValue *globalvaluechange2add) { + void addGlobalValuechange(GlobalValue *globalvaluechange2add) { GlobalValuechange.insert(globalvaluechange2add); } ///<添加在循环中改变的全局变量 - auto getGlobalValuechange() -> std::set & { + std::set& getGlobalValuechange() { return GlobalValuechange; } ///<获得在循环中改变的所有全局变量 @@ -1335,83 +1336,82 @@ protected: std::unordered_map> value2UseBlocks; //< value -- use blocks mapping public: - static auto getcloneIndex() -> unsigned { + static unsigned getcloneIndex() { static unsigned cloneIndex = 0; cloneIndex += 1; return cloneIndex - 1; } - auto clone(const std::string &suffix = "_" + std::to_string(getcloneIndex()) + "@") const - -> Function *; ///< 复制函数 - auto getCallees() -> const std::set & { return callees; } - auto addCallee(Function *callee) -> void { callees.insert(callee); } - auto removeCallee(Function *callee) -> void { callees.erase(callee); } - auto clearCallees() -> void { callees.clear(); } - auto getCalleesWithNoExternalAndSelf() -> std::set; - auto getAttribute() const -> FunctionAttribute { return attribute; } ///< 获取函数属性 - auto setAttribute(FunctionAttribute attr) -> void { + Function* clone(const std::string &suffix = "_" + std::to_string(getcloneIndex()) + "@") const; ///< 复制函数 + const std::set& getCallees() { return callees; } + void addCallee(Function *callee) { callees.insert(callee); } + void removeCallee(Function *callee) { callees.erase(callee); } + void clearCallees() { callees.clear(); } + std::set getCalleesWithNoExternalAndSelf(); + FunctionAttribute getAttribute() const { return attribute; } ///< 获取函数属性 + void setAttribute(FunctionAttribute attr) { attribute = static_cast(attribute | attr); } ///< 设置函数属性 - auto clearAttribute() -> void { attribute = PlaceHolder; } ///< 清楚所有函数属性，只保留PlaceHolder - auto getLoopOfBasicBlock(BasicBlock *bb) -> Loop * { + void clearAttribute() { attribute = PlaceHolder; } ///< 清楚所有函数属性，只保留PlaceHolder + Loop* getLoopOfBasicBlock(BasicBlock *bb) { return basicblock2Loop.count(bb) != 0 ? basicblock2Loop[bb] : nullptr; } ///< 获得块所在循环 - auto getLoopDepthByBlock(BasicBlock *basicblock2Check) { + unsigned getLoopDepthByBlock(BasicBlock *basicblock2Check) { if (getLoopOfBasicBlock(basicblock2Check) != nullptr) { auto loop = getLoopOfBasicBlock(basicblock2Check); return loop->getLoopDepth(); } return static_cast(0); } ///< 通过块，获得其所在循环深度 - auto addBBToLoop(BasicBlock *bb, Loop *LoopToadd) { basicblock2Loop[bb] = LoopToadd; } ///< 添加块与循环的映射 - auto getBBToLoopRef() -> std::unordered_map & { + void addBBToLoop(BasicBlock *bb, Loop *LoopToadd) { basicblock2Loop[bb] = LoopToadd; } ///< 添加块与循环的映射 + std::unordered_map& getBBToLoopRef() { return basicblock2Loop; } ///< 获得块-循环映射表 // auto getNewLoopPtr(BasicBlock *header) -> Loop * { return new Loop(header); } - auto getReturnType() const -> Type * { return getType()->as()->getReturnType(); } ///< 获取返回值类型 + Type* getReturnType() const { return getType()->as()->getReturnType(); } ///< 获取返回值类型 auto getParamTypes() const { return getType()->as()->getParamTypes(); } ///< 获取形式参数类型列表 auto getBasicBlocks() { return make_range(blocks); } ///< 获取基本块列表 - auto getBasicBlocks_NoRange() -> block_list & { return blocks; } - auto getEntryBlock() -> BasicBlock * { return blocks.front().get(); } ///< 获取入口块 - auto removeBasicBlock(BasicBlock *blockToRemove) { + block_list& getBasicBlocks_NoRange() { return blocks; } + BasicBlock* getEntryBlock() { return blocks.front().get(); } ///< 获取入口块 + void removeBasicBlock(BasicBlock *blockToRemove) { auto is_same_ptr = [blockToRemove](const std::unique_ptr &ptr) { return ptr.get() == blockToRemove; }; blocks.remove_if(is_same_ptr); // blocks.erase(std::remove_if(blocks.begin(), blocks.end(), is_same_ptr), blocks.end()); } ///< 将该块从function的blocks中删除 // auto getBasicBlocks_NoRange() -> block_list & { return blocks; } - auto addBasicBlock(const std::string &name = "") -> BasicBlock * { + BasicBlock* addBasicBlock(const std::string &name = "") { blocks.emplace_back(new BasicBlock(this, name)); return blocks.back().get(); } ///< 添加新的基本块 - auto addBasicBlock(BasicBlock *block) -> BasicBlock * { + BasicBlock* addBasicBlock(BasicBlock *block) { blocks.emplace_back(block); return block; } ///< 添加基本块到blocks中 - auto addBasicBlockFront(BasicBlock *block) -> BasicBlock * { + BasicBlock* addBasicBlockFront(BasicBlock *block) { blocks.emplace_front(block); return block; } // 从前端插入新的基本块 /** value -- alloc blocks mapping */ - auto addValue2AllocBlocks(Value *value, BasicBlock *block) -> void { + void addValue2AllocBlocks(Value *value, BasicBlock *block) { value2AllocBlocks[value] = block; } ///< 添加value -- alloc block mapping - auto getAllocBlockByValue(Value *value) -> BasicBlock * { + BasicBlock* getAllocBlockByValue(Value *value) { if (value2AllocBlocks.count(value) > 0) { return value2AllocBlocks[value]; } return nullptr; } ///< 通过value获取alloc block - auto getValue2AllocBlocks() -> std::unordered_map & { + std::unordered_map& getValue2AllocBlocks() { return value2AllocBlocks; } ///< 获取所有value -- alloc block mappings - auto removeValue2AllocBlock(Value *value) -> void { + void removeValue2AllocBlock(Value *value) { value2AllocBlocks.erase(value); } ///< 删除value -- alloc block mapping /** value -- define blocks mapping */ - auto addValue2DefBlocks(Value *value, BasicBlock *block) -> void { + void addValue2DefBlocks(Value *value, BasicBlock *block) { ++value2DefBlocks[value][block]; } ///< 添加value -- define block mapping // keep in mind that the return is not a reference. - auto getDefBlocksByValue(Value *value) -> std::unordered_set { + std::unordered_set getDefBlocksByValue(Value *value) { std::unordered_set blocks; if (value2DefBlocks.count(value) > 0) { for (const auto &pair : value2DefBlocks[value]) { @@ -1420,10 +1420,10 @@ protected: } return blocks; } ///< 通过value获取define blocks - auto getValue2DefBlocks() -> std::unordered_map> & { + std::unordered_map>& getValue2DefBlocks() { return value2DefBlocks; } ///< 获取所有value -- define blocks mappings - auto removeValue2DefBlock(Value *value, BasicBlock *block) -> bool { + bool removeValue2DefBlock(Value *value, BasicBlock *block) { bool changed = false; if (--value2DefBlocks[value][block] == 0) { value2DefBlocks[value].erase(block); @@ -1434,7 +1434,7 @@ protected: } return changed; } ///< 删除value -- define block mapping - auto getValuesOfDefBlock() -> std::unordered_set { + std::unordered_set getValuesOfDefBlock() { std::unordered_set values; for (const auto &pair : value2DefBlocks) { values.insert(pair.first); @@ -1442,11 +1442,11 @@ protected: return values; } ///< 获取所有定义过的value /** value -- use blocks mapping */ - auto addValue2UseBlocks(Value *value, BasicBlock *block) -> void { + void addValue2UseBlocks(Value *value, BasicBlock *block) { ++value2UseBlocks[value][block]; } ///< 添加value -- use block mapping // keep in mind that the return is not a reference. - auto getUseBlocksByValue(Value *value) -> std::unordered_set { + std::unordered_set getUseBlocksByValue(Value *value) { std::unordered_set blocks; if (value2UseBlocks.count(value) > 0) { for (const auto &pair : value2UseBlocks[value]) { @@ -1455,10 +1455,10 @@ protected: } return blocks; } ///< 通过value获取use blocks - auto getValue2UseBlocks() -> std::unordered_map> & { + std::unordered_map>& getValue2UseBlocks() { return value2UseBlocks; } ///< 获取所有value -- use blocks mappings - auto removeValue2UseBlock(Value *value, BasicBlock *block) -> bool { + bool removeValue2UseBlock(Value *value, BasicBlock *block) { bool changed = false; if (--value2UseBlocks[value][block] == 0) { value2UseBlocks[value].erase(block); @@ -1469,8 +1469,8 @@ protected: } return changed; } ///< 删除value -- use block mapping - auto addIndirectAlloca(AllocaInst *alloca) { indirectAllocas.emplace_back(alloca); } ///< 添加间接分配 - auto getIndirectAllocas() -> std::list> & { + void addIndirectAlloca(AllocaInst *alloca) { indirectAllocas.emplace_back(alloca); } ///< 添加间接分配 + std::list>& getIndirectAllocas() { return indirectAllocas; } ///< 获取间接分配列表 @@ -1478,8 +1478,8 @@ protected: void addLoop(Loop *loop) { loops.emplace_back(loop); } ///< 添加循环（非顶层） void addTopLoop(Loop *loop) { topLoops.emplace_back(loop); } ///< 添加顶层循环 - auto getLoops() -> Loop_list & { return loops; } ///< 获得循环（非顶层） - auto getTopLoops() -> Loop_list & { return topLoops; } ///< 获得顶层循环 + Loop_list& getLoops() { return loops; } ///< 获得循环（非顶层） + Loop_list& getTopLoops() { return topLoops; } ///< 获得顶层循环 /** loop -- end */ }; // class Function @@ -1532,7 +1532,7 @@ public: Value* getByIndex(unsigned index) const { return initValues.getValue(index); } ///< 通过一维偏移量index获取初始值 - Value * getByIndices(const std::vector &indices) const { + Value* getByIndices(const std::vector &indices) const { int index = 0; for (size_t i = 0; i < indices.size(); i++) { index = dynamic_cast(getDim(i))->getInt() * index + @@ -1540,7 +1540,7 @@ public: } return getByIndex(index); } ///< 通过多维索引indices获取初始值 - const ValueCounter &getInitValues() const { return initValues; } + const ValueCounter& getInitValues() const { return initValues; } }; // class GlobalValue @@ -1583,13 +1583,13 @@ class ConstantVariable : public User, public LVal { return getByIndex(index); } ///< 通过多维索引indices获取初始值 unsigned getNumDims() const { return numDims; } ///< 获取维度数量 - Value* getDim(unsigned index) const { return getOperand(index); } ///< 获取位置为index的维度 + Value* getDim(unsigned index) const { return getOperand(index); } ///< 获取位置为index的维度 auto getDims() const { return getOperands(); } ///< 获取维度列表 const ValueCounter& getInitValues() const { return initValues; } ///< 获取初始值 }; using SymbolTableNode = struct SymbolTableNode { - struct SymbolTableNode *pNode; ///< 父节点 + SymbolTableNode *pNode; ///< 父节点 std::vector children; ///< 子节点列表 std::map varList; ///< 变量列表 }; @@ -1606,15 +1606,15 @@ class SymbolTable { public: SymbolTable() = default; - auto getVariable(const std::string &name) const -> User *; ///< 根据名字name以及当前作用域获取变量 - auto addVariable(const std::string &name, User *variable) -> User *; ///< 添加变量 - auto getGlobals() -> std::vector> &; ///< 获取全局变量列表 - auto getConsts() const -> const std::vector> &; ///< 获取常量列表 + User* getVariable(const std::string &name) const; ///< 根据名字name以及当前作用域获取变量 + User* addVariable(const std::string &name, User *variable); ///< 添加变量 + std::vector>& getGlobals(); ///< 获取全局变量列表 + const std::vector>& getConsts() const; ///< 获取常量列表 void enterNewScope(); ///< 进入新的作用域 void leaveScope(); ///< 离开作用域 - auto isInGlobalScope() const -> bool; ///< 是否位于全局作用域 + bool isInGlobalScope() const; ///< 是否位于全局作用域 void enterGlobalScope(); ///< 进入全局作用域 - auto isCurNodeNull() -> bool { return curNode == nullptr; } + bool isCurNodeNull() { return curNode == nullptr; } }; //! IR unit for representing a SysY compile unit @@ -1628,14 +1628,14 @@ class Module { Module() = default; public: - auto createFunction(const std::string &name, Type *type) -> Function * { + Function* createFunction(const std::string &name, Type *type) { auto result = functions.try_emplace(name, new Function(this, type, name)); if (!result.second) { return nullptr; } return result.first->second.get(); } ///< 创建函数 - auto createExternalFunction(const std::string &name, Type *type) -> Function * { + Function* createExternalFunction(const std::string &name, Type *type) { auto result = externalFunctions.try_emplace(name, new Function(this, type, name)); if (!result.second) { return nullptr; @@ -1643,8 +1643,8 @@ class Module { return result.first->second.get(); } ///< 创建外部函数 ///< 变量创建伴随着符号表的更新 - auto createGlobalValue(const std::string &name, Type *type, const std::vector &dims = {}, - const ValueCounter &init = {}) -> GlobalValue * { + GlobalValue* createGlobalValue(const std::string &name, Type *type, const std::vector &dims = {}, + const ValueCounter &init = {}) { bool isFinished = variableTable.isCurNodeNull(); if (isFinished) { variableTable.enterGlobalScope(); @@ -1658,8 +1658,8 @@ class Module { } return dynamic_cast(result); } ///< 创建全局变量 - auto createConstVar(const std::string &name, Type *type, const ValueCounter &init, - const std::vector &dims = {}) -> ConstantVariable * { + ConstantVariable* createConstVar(const std::string &name, Type *type, const ValueCounter &init, + const std::vector &dims = {}) { auto result = variableTable.addVariable(name, new ConstantVariable(this, type, name, init, dims)); if (result == nullptr) { return nullptr; @@ -1669,38 +1669,38 @@ class Module { void addVariable(const std::string &name, AllocaInst *variable) { variableTable.addVariable(name, variable); } ///< 添加变量 - auto getVariable(const std::string &name) -> User * { + User* getVariable(const std::string &name) { return variableTable.getVariable(name); } ///< 根据名字name和当前作用域获取变量 - auto getFunction(const std::string &name) const -> Function * { + Function* getFunction(const std::string &name) const { auto result = functions.find(name); if (result == functions.end()) { return nullptr; } return result->second.get(); } ///< 获取函数 - auto getExternalFunction(const std::string &name) const -> Function * { + Function* getExternalFunction(const std::string &name) const { auto result = externalFunctions.find(name); if (result == functions.end()) { return nullptr; } return result->second.get(); } ///< 获取外部函数 - auto getFunctions() -> std::map> & { return functions; } ///< 获取函数列表 - auto getExternalFunctions() const -> const std::map> & { + std::map>& getFunctions() { return functions; } ///< 获取函数列表 + const std::map>& getExternalFunctions() const { return externalFunctions; } ///< 获取外部函数列表 - auto getGlobals() -> std::vector> & { + std::vector>& getGlobals() { return variableTable.getGlobals(); } ///< 获取全局变量列表 - auto getConsts() const -> const std::vector> & { + const std::vector>& getConsts() const { return variableTable.getConsts(); } ///< 获取常量列表 void enterNewScope() { variableTable.enterNewScope(); } ///< 进入新的作用域 void leaveScope() { variableTable.leaveScope(); } ///< 离开作用域 - auto isInGlobalArea() const -> bool { return variableTable.isInGlobalScope(); } ///< 是否位于全局作用域 + bool isInGlobalArea() const { return variableTable.isInGlobalScope(); } ///< 是否位于全局作用域 }; /*! diff --git a/src/include/IRBuilder.h b/src/include/IRBuilder.h index 7335ea8..9189cba 100644 --- a/src/include/IRBuilder.h +++ b/src/include/IRBuilder.h @@ -39,41 +39,41 @@ class IRBuilder { : labelIndex(0), tmpIndex(0), block(block), position(position) {} public: - auto getLabelIndex() -> unsigned { + unsigned getLabelIndex() { labelIndex += 1; return labelIndex - 1; } ///< 获取基本块标签编号 - auto getTmpIndex() -> unsigned { + unsigned getTmpIndex() { tmpIndex += 1; return tmpIndex - 1; } ///< 获取临时变量编号 - auto getBasicBlock() const -> BasicBlock * { return block; } ///< 获取当前基本块 - auto getBreakBlock() const -> BasicBlock * { return breakBlocks.back(); } ///< 获取break目标块 - auto popBreakBlock() -> BasicBlock * { + BasicBlock * getBasicBlock() const { return block; } ///< 获取当前基本块 + BasicBlock * getBreakBlock() const { return breakBlocks.back(); } ///< 获取break目标块 + BasicBlock * popBreakBlock() { auto result = breakBlocks.back(); breakBlocks.pop_back(); return result; } ///< 弹出break目标块 - auto getContinueBlock() const -> BasicBlock * { return continueBlocks.back(); } ///< 获取continue目标块 - auto popContinueBlock() -> BasicBlock * { + BasicBlock * getContinueBlock() const { return continueBlocks.back(); } ///< 获取continue目标块 + BasicBlock * popContinueBlock() { auto result = continueBlocks.back(); continueBlocks.pop_back(); return result; } ///< 弹出continue目标块 - auto getTrueBlock() const -> BasicBlock * { return trueBlocks.back(); } ///< 获取true分支基本块 - auto getFalseBlock() const -> BasicBlock * { return falseBlocks.back(); } ///< 获取false分支基本块 - auto popTrueBlock() -> BasicBlock * { + BasicBlock * getTrueBlock() const { return trueBlocks.back(); } ///< 获取true分支基本块 + BasicBlock * getFalseBlock() const { return falseBlocks.back(); } ///< 获取false分支基本块 + BasicBlock * popTrueBlock() { auto result = trueBlocks.back(); trueBlocks.pop_back(); return result; } ///< 弹出true分支基本块 - auto popFalseBlock() -> BasicBlock * { + BasicBlock * popFalseBlock() { auto result = falseBlocks.back(); falseBlocks.pop_back(); return result; } ///< 弹出false分支基本块 - auto getPosition() const -> BasicBlock::iterator { return position; } ///< 获取当前基本块指令列表位置的迭代器 + BasicBlock::iterator getPosition() const { return position; } ///< 获取当前基本块指令列表位置的迭代器 void setPosition(BasicBlock *block, BasicBlock::iterator position) { this->block = block; this->position = position; @@ -87,13 +87,12 @@ class IRBuilder { void pushFalseBlock(BasicBlock *block) { falseBlocks.push_back(block); } ///< 压入false分支基本块 public: - auto insertInst(Instruction *inst) -> Instruction * { + Instruction * insertInst(Instruction *inst) { assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 插入指令 - auto createUnaryInst(Instruction::Kind kind, Type *type, Value *operand, const std::string &name = "") - -> UnaryInst * { + UnaryInst * createUnaryInst(Instruction::Kind kind, Type *type, Value *operand, const std::string &name = "") { std::string newName; if (name.empty()) { std::stringstream ss; @@ -109,32 +108,31 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建一元指令 - auto createNegInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createNegInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kNeg, Type::getIntType(), operand, name); } ///< 创建取反指令 - auto createNotInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createNotInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kNot, Type::getIntType(), operand, name); } ///< 创建取非指令 - auto createFtoIInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createFtoIInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kFtoI, Type::getIntType(), operand, name); } ///< 创建浮点转整型指令 - auto createBitFtoIInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createBitFtoIInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kBitFtoI, Type::getIntType(), operand, name); } ///< 创建按位浮点转整型指令 - auto createFNegInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createFNegInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kFNeg, Type::getFloatType(), operand, name); } ///< 创建浮点取反指令 - auto createFNotInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createFNotInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kFNot, Type::getIntType(), operand, name); } ///< 创建浮点取非指令 - auto createIToFInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createIToFInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kItoF, Type::getFloatType(), operand, name); } ///< 创建整型转浮点指令 - auto createBitItoFInst(Value *operand, const std::string &name = "") -> UnaryInst * { + UnaryInst * createBitItoFInst(Value *operand, const std::string &name = "") { return createUnaryInst(Instruction::kBitItoF, Type::getFloatType(), operand, name); } ///< 创建按位整型转浮点指令 - auto createBinaryInst(Instruction::Kind kind, Type *type, Value *lhs, Value *rhs, const std::string &name = "") - -> BinaryInst * { + BinaryInst * createBinaryInst(Instruction::Kind kind, Type *type, Value *lhs, Value *rhs, const std::string &name = "") { std::string newName; if (name.empty()) { std::stringstream ss; @@ -150,76 +148,76 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建二元指令 - auto createAddInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createAddInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kAdd, Type::getIntType(), lhs, rhs, name); } ///< 创建加法指令 - auto createSubInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createSubInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kSub, Type::getIntType(), lhs, rhs, name); } ///< 创建减法指令 - auto createMulInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createMulInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kMul, Type::getIntType(), lhs, rhs, name); } ///< 创建乘法指令 - auto createDivInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createDivInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kDiv, Type::getIntType(), lhs, rhs, name); } ///< 创建除法指令 - auto createRemInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createRemInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kRem, Type::getIntType(), lhs, rhs, name); } ///< 创建取余指令 - auto createICmpEQInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpEQInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpEQ, Type::getIntType(), lhs, rhs, name); } ///< 创建相等设置指令 - auto createICmpNEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpNEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpNE, Type::getIntType(), lhs, rhs, name); } ///< 创建不相等设置指令 - auto createICmpLTInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpLTInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpLT, Type::getIntType(), lhs, rhs, name); } ///< 创建小于设置指令 - auto createICmpLEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpLEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpLE, Type::getIntType(), lhs, rhs, name); } ///< 创建小于等于设置指令 - auto createICmpGTInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpGTInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpGT, Type::getIntType(), lhs, rhs, name); } ///< 创建大于设置指令 - auto createICmpGEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createICmpGEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kICmpGE, Type::getIntType(), lhs, rhs, name); } ///< 创建大于等于设置指令 - auto createFAddInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFAddInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFAdd, Type::getFloatType(), lhs, rhs, name); } ///< 创建浮点加法指令 - auto createFSubInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFSubInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFSub, Type::getFloatType(), lhs, rhs, name); } ///< 创建浮点减法指令 - auto createFMulInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFMulInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFMul, Type::getFloatType(), lhs, rhs, name); } ///< 创建浮点乘法指令 - auto createFDivInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFDivInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFDiv, Type::getFloatType(), lhs, rhs, name); } ///< 创建浮点除法指令 - auto createFCmpEQInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpEQInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpEQ, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点相等设置指令 - auto createFCmpNEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpNEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpNE, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点不相等设置指令 - auto createFCmpLTInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpLTInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpLT, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点小于设置指令 - auto createFCmpLEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpLEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpLE, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点小于等于设置指令 - auto createFCmpGTInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpGTInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpGT, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点大于设置指令 - auto createFCmpGEInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createFCmpGEInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kFCmpGE, Type::getIntType(), lhs, rhs, name); } ///< 创建浮点相大于等于设置指令 - auto createAndInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createAndInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kAnd, Type::getIntType(), lhs, rhs, name); } ///< 创建按位且指令 - auto createOrInst(Value *lhs, Value *rhs, const std::string &name = "") -> BinaryInst * { + BinaryInst * createOrInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kOr, Type::getIntType(), lhs, rhs, name); } ///< 创建按位或指令 - auto createCallInst(Function *callee, const std::vector &args, const std::string &name = "") -> CallInst * { + CallInst * createCallInst(Function *callee, const std::vector &args, const std::string &name = "") { std::string newName; if (name.empty() && callee->getReturnType() != Type::getVoidType()) { std::stringstream ss; @@ -235,40 +233,38 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建Call指令 - auto createReturnInst(Value *value = nullptr, const std::string &name = "") -> ReturnInst * { + ReturnInst * createReturnInst(Value *value = nullptr, const std::string &name = "") { auto inst = new ReturnInst(value, block, name); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建return指令 - auto createUncondBrInst(BasicBlock *thenBlock, const std::vector &args) -> UncondBrInst * { + UncondBrInst * createUncondBrInst(BasicBlock *thenBlock, const std::vector &args) { auto inst = new UncondBrInst(thenBlock, args, block); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建无条件指令 - auto createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock, - const std::vector &thenArgs, const std::vector &elseArgs) -> CondBrInst * { + CondBrInst * createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock, + const std::vector &thenArgs, const std::vector &elseArgs) { auto inst = new CondBrInst(condition, thenBlock, elseBlock, thenArgs, elseArgs, block); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建条件跳转指令 - auto createAllocaInst(Type *type, const std::vector &dims = {}, const std::string &name = "") - -> AllocaInst * { + AllocaInst * createAllocaInst(Type *type, const std::vector &dims = {}, const std::string &name = "") { auto inst = new AllocaInst(type, dims, block, name); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建分配指令 - auto createAllocaInstWithoutInsert(Type *type, const std::vector &dims = {}, BasicBlock *parent = nullptr, - const std::string &name = "") -> AllocaInst * { + AllocaInst * createAllocaInstWithoutInsert(Type *type, const std::vector &dims = {}, BasicBlock *parent = nullptr, + const std::string &name = "") { auto inst = new AllocaInst(type, dims, parent, name); assert(inst); return inst; } ///< 创建不插入指令列表的分配指令 - auto createLoadInst(Value *pointer, const std::vector &indices = {}, const std::string &name = "") - -> LoadInst * { + LoadInst * createLoadInst(Value *pointer, const std::vector &indices = {}, const std::string &name = "") { std::string newName; if (name.empty()) { std::stringstream ss; @@ -284,8 +280,7 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建load指令 - auto createLaInst(Value *pointer, const std::vector &indices = {}, const std::string &name = "") - -> LaInst * { + LaInst * createLaInst(Value *pointer, const std::vector &indices = {}, const std::string &name = "") { std::string newName; if (name.empty()) { std::stringstream ss; @@ -301,8 +296,7 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建la指令 - auto createGetSubArray(LVal *fatherArray, const std::vector &indices, const std::string &name = "") - -> GetSubArrayInst * { + GetSubArrayInst * createGetSubArray(LVal *fatherArray, const std::vector &indices, const std::string &name = "") { assert(fatherArray->getLValNumDims() > indices.size()); std::vector subDims; auto dims = fatherArray->getLValDims(); @@ -326,21 +320,20 @@ class IRBuilder { block->getInstructions().emplace(position, inst); return inst; } ///< 创建获取部分数组指令 - auto createMemsetInst(Value *pointer, Value *begin, Value *size, Value *value, const std::string &name = "") - -> MemsetInst * { + MemsetInst * createMemsetInst(Value *pointer, Value *begin, Value *size, Value *value, const std::string &name = "") { auto inst = new MemsetInst(pointer, begin, size, value, block, name); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建memset指令 - auto createStoreInst(Value *value, Value *pointer, const std::vector &indices = {}, - const std::string &name = "") -> StoreInst * { + StoreInst * createStoreInst(Value *value, Value *pointer, const std::vector &indices = {}, + const std::string &name = "") { auto inst = new StoreInst(value, pointer, indices, block, name); assert(inst); block->getInstructions().emplace(position, inst); return inst; } ///< 创建store指令 - auto createPhiInst(Type *type, Value *lhs, BasicBlock *parent, const std::string &name = "") -> PhiInst * { + PhiInst * createPhiInst(Type *type, Value *lhs, BasicBlock *parent, const std::string &name = "") { auto predNum = parent->getNumPredecessors(); std::vector rhs; for (size_t i = 0; i < predNum; i++) {