750 lines
24 KiB
C++
750 lines
24 KiB
C++
#include "IR.h"
|
||
#include <algorithm>
|
||
#include <cassert>
|
||
#include <memory>
|
||
#include <queue>
|
||
#include <set>
|
||
#include <sstream>
|
||
#include <vector>
|
||
#include "IRBuilder.h"
|
||
|
||
/**
|
||
* @file IR.cpp
|
||
*
|
||
* @brief 定义IR相关类型与操作的源文件
|
||
*/
|
||
namespace sysy {
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// Types
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
auto Type::getIntType() -> Type * {
|
||
static Type intType(kInt);
|
||
return &intType;
|
||
}
|
||
|
||
auto Type::getFloatType() -> Type * {
|
||
static Type floatType(kFloat);
|
||
return &floatType;
|
||
}
|
||
|
||
auto Type::getVoidType() -> Type * {
|
||
static Type voidType(kVoid);
|
||
return &voidType;
|
||
}
|
||
|
||
auto Type::getLabelType() -> Type * {
|
||
static Type labelType(kLabel);
|
||
return &labelType;
|
||
}
|
||
|
||
auto Type::getPointerType(Type *baseType) -> Type * {
|
||
// forward to PointerType
|
||
return PointerType::get(baseType);
|
||
}
|
||
|
||
auto Type::getFunctionType(Type *returnType, const std::vector<Type *> ¶mTypes) -> Type * {
|
||
// forward to FunctionType
|
||
return FunctionType::get(returnType, paramTypes);
|
||
}
|
||
|
||
auto Type::getArrayType(Type *elementType, unsigned numElements) -> Type * {
|
||
// forward to ArrayType
|
||
return ArrayType::get(elementType, numElements);
|
||
}
|
||
|
||
auto Type::getSize() const -> unsigned {
|
||
switch (kind) {
|
||
case kInt:
|
||
case kFloat:
|
||
return 4;
|
||
case kLabel:
|
||
case kPointer:
|
||
case kFunction:
|
||
return 8;
|
||
case Kind::kArray: {
|
||
const ArrayType* arrType = static_cast<const ArrayType*>(this);
|
||
return arrType->getElementType()->getSize() * arrType->getNumElements();
|
||
}
|
||
case kVoid:
|
||
return 0;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
PointerType* PointerType::get(Type *baseType) {
|
||
static std::map<Type *, std::unique_ptr<PointerType>> pointerTypes;
|
||
auto iter = pointerTypes.find(baseType);
|
||
if (iter != pointerTypes.end()) {
|
||
return iter->second.get();
|
||
}
|
||
auto type = new PointerType(baseType);
|
||
assert(type);
|
||
auto result = pointerTypes.emplace(baseType, type);
|
||
return result.first->second.get();
|
||
}
|
||
|
||
FunctionType*FunctionType::get(Type *returnType, const std::vector<Type *> ¶mTypes) {
|
||
static std::set<std::unique_ptr<FunctionType>> functionTypes;
|
||
auto iter =
|
||
std::find_if(functionTypes.begin(), functionTypes.end(), [&](const std::unique_ptr<FunctionType> &type) -> bool {
|
||
if (returnType != type->getReturnType() ||
|
||
paramTypes.size() != static_cast<size_t>(type->getParamTypes().size())) {
|
||
return false;
|
||
}
|
||
return std::equal(paramTypes.begin(), paramTypes.end(), type->getParamTypes().begin());
|
||
});
|
||
if (iter != functionTypes.end()) {
|
||
return iter->get();
|
||
}
|
||
auto type = new FunctionType(returnType, paramTypes);
|
||
assert(type);
|
||
auto result = functionTypes.emplace(type);
|
||
return result.first->get();
|
||
}
|
||
|
||
ArrayType *ArrayType::get(Type *elementType, unsigned numElements) {
|
||
static std::set<std::unique_ptr<ArrayType>> arrayTypes;
|
||
auto iter = std::find_if(arrayTypes.begin(), arrayTypes.end(), [&](const std::unique_ptr<ArrayType> &type) -> bool {
|
||
return elementType == type->getElementType() && numElements == type->getNumElements();
|
||
});
|
||
if (iter != arrayTypes.end()) {
|
||
return iter->get();
|
||
}
|
||
auto type = new ArrayType(elementType, numElements);
|
||
assert(type);
|
||
auto result = arrayTypes.emplace(type);
|
||
return result.first->get();
|
||
}
|
||
|
||
void Value::replaceAllUsesWith(Value *value) {
|
||
for (auto &use : uses) {
|
||
use->getUser()->setOperand(use->getIndex(), value);
|
||
}
|
||
uses.clear();
|
||
}
|
||
|
||
|
||
// Implementations for static members
|
||
|
||
std::unordered_map<ConstantValueKey, ConstantValue*, ConstantValueHash, ConstantValueEqual> ConstantValue::mConstantPool;
|
||
std::unordered_map<Type*, UndefinedValue*> UndefinedValue::UndefValues;
|
||
|
||
ConstantValue* ConstantValue::get(Type* type, ConstantValVariant val) {
|
||
ConstantValueKey key = {type, val};
|
||
auto it = mConstantPool.find(key);
|
||
if (it != mConstantPool.end()) {
|
||
return it->second;
|
||
}
|
||
|
||
ConstantValue* newConstant = nullptr;
|
||
if (std::holds_alternative<int>(val)) {
|
||
newConstant = new ConstantInteger(type, std::get<int>(val));
|
||
} else if (std::holds_alternative<float>(val)) {
|
||
newConstant = new ConstantFloating(type, std::get<float>(val));
|
||
} else {
|
||
assert(false && "Unsupported ConstantValVariant type");
|
||
}
|
||
|
||
mConstantPool[key] = newConstant;
|
||
return newConstant;
|
||
}
|
||
|
||
ConstantInteger* ConstantInteger::get(Type* type, int val) {
|
||
return dynamic_cast<ConstantInteger*>(ConstantValue::get(type, val));
|
||
}
|
||
|
||
ConstantFloating* ConstantFloating::get(Type* type, float val) {
|
||
return dynamic_cast<ConstantFloating*>(ConstantValue::get(type, val));
|
||
}
|
||
|
||
UndefinedValue* UndefinedValue::get(Type* type) {
|
||
assert(!type->isVoid() && "Cannot get UndefinedValue of void type!");
|
||
|
||
auto it = UndefValues.find(type);
|
||
if (it != UndefValues.end()) {
|
||
return it->second;
|
||
}
|
||
|
||
UndefinedValue* newUndef = new UndefinedValue(type);
|
||
UndefValues[type] = newUndef;
|
||
return newUndef;
|
||
}
|
||
|
||
|
||
auto Function::getCalleesWithNoExternalAndSelf() -> std::set<Function *> {
|
||
std::set<Function *> result;
|
||
for (auto callee : callees) {
|
||
if (parent->getExternalFunctions().count(callee->getName()) == 0U && callee != this) {
|
||
result.insert(callee);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 函数克隆，后续函数级优化（内联等）需要用到
|
||
Function * Function::clone(const std::string &suffix) const {
|
||
std::stringstream ss;
|
||
std::map<BasicBlock *, BasicBlock *> oldNewBlockMap;
|
||
IRBuilder builder;
|
||
auto newFunction = new Function(parent, type, name);
|
||
newFunction->getEntryBlock()->setName(blocks.front()->getName());
|
||
oldNewBlockMap.emplace(blocks.front().get(), newFunction->getEntryBlock());
|
||
auto oldBlockListIter = std::next(blocks.begin());
|
||
while (oldBlockListIter != blocks.end()) {
|
||
auto newBlock = newFunction->addBasicBlock(oldBlockListIter->get()->getName());
|
||
oldNewBlockMap.emplace(oldBlockListIter->get(), newBlock);
|
||
oldBlockListIter++;
|
||
}
|
||
|
||
for (const auto &oldNewBlockItem : oldNewBlockMap) {
|
||
auto oldBlock = oldNewBlockItem.first;
|
||
auto newBlock = oldNewBlockItem.second;
|
||
for (const auto &oldPred : oldBlock->getPredecessors()) {
|
||
newBlock->addPredecessor(oldNewBlockMap.at(oldPred));
|
||
}
|
||
for (const auto &oldSucc : oldBlock->getSuccessors()) {
|
||
newBlock->addSuccessor(oldNewBlockMap.at(oldSucc));
|
||
}
|
||
}
|
||
|
||
std::map<Value *, Value *> oldNewValueMap;
|
||
std::map<Value *, bool> isAddedToCreate;
|
||
std::map<Value *, bool> isCreated;
|
||
std::queue<Value *> toCreate;
|
||
|
||
for (const auto &oldBlock : blocks) {
|
||
for (const auto &inst : oldBlock->getInstructions()) {
|
||
isAddedToCreate.emplace(inst.get(), false);
|
||
isCreated.emplace(inst.get(), false);
|
||
}
|
||
}
|
||
for (const auto &oldBlock : blocks) {
|
||
for (const auto &inst : oldBlock->getInstructions()) {
|
||
for (const auto &valueUse : inst->getOperands()) {
|
||
auto value = valueUse->getValue();
|
||
if (oldNewValueMap.find(value) == oldNewValueMap.end()) {
|
||
auto oldAllocInst = dynamic_cast<AllocaInst *>(value);
|
||
if (oldAllocInst != nullptr) {
|
||
std::vector<Value *> dims;
|
||
// TODO: 这里的dims用type推断
|
||
// for (const auto &dim : oldAllocInst->getDims()) {
|
||
// dims.emplace_back(dim->getValue());
|
||
// }
|
||
ss << oldAllocInst->getName() << suffix;
|
||
auto newAllocInst =
|
||
new AllocaInst(oldAllocInst->getType(), oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
|
||
ss.str("");
|
||
oldNewValueMap.emplace(oldAllocInst, newAllocInst);
|
||
if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) {
|
||
isAddedToCreate.emplace(oldAllocInst, true);
|
||
} else {
|
||
isAddedToCreate.at(oldAllocInst) = true;
|
||
}
|
||
if (isCreated.find(oldAllocInst) == isCreated.end()) {
|
||
isCreated.emplace(oldAllocInst, true);
|
||
} else {
|
||
isCreated.at(oldAllocInst) = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (inst->getKind() == Instruction::kAlloca) {
|
||
if (oldNewValueMap.find(inst.get()) == oldNewValueMap.end()) {
|
||
auto oldAllocInst = dynamic_cast<AllocaInst *>(inst.get());
|
||
std::vector<Value *> dims;
|
||
// TODO: 这里的dims用type推断
|
||
// for (const auto &dim : oldAllocInst->getDims()) {
|
||
// dims.emplace_back(dim->getValue());
|
||
// }
|
||
ss << oldAllocInst->getName() << suffix;
|
||
auto newAllocInst =
|
||
new AllocaInst(oldAllocInst->getType(), oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
|
||
ss.str("");
|
||
oldNewValueMap.emplace(oldAllocInst, newAllocInst);
|
||
if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) {
|
||
isAddedToCreate.emplace(oldAllocInst, true);
|
||
} else {
|
||
isAddedToCreate.at(oldAllocInst) = true;
|
||
}
|
||
if (isCreated.find(oldAllocInst) == isCreated.end()) {
|
||
isCreated.emplace(oldAllocInst, true);
|
||
} else {
|
||
isCreated.at(oldAllocInst) = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (const auto &oldBlock : blocks) {
|
||
for (const auto &inst : oldBlock->getInstructions()) {
|
||
for (const auto &valueUse : inst->getOperands()) {
|
||
auto value = valueUse->getValue();
|
||
if (oldNewValueMap.find(value) == oldNewValueMap.end()) {
|
||
auto globalValue = dynamic_cast<GlobalValue *>(value);
|
||
auto constVariable = dynamic_cast<ConstantVariable *>(value);
|
||
auto constantValue = dynamic_cast<ConstantValue *>(value);
|
||
auto functionValue = dynamic_cast<Function *>(value);
|
||
if (globalValue != nullptr || constantValue != nullptr || constVariable != nullptr ||
|
||
functionValue != nullptr) {
|
||
if (functionValue == this) {
|
||
oldNewValueMap.emplace(value, newFunction);
|
||
} else {
|
||
oldNewValueMap.emplace(value, value);
|
||
}
|
||
isCreated.emplace(value, true);
|
||
isAddedToCreate.emplace(value, true);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (const auto &oldBlock : blocks) {
|
||
for (const auto &inst : oldBlock->getInstructions()) {
|
||
if (inst->getKind() != Instruction::kAlloca) {
|
||
bool isReady = true;
|
||
for (const auto &use : inst->getOperands()) {
|
||
auto value = use->getValue();
|
||
if (dynamic_cast<BasicBlock *>(value) == nullptr && !isCreated.at(value)) {
|
||
isReady = false;
|
||
break;
|
||
}
|
||
}
|
||
if (isReady) {
|
||
toCreate.push(inst.get());
|
||
isAddedToCreate.at(inst.get()) = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
while (!toCreate.empty()) {
|
||
auto inst = dynamic_cast<Instruction *>(toCreate.front());
|
||
toCreate.pop();
|
||
|
||
bool isReady = true;
|
||
for (const auto &valueUse : inst->getOperands()) {
|
||
auto value = dynamic_cast<Instruction *>(valueUse->getValue());
|
||
if (value != nullptr && !isCreated.at(value)) {
|
||
isReady = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!isReady) {
|
||
toCreate.push(inst);
|
||
continue;
|
||
}
|
||
isCreated.at(inst) = true;
|
||
switch (inst->getKind()) {
|
||
case Instruction::kAdd:
|
||
case Instruction::kSub:
|
||
case Instruction::kMul:
|
||
case Instruction::kDiv:
|
||
case Instruction::kRem:
|
||
case Instruction::kICmpEQ:
|
||
case Instruction::kICmpNE:
|
||
case Instruction::kICmpLT:
|
||
case Instruction::kICmpGT:
|
||
case Instruction::kICmpLE:
|
||
case Instruction::kICmpGE:
|
||
case Instruction::kAnd:
|
||
case Instruction::kOr:
|
||
case Instruction::kFAdd:
|
||
case Instruction::kFSub:
|
||
case Instruction::kFMul:
|
||
case Instruction::kFDiv:
|
||
case Instruction::kFCmpEQ:
|
||
case Instruction::kFCmpNE:
|
||
case Instruction::kFCmpLT:
|
||
case Instruction::kFCmpGT:
|
||
case Instruction::kFCmpLE:
|
||
case Instruction::kFCmpGE: {
|
||
auto oldBinaryInst = dynamic_cast<BinaryInst *>(inst);
|
||
auto lhs = oldBinaryInst->getLhs();
|
||
auto rhs = oldBinaryInst->getRhs();
|
||
Value *newLhs;
|
||
Value *newRhs;
|
||
newLhs = oldNewValueMap[lhs];
|
||
newRhs = oldNewValueMap[rhs];
|
||
ss << oldBinaryInst->getName() << suffix;
|
||
auto newBinaryInst = new BinaryInst(oldBinaryInst->getKind(), oldBinaryInst->getType(), newLhs, newRhs,
|
||
oldNewBlockMap.at(oldBinaryInst->getParent()), ss.str());
|
||
ss.str("");
|
||
oldNewValueMap.emplace(oldBinaryInst, newBinaryInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kNeg:
|
||
case Instruction::kNot:
|
||
case Instruction::kFNeg:
|
||
case Instruction::kFNot:
|
||
case Instruction::kItoF:
|
||
case Instruction::kFtoI: {
|
||
auto oldUnaryInst = dynamic_cast<UnaryInst *>(inst);
|
||
auto hs = oldUnaryInst->getOperand();
|
||
Value *newHs;
|
||
newHs = oldNewValueMap.at(hs);
|
||
ss << oldUnaryInst->getName() << suffix;
|
||
auto newUnaryInst = new UnaryInst(oldUnaryInst->getKind(), oldUnaryInst->getType(), newHs,
|
||
oldNewBlockMap.at(oldUnaryInst->getParent()), ss.str());
|
||
ss.str("");
|
||
oldNewValueMap.emplace(oldUnaryInst, newUnaryInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kCall: {
|
||
auto oldCallInst = dynamic_cast<CallInst *>(inst);
|
||
std::vector<Value *> newArgumnts;
|
||
for (const auto &arg : oldCallInst->getArguments()) {
|
||
newArgumnts.emplace_back(oldNewValueMap.at(arg->getValue()));
|
||
}
|
||
|
||
ss << oldCallInst->getName() << suffix;
|
||
CallInst *newCallInst;
|
||
newCallInst =
|
||
new CallInst(oldCallInst->getCallee(), newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()), ss.str());
|
||
ss.str("");
|
||
// if (oldCallInst->getCallee() != this) {
|
||
// newCallInst = new CallInst(oldCallInst->getCallee(), newArgumnts,
|
||
// oldNewBlockMap.at(oldCallInst->getParent()),
|
||
// oldCallInst->getName());
|
||
// } else {
|
||
// newCallInst = new CallInst(newFunction, newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()),
|
||
// oldCallInst->getName());
|
||
// }
|
||
|
||
oldNewValueMap.emplace(oldCallInst, newCallInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kCondBr: {
|
||
auto oldCondBrInst = dynamic_cast<CondBrInst *>(inst);
|
||
auto oldCond = oldCondBrInst->getCondition();
|
||
Value *newCond;
|
||
newCond = oldNewValueMap.at(oldCond);
|
||
auto newCondBrInst = new CondBrInst(newCond, oldNewBlockMap.at(oldCondBrInst->getThenBlock()),
|
||
oldNewBlockMap.at(oldCondBrInst->getElseBlock()),
|
||
oldNewBlockMap.at(oldCondBrInst->getParent()));
|
||
oldNewValueMap.emplace(oldCondBrInst, newCondBrInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kBr: {
|
||
auto oldBrInst = dynamic_cast<UncondBrInst *>(inst);
|
||
auto newBrInst =
|
||
new UncondBrInst(oldNewBlockMap.at(oldBrInst->getBlock()), oldNewBlockMap.at(oldBrInst->getParent()));
|
||
oldNewValueMap.emplace(oldBrInst, newBrInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kReturn: {
|
||
auto oldReturnInst = dynamic_cast<ReturnInst *>(inst);
|
||
auto oldRval = oldReturnInst->getReturnValue();
|
||
Value *newRval = nullptr;
|
||
if (oldRval != nullptr) {
|
||
newRval = oldNewValueMap.at(oldRval);
|
||
}
|
||
auto newReturnInst =
|
||
new ReturnInst(newRval, oldNewBlockMap.at(oldReturnInst->getParent()), oldReturnInst->getName());
|
||
oldNewValueMap.emplace(oldReturnInst, newReturnInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kAlloca: {
|
||
assert(false);
|
||
}
|
||
|
||
case Instruction::kLoad: {
|
||
auto oldLoadInst = dynamic_cast<LoadInst *>(inst);
|
||
auto oldPointer = oldLoadInst->getPointer();
|
||
Value *newPointer;
|
||
newPointer = oldNewValueMap.at(oldPointer);
|
||
|
||
std::vector<Value *> newIndices;
|
||
// for (const auto &index : oldLoadInst->getIndices()) {
|
||
// newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
|
||
// }
|
||
ss << oldLoadInst->getName() << suffix;
|
||
// TODO : 这里的newLoadInst的类型需要根据oldLoadInst的类型来推断
|
||
auto newLoadInst = new LoadInst(newPointer, oldNewBlockMap.at(oldLoadInst->getParent()), ss.str());
|
||
ss.str("");
|
||
oldNewValueMap.emplace(oldLoadInst, newLoadInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kStore: {
|
||
auto oldStoreInst = dynamic_cast<StoreInst *>(inst);
|
||
auto oldPointer = oldStoreInst->getPointer();
|
||
auto oldValue = oldStoreInst->getValue();
|
||
Value *newPointer;
|
||
Value *newValue;
|
||
std::vector<Value *> newIndices;
|
||
newPointer = oldNewValueMap.at(oldPointer);
|
||
newValue = oldNewValueMap.at(oldValue);
|
||
// TODO: 这里的newIndices需要根据oldStoreInst的类型来推断
|
||
// for (const auto &index : oldStoreInst->getIndices()) {
|
||
// newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
|
||
// }
|
||
auto newStoreInst = new StoreInst(newValue, newPointer,
|
||
oldNewBlockMap.at(oldStoreInst->getParent()), oldStoreInst->getName());
|
||
oldNewValueMap.emplace(oldStoreInst, newStoreInst);
|
||
break;
|
||
}
|
||
|
||
// TODO：复制GEP指令
|
||
|
||
case Instruction::kMemset: {
|
||
auto oldMemsetInst = dynamic_cast<MemsetInst *>(inst);
|
||
auto oldPointer = oldMemsetInst->getPointer();
|
||
auto oldValue = oldMemsetInst->getValue();
|
||
Value *newPointer;
|
||
Value *newValue;
|
||
newPointer = oldNewValueMap.at(oldPointer);
|
||
newValue = oldNewValueMap.at(oldValue);
|
||
|
||
auto newMemsetInst = new MemsetInst(newPointer, oldMemsetInst->getBegin(), oldMemsetInst->getSize(), newValue,
|
||
oldNewBlockMap.at(oldMemsetInst->getParent()), oldMemsetInst->getName());
|
||
oldNewValueMap.emplace(oldMemsetInst, newMemsetInst);
|
||
break;
|
||
}
|
||
|
||
case Instruction::kInvalid:
|
||
case Instruction::kPhi: {
|
||
break;
|
||
}
|
||
|
||
default:
|
||
assert(false);
|
||
}
|
||
for (const auto &userUse : inst->getUses()) {
|
||
auto user = userUse->getUser();
|
||
if (!isAddedToCreate.at(user)) {
|
||
toCreate.push(user);
|
||
isAddedToCreate.at(user) = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
for (const auto &oldBlock : blocks) {
|
||
auto newBlock = oldNewBlockMap.at(oldBlock.get());
|
||
builder.setPosition(newBlock, newBlock->end());
|
||
for (const auto &inst : oldBlock->getInstructions()) {
|
||
builder.insertInst(dynamic_cast<Instruction *>(oldNewValueMap.at(inst.get())));
|
||
}
|
||
}
|
||
|
||
// for (const auto ¶m : blocks.front()->getArguments()) {
|
||
// newFunction->getEntryBlock()->insertArgument(dynamic_cast<AllocaInst *>(oldNewValueMap.at(param)));
|
||
// }
|
||
for (const auto &arg : arguments) {
|
||
auto newArg = dynamic_cast<Argument *>(oldNewValueMap.at(arg));
|
||
if (newArg != nullptr) {
|
||
newFunction->insertArgument(newArg);
|
||
}
|
||
}
|
||
|
||
return newFunction;
|
||
}
|
||
/**
|
||
* 设置操作数
|
||
*/
|
||
void User::setOperand(unsigned index, Value *value) {
|
||
assert(index < getNumOperands());
|
||
operands[index]->setValue(value);
|
||
value->addUse(operands[index]);
|
||
}
|
||
/**
|
||
* 替换操作数
|
||
*/
|
||
void User::replaceOperand(unsigned index, Value *value) {
|
||
assert(index < getNumOperands());
|
||
auto &use = operands[index];
|
||
use->getValue()->removeUse(use);
|
||
use->setValue(value);
|
||
value->addUse(use);
|
||
}
|
||
|
||
/**
|
||
* phi相关函数
|
||
*/
|
||
|
||
Value* PhiInst::getvalfromBlk(BasicBlock* blk){
|
||
refreshB2VMap();
|
||
if( blk2val.find(blk) != blk2val.end()) {
|
||
return blk2val.at(blk);
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
BasicBlock* PhiInst::getBlkfromVal(Value* val){
|
||
// 返回第一个值对应的基本块
|
||
for(unsigned i = 0; i < vsize; i++) {
|
||
if(getValue(i) == val) {
|
||
return getBlock(i);
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
void PhiInst::delValue(Value* val){
|
||
//根据value删除对应的基本块和值
|
||
unsigned i = 0;
|
||
BasicBlock* blk = getBlkfromVal(val);
|
||
for(i = 0; i < vsize; i++) {
|
||
if(getValue(i) == val) {
|
||
break;
|
||
}
|
||
}
|
||
removeOperand(2 * i + 1); // 删除blk
|
||
removeOperand(2 * i); // 删除val
|
||
vsize--;
|
||
blk2val.erase(blk); // 删除blk2val映射
|
||
}
|
||
|
||
void PhiInst::delBlk(BasicBlock* blk){
|
||
//根据Blk删除对应的基本块和值
|
||
unsigned i = 0;
|
||
Value* val = getvalfromBlk(blk);
|
||
for(i = 0; i < vsize; i++) {
|
||
if(getBlock(i) == blk) {
|
||
break;
|
||
}
|
||
}
|
||
removeOperand(2 * i + 1); // 删除blk
|
||
removeOperand(2 * i); // 删除val
|
||
vsize--;
|
||
blk2val.erase(blk); // 删除blk2val映射
|
||
}
|
||
|
||
void PhiInst::replaceBlk(BasicBlock* newBlk, unsigned k){
|
||
refreshB2VMap();
|
||
BasicBlock* oldBlk = getBlock(k);
|
||
Value* val = blk2val.at(oldBlk);
|
||
// Value* val = blk2val.at(getBlock(k));
|
||
// 替换基本块
|
||
setOperand(2 * k + 1, newBlk);
|
||
// 替换blk2val映射
|
||
blk2val.erase(oldBlk);
|
||
blk2val.emplace(newBlk, val);
|
||
}
|
||
|
||
void PhiInst::replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk){
|
||
refreshB2VMap();
|
||
Value* val = blk2val.at(oldBlk);
|
||
// 替换基本块
|
||
delBlk(oldBlk);
|
||
addIncoming(val, newBlk);
|
||
}
|
||
|
||
void PhiInst::refreshB2VMap(){
|
||
blk2val.clear();
|
||
for(unsigned i = 0; i < vsize; i++) {
|
||
blk2val.emplace(getBlock(i), getValue(i));
|
||
}
|
||
}
|
||
|
||
CallInst::CallInst(Function *callee, const std::vector<Value *> &args, BasicBlock *parent, const std::string &name)
|
||
: Instruction(kCall, callee->getReturnType(), parent, name) {
|
||
addOperand(callee);
|
||
for (auto arg : args) {
|
||
addOperand(arg);
|
||
}
|
||
}
|
||
/**
|
||
* 获取被调用函数的指针
|
||
*/
|
||
Function * CallInst::getCallee() const { return dynamic_cast<Function *>(getOperand(0)); }
|
||
|
||
/**
|
||
* 获取变量指针
|
||
* 如果在当前作用域或父作用域中找到变量，则返回该变量的指针，否则返回nullptr
|
||
*/
|
||
auto SymbolTable::getVariable(const std::string &name) const -> Value * {
|
||
auto node = curNode;
|
||
while (node != nullptr) {
|
||
auto iter = node->varList.find(name);
|
||
if (iter != node->varList.end()) {
|
||
return iter->second;
|
||
}
|
||
node = node->pNode;
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
/**
|
||
* 添加变量到符号表
|
||
*/
|
||
auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value * {
|
||
Value *result = nullptr;
|
||
if (curNode != nullptr) {
|
||
std::stringstream ss;
|
||
auto iter = variableIndex.find(name);
|
||
if (iter != variableIndex.end()) {
|
||
ss << name << iter->second ;
|
||
iter->second += 1;
|
||
} else {
|
||
variableIndex.emplace(name, 1);
|
||
ss << name << 0 ;
|
||
}
|
||
|
||
variable->setName(ss.str());
|
||
curNode->varList.emplace(name, variable);
|
||
auto global = dynamic_cast<GlobalValue *>(variable);
|
||
auto constvar = dynamic_cast<ConstantVariable *>(variable);
|
||
if (global != nullptr) {
|
||
globals.emplace_back(global);
|
||
} else if (constvar != nullptr) {
|
||
globalconsts.emplace_back(constvar);
|
||
}
|
||
|
||
result = variable;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
/**
|
||
* 获取全局变量
|
||
*/
|
||
auto SymbolTable::getGlobals() -> std::vector<std::unique_ptr<GlobalValue>> & { return globals; }
|
||
/**
|
||
* 获取常量
|
||
*/
|
||
auto SymbolTable::getConsts() const -> const std::vector<std::unique_ptr<ConstantVariable>> & { return globalconsts; }
|
||
/**
|
||
* 进入新的作用域
|
||
*/
|
||
void SymbolTable::enterNewScope() {
|
||
auto newNode = new SymbolTableNode;
|
||
nodeList.emplace_back(newNode);
|
||
if (curNode != nullptr) {
|
||
curNode->children.emplace_back(newNode);
|
||
}
|
||
newNode->pNode = curNode;
|
||
curNode = newNode;
|
||
}
|
||
/**
|
||
* 进入全局作用域
|
||
*/
|
||
void SymbolTable::enterGlobalScope() { curNode = nodeList.front().get(); }
|
||
/**
|
||
* 离开作用域
|
||
*/
|
||
void SymbolTable::leaveScope() { curNode = curNode->pNode; }
|
||
/**
|
||
* 是否位于全局作用域
|
||
*/
|
||
auto SymbolTable::isInGlobalScope() const -> bool { return curNode->pNode == nullptr; }
|
||
|
||
/**
|
||
*移动指令
|
||
*/
|
||
auto BasicBlock::moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block) -> iterator {
|
||
auto inst = sourcePos->release();
|
||
inst->setParent(block);
|
||
block->instructions.emplace(targetPos, inst);
|
||
return instructions.erase(sourcePos);
|
||
}
|
||
|
||
} // namespace sysy
|