diff --git a/src/IR.cpp b/src/IR.cpp index ebd61c1..1483bf3 100644 --- a/src/IR.cpp +++ b/src/IR.cpp @@ -598,11 +598,11 @@ auto SymbolTable::addVariable(const std::string &name, User *variable) -> User * std::stringstream ss; auto iter = variableIndex.find(name); if (iter != variableIndex.end()) { - ss << name << "(" << iter->second << ")"; + ss << name << iter->second ; iter->second += 1; } else { variableIndex.emplace(name, 1); - ss << name << "(" << 0 << ")"; + ss << name << 0 ; } variable->setName(ss.str()); @@ -665,42 +665,6 @@ void SymbolTable::leaveScope() { curNode = curNode->pNode; } */ auto SymbolTable::isInGlobalScope() const -> bool { return curNode->pNode == nullptr; } -/** - * @brief 判断是否为循环不变量 - * @param value: 要判断的value - * @return true: 是不变量 - * @return false: 不是 - */ -auto Loop::isSimpleLoopInvariant(Value *value) -> bool { - // auto constValue = dynamic_cast(value); - // if (constValue != nullptr) { - // return false; - // } - if (auto instr = dynamic_cast(value)) { - if (instr->isLoad()) { - auto loadinst = dynamic_cast(instr); - - auto loadvalue = dynamic_cast(loadinst->getOperand(0)); - if (loadvalue != nullptr) { - if (loadvalue->getParent() != nullptr) { - auto basicblock = loadvalue->getParent(); - return !this->isLoopContainsBasicBlock(basicblock); - } - } - auto globalvalue = dynamic_cast(loadinst->getOperand(0)); - if (globalvalue != nullptr) { - return true; - } - auto basicblock = instr->getParent(); - - return !this->isLoopContainsBasicBlock(basicblock); - } - auto basicblock = instr->getParent(); - return !this->isLoopContainsBasicBlock(basicblock); - } - return true; -} - /** * @brief 移动指令 * diff --git a/src/SysYIRPrinter.cpp b/src/SysYIRPrinter.cpp index 4812106..04be4da 100644 --- a/src/SysYIRPrinter.cpp +++ b/src/SysYIRPrinter.cpp @@ -128,12 +128,15 @@ void SysYPrinter::printFunction(Function *function) { std::cout << " @" << function->getName() << "("; auto entryBlock = function->getEntryBlock(); + const auto &args_types = function->getParamTypes(); auto &args = entryBlock->getArguments(); - for (size_t i = 0; i < args.size(); i++) { + int i = 0; + for (const auto &args_type : args_types) { if (i > 0) std::cout << ", "; - printType(args[i]->getType()); + printType(args_type); std::cout << " %" << args[i]->getName(); + i++; } std::cout << ") {" << std::endl; diff --git a/src/include/IR.h b/src/include/IR.h index 25f44ed..dbf12cc 100644 --- a/src/include/IR.h +++ b/src/include/IR.h @@ -317,7 +317,6 @@ class ConstantValue : public Value { class Instruction; class Function; -class Loop; class BasicBlock; /*! @@ -327,104 +326,73 @@ class BasicBlock; * a terminator (branch or return). Besides, `BasicBlock` stores its arguments * and records its predecessor and successor `BasicBlock`s. */ - - class BasicBlock : public Value { +class BasicBlock : public Value { friend class Function; - public: +public: + using inst_list = std::list>; using iterator = inst_list::iterator; using arg_list = std::vector; using block_list = std::vector; using block_set = std::unordered_set; - protected: +protected: + Function *parent; ///< 从属的函数 inst_list instructions; ///< 拥有的指令序列 arg_list arguments; ///< 分配空间后的形式参数列表 block_list successors; ///< 前驱列表 block_list predecessors; ///< 后继列表 - BasicBlock *idom = nullptr; ///< 直接支配结点，即支配树前驱，唯一，默认nullptr - block_list sdoms; ///< 支配树后继，可以有多个 - block_set dominants; ///< 必经结点集合 - block_set dominant_frontiers; ///< 支配边界 - bool reachable = false; ///< 用于表示该节点是否可达，默认不可达 - Loop *loopbelong = nullptr; ///< 用来表示该块属于哪个循环，唯一，默认nullptr - int loopdepth = 0; /// < 用来表示其归属循环的深度，默认0 + bool reachable = false; - public: +public: explicit BasicBlock(Function *parent, const std::string &name = "") : Value(Type::getLabelType(), name), parent(parent) {} - ~BasicBlock() override { for (auto pre : predecessors) { pre->removeSuccessor(this); } - for (auto suc : successors) { suc->removePredecessor(this); } - } ///< 基本块的析构函数，同时删除其前驱后继关系 + } + +public: - public: - 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; } ///< 设置父函数 - 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); } ///< 插入分配空间后的形式参数 + 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; } + inst_list& getInstructions() { return instructions; } + arg_list& getArguments() { return arguments; } + const block_list& getPredecessors() const { return predecessors; } + block_list& getSuccessors() { return successors; } + iterator begin() { return instructions.begin(); } + iterator end() { return instructions.end(); } + iterator terminator() { return std::prev(end()); } + void insertArgument(AllocaInst *inst) { arguments.push_back(inst); } void addPredecessor(BasicBlock *block) { if (std::find(predecessors.begin(), predecessors.end(), block) == predecessors.end()) { predecessors.push_back(block); } - } ///< 添加前驱 + } void addSuccessor(BasicBlock *block) { if (std::find(successors.begin(), successors.end(), block) == successors.end()) { successors.push_back(block); } - } ///< 添加后继 + } void addPredecessor(const block_list &blocks) { for (auto block : blocks) { addPredecessor(block); } - } ///< 添加多个前驱 + } void addSuccessor(const block_list &blocks) { for (auto block : blocks) { addSuccessor(block); } - } ///< 添加多个后继 - void setIdom(BasicBlock *block) { idom = block; } - void addSdoms(BasicBlock *block) { sdoms.push_back(block); } - void clearSdoms() { sdoms.clear(); } - // 重载1，参数为 BasicBlock* - void addDominants(BasicBlock *block) { dominants.emplace(block); } - // 重载2，参数为 block_set - void addDominants(const block_set &blocks) { dominants.insert(blocks.begin(), blocks.end()); } - void setDominants(BasicBlock *block) { - dominants.clear(); - addDominants(block); - } - void setDominants(const block_set &doms) { - dominants.clear(); - addDominants(doms); - } - void setDFs(const block_set &df) { - dominant_frontiers.clear(); - for (auto elem : df) { - dominant_frontiers.emplace(elem); - } } void removePredecessor(BasicBlock *block) { auto iter = std::find(predecessors.begin(), predecessors.end(), block); @@ -433,7 +401,7 @@ class BasicBlock; } else { assert(false); } - } ///< 删除前驱 + } void removeSuccessor(BasicBlock *block) { auto iter = std::find(successors.begin(), successors.end(), block); if (iter != successors.end()) { @@ -441,7 +409,7 @@ class BasicBlock; } else { assert(false); } - } ///< 删除后继 + } void replacePredecessor(BasicBlock *oldBlock, BasicBlock *newBlock) { for (auto &predecessor : predecessors) { if (predecessor == oldBlock) { @@ -449,41 +417,16 @@ class BasicBlock; break; } } - } ///< 替换前驱 - // 获取支配树中该块的所有子节点，包括子节点的子节点等，迭代实现 - block_list getChildren() { - std::queue q; - block_list children; - for (auto sdom : sdoms) { - q.push(sdom); - children.push_back(sdom); - } - while (!q.empty()) { - auto block = q.front(); - q.pop(); - for (auto sdom : block->sdoms) { - q.push(sdom); - children.push_back(sdom); - } - } - - return children; } - 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; } ///< 设置所属循环 - Loop* getLoop() { return loopbelong; } ///< 获得所属循环 - void setLoopDepth(int loopdepth2set) { loopdepth = loopdepth2set; } ///< 设置循环深度 - int getLoopDepth() { return loopdepth; } ///< 获得其在循环的深度 - void removeInst(iterator pos) { instructions.erase(pos); } ///< 删除指令 - iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block); ///< 移动指令 + } + void removeInst(iterator pos) { instructions.erase(pos); } + iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block); }; //! User is the abstract base type of `Value` types which use other `Value` as @@ -1198,109 +1141,11 @@ public: class GlobalValue; -// 循环类 -class Loop { -public: - using block_list = std::vector; - using block_set = std::unordered_set; - using Loop_list = std::vector; - -protected: - Function *parent; // 所属函数 - block_list blocksInLoop; // 循环内的基本块 - BasicBlock *preheaderBlock = nullptr; // 前驱块 - BasicBlock *headerBlock = nullptr; // 循环头 - block_list latchBlock; // 回边块 - block_set exitingBlocks; // 退出块 - block_set exitBlocks; // 退出目标块 - Loop *parentloop = nullptr; // 父循环 - Loop_list subLoops; // 子循环 - size_t loopID; // 循环ID - unsigned loopDepth; // 循环深度 - - Instruction *indCondVar = nullptr; // 循环条件变量 - Instruction::Kind IcmpKind; // 比较类型 - Value *indEnd = nullptr; // 循环结束值 - AllocaInst *IndPhi = nullptr; // 循环变量 - - ConstantValue *indBegin = nullptr; // 循环起始值 - ConstantValue *indStep = nullptr; // 循环步长 - - std::set GlobalValuechange; // 循环内改变的全局变量 - - int StepType = 0; // 循环步长类型 - bool parallelable = false; // 是否可并行 - -public: - explicit Loop(BasicBlock *header, const std::string &name = "") - : headerBlock(header) { - blocksInLoop.push_back(header); - } - - void setloopID() { - static unsigned loopCount = 0; - loopCount = loopCount + 1; - loopID = loopCount; - } - 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; } - 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; } - unsigned getLoopDepth() const { return loopDepth; } - - bool isLoopContainsBasicBlock(BasicBlock *bb) const { - return std::find(blocksInLoop.begin(), blocksInLoop.end(), bb) != blocksInLoop.end(); - } ///< 判断输入块是否在该循环内 - - void addExitingBlock(BasicBlock *bb) { exitingBlocks.insert(bb); } - void addExitBlock(BasicBlock *bb) { exitBlocks.insert(bb); } - void addLatchBlock(BasicBlock *bb) { latchBlock.push_back(bb); } - void setPreheaderBlock(BasicBlock *bb) { preheaderBlock = bb; } - - void setIndexCondInstr(Instruction *instr) { indCondVar = instr; } - void setIcmpKind(Instruction::Kind kind) { IcmpKind = kind; } - Instruction::Kind getIcmpKind() const { return IcmpKind; } - - bool isSimpleLoopInvariant(Value *value) ; ///< 判断是否为简单循环不变量，若其在loop中，则不是。 - - 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; } - - void addGlobalValuechange(GlobalValue *globalvaluechange2add) { - GlobalValuechange.insert(globalvaluechange2add); - } ///<添加在循环中改变的全局变量 - std::set& getGlobalValuechange() { - return GlobalValuechange; - } ///<获得在循环中改变的所有全局变量 - - void setParallelable(bool flag) { parallelable = flag; } - bool isParallelable() const { return parallelable; } -}; class Module; -//! Function definition +//! Function definitionclass class Function : public Value { friend class Module; - protected: Function(Module *parent, Type *type, const std::string &name) : Value(type, name), parent(parent) { blocks.emplace_back(new BasicBlock(this)); @@ -1308,9 +1153,6 @@ protected: public: using block_list = std::list>; - using Loop_list = std::list>; - - // 函数优化属性标识符 enum FunctionAttribute : uint64_t { PlaceHolder = 0x0UL, Pure = 0x1UL << 0, @@ -1322,167 +1164,47 @@ public: protected: Module *parent; ///< 函数的父模块 block_list blocks; ///< 函数包含的基本块列表 - Loop_list loops; ///< 函数包含的循环列表 - Loop_list topLoops; ///< 函数所包含的顶层循环； - std::list> indirectAllocas; ///< 函数中mem2reg引入的间接分配的内存 - FunctionAttribute attribute = PlaceHolder; ///< 函数属性 std::set callees; ///< 函数调用的函数集合 - - std::unordered_map basicblock2Loop; - std::unordered_map value2AllocBlocks; ///< value -- alloc block mapping - std::unordered_map> - value2DefBlocks; //< value -- define blocks mapping - std::unordered_map> value2UseBlocks; //< value -- use blocks mapping - - public: + public: static unsigned getcloneIndex() { static unsigned cloneIndex = 0; cloneIndex += 1; return cloneIndex - 1; } - Function* clone(const std::string &suffix = "_" + std::to_string(getcloneIndex()) + "@") const; ///< 复制函数 + 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; } ///< 获取函数属性 + FunctionAttribute getAttribute() const { return attribute; } void setAttribute(FunctionAttribute attr) { attribute = static_cast(attribute | attr); - } ///< 设置函数属性 - void clearAttribute() { attribute = PlaceHolder; } ///< 清楚所有函数属性，只保留PlaceHolder - Loop* getLoopOfBasicBlock(BasicBlock *bb) { - return basicblock2Loop.count(bb) != 0 ? basicblock2Loop[bb] : nullptr; - } ///< 获得块所在循环 - unsigned getLoopDepthByBlock(BasicBlock *basicblock2Check) { - if (getLoopOfBasicBlock(basicblock2Check) != nullptr) { - auto loop = getLoopOfBasicBlock(basicblock2Check); - return loop->getLoopDepth(); - } - return static_cast(0); - } ///< 通过块，获得其所在循环深度 - void addBBToLoop(BasicBlock *bb, Loop *LoopToadd) { basicblock2Loop[bb] = LoopToadd; } ///< 添加块与循环的映射 - std::unordered_map& getBBToLoopRef() { - return basicblock2Loop; - } ///< 获得块-循环映射表 - // auto getNewLoopPtr(BasicBlock *header) -> Loop * { return new Loop(header); } - Type* getReturnType() const { return getType()->as()->getReturnType(); } ///< 获取返回值类型 - auto getParamTypes() const { return getType()->as()->getParamTypes(); } ///< 获取形式参数类型列表 - auto getBasicBlocks() { return make_range(blocks); } ///< 获取基本块列表 + } + void clearAttribute() { attribute = PlaceHolder; } + Type* getReturnType() const { return getType()->as()->getReturnType(); } + auto getParamTypes() const { return getType()->as()->getParamTypes(); } + auto getBasicBlocks() { return make_range(blocks); } block_list& getBasicBlocks_NoRange() { return blocks; } - BasicBlock* getEntryBlock() { return blocks.front().get(); } ///< 获取入口块 + 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; } + } BasicBlock* addBasicBlock(const std::string &name = "") { blocks.emplace_back(new BasicBlock(this, name)); return blocks.back().get(); - } ///< 添加新的基本块 + } BasicBlock* addBasicBlock(BasicBlock *block) { blocks.emplace_back(block); return block; - } ///< 添加基本块到blocks中 + } BasicBlock* addBasicBlockFront(BasicBlock *block) { blocks.emplace_front(block); return block; - } // 从前端插入新的基本块 - /** value -- alloc blocks mapping */ - void addValue2AllocBlocks(Value *value, BasicBlock *block) { - value2AllocBlocks[value] = block; - } ///< 添加value -- alloc block mapping - BasicBlock* getAllocBlockByValue(Value *value) { - if (value2AllocBlocks.count(value) > 0) { - return value2AllocBlocks[value]; - } - return nullptr; - } ///< 通过value获取alloc block - std::unordered_map& getValue2AllocBlocks() { - return value2AllocBlocks; - } ///< 获取所有value -- alloc block mappings - void removeValue2AllocBlock(Value *value) { - value2AllocBlocks.erase(value); - } ///< 删除value -- alloc block mapping - /** value -- define blocks mapping */ - void addValue2DefBlocks(Value *value, BasicBlock *block) { - ++value2DefBlocks[value][block]; - } ///< 添加value -- define block mapping - // keep in mind that the return is not a reference. - std::unordered_set getDefBlocksByValue(Value *value) { - std::unordered_set blocks; - if (value2DefBlocks.count(value) > 0) { - for (const auto &pair : value2DefBlocks[value]) { - blocks.insert(pair.first); - } - } - return blocks; - } ///< 通过value获取define blocks - std::unordered_map>& getValue2DefBlocks() { - return value2DefBlocks; - } ///< 获取所有value -- define blocks mappings - bool removeValue2DefBlock(Value *value, BasicBlock *block) { - bool changed = false; - if (--value2DefBlocks[value][block] == 0) { - value2DefBlocks[value].erase(block); - if (value2DefBlocks[value].empty()) { - value2DefBlocks.erase(value); - changed = true; - } - } - return changed; - } ///< 删除value -- define block mapping - std::unordered_set getValuesOfDefBlock() { - std::unordered_set values; - for (const auto &pair : value2DefBlocks) { - values.insert(pair.first); - } - return values; - } ///< 获取所有定义过的value - /** value -- use blocks mapping */ - void addValue2UseBlocks(Value *value, BasicBlock *block) { - ++value2UseBlocks[value][block]; - } ///< 添加value -- use block mapping - // keep in mind that the return is not a reference. - std::unordered_set getUseBlocksByValue(Value *value) { - std::unordered_set blocks; - if (value2UseBlocks.count(value) > 0) { - for (const auto &pair : value2UseBlocks[value]) { - blocks.insert(pair.first); - } - } - return blocks; - } ///< 通过value获取use blocks - std::unordered_map>& getValue2UseBlocks() { - return value2UseBlocks; - } ///< 获取所有value -- use blocks mappings - bool removeValue2UseBlock(Value *value, BasicBlock *block) { - bool changed = false; - if (--value2UseBlocks[value][block] == 0) { - value2UseBlocks[value].erase(block); - if (value2UseBlocks[value].empty()) { - value2UseBlocks.erase(value); - changed = true; - } - } - return changed; - } ///< 删除value -- use block mapping - void addIndirectAlloca(AllocaInst *alloca) { indirectAllocas.emplace_back(alloca); } ///< 添加间接分配 - std::list>& getIndirectAllocas() { - return indirectAllocas; - } ///< 获取间接分配列表 - - /** loop -- begin */ - - void addLoop(Loop *loop) { loops.emplace_back(loop); } ///< 添加循环（非顶层） - void addTopLoop(Loop *loop) { topLoops.emplace_back(loop); } ///< 添加顶层循环 - Loop_list& getLoops() { return loops; } ///< 获得循环（非顶层） - Loop_list& getTopLoops() { return topLoops; } ///< 获得顶层循环 - /** loop -- end */ - -}; // class Function + } +}; //! Global value declared at file scope class GlobalValue : public User, public LVal {