gh0s7/mysysy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[midend] GEP类型推断函数getIndexedType逻辑修复，增加数组type缓存池避免相同type ==操作返回假，修复实参形参类型转换判断逻辑，starttime stoptime提供支持（待后端测试）

Browse Source
This commit is contained in:
rain2133
2025-07-25 03:26:10 +08:00
parent 96c6b0ab6e
commit 1e6f6ed711
3 changed files with 85 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/IR.cpp
View File

@ -105,8 +105,17 @@ FunctionType*FunctionType::get(Type *returnType, const std::vector<Type *> &para
}
ArrayType *ArrayType::get(Type *elementType, unsigned numElements) {
// TODO:可以考虑在这里添加缓存，避免重复创建相同的数组类型
return new ArrayType(elementType, 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) {

65
src/SysYIRGenerator.cpp
View File

@ -770,6 +770,7 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
if (allocatedType->isPointer()) {
// 如果 AllocaInst 分配的是一个指针类型 (例如，用于存储函数参数的指针，如 int b[][20] 中的 b)
// 即 `allocatedType` 是一个指向数组指针的指针 (e.g., [20 x i32]**)
// 那么 GEP 的基指针是加载这个指针变量的值。
gepBasePointer = builder.createLoadInst(alloc); // 加载出实际的指针值 (e.g., [20 x i32]*)
// 对于这种参数指针，用户提供的索引直接作用于它。不需要额外的 0。
@ -777,6 +778,7 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
} else {
// 如果 AllocaInst 分配的是实际的数组数据 (例如，int b[10][20] 中的 b)
// 那么 AllocaInst 本身就是 GEP 的基指针。
// 这里的 `alloc` 是指向数组的指针 (e.g., [10 x [20 x i32]]*)
gepBasePointer = alloc; // 类型是 [10 x [20 x i32]]*
// 对于这种完整的数组分配，GEP 的第一个索引必须是 0，用于“步过”整个数组。
gepIndices.push_back(ConstantInteger::get(0));
@ -856,32 +858,63 @@ std::any SysYIRGenerator::visitCall(SysYParser::CallContext *ctx) {
std::vector<Value *> args = {};
if (funcName == "starttime" || funcName == "stoptime") {
// 如果是starttime或stoptime函数
// TODO: 这里需要处理starttime和stoptime函数的参数
// args.emplace_back()
args.emplace_back(
ConstantInteger::get(static_cast<int>(ctx->getStart()->getLine())));
} else {
if (ctx->funcRParams() != nullptr) {
args = std::any_cast<std::vector<Value *>>(visitFuncRParams(ctx->funcRParams()));
}
auto params = function->getEntryBlock()->getArguments();
// 获取形参列表。`getArguments()` 返回的是 `Argument*` 的集合，
// 每个 `Argument` 代表一个函数形参，其 `getType()` 就是指向形参的类型的指针类型。
auto formalParamsAlloca = function->getEntryBlock()->getArguments();
// 检查实参和形参数量是否匹配。
if (args.size() != formalParamsAlloca.size()) {
std::cerr << "Error: Function call argument count mismatch for function '" << funcName << "'." << std::endl;
assert(false && "Function call argument count mismatch!");
}
for (int i = 0; i < args.size(); i++) {
// 参数类型转换
if (params[i]->getType() != args[i]->getType() &&
(params[i]->getNumDims() != 0 ||
params[i]->getType()->as<PointerType>()->getBaseType() != args[i]->getType())) {
ConstantValue * constValue = dynamic_cast<ConstantValue *>(args[i]);
// 形参的类型 (e.g., i32, float, i32*, [10 x i32]*)
Type* formalParamExpectedValueType = formalParamsAlloca[i]->getType()->as<PointerType>()->getBaseType();
// 实参的实际类型 (e.g., i32, float, i32*, [67 x i32]*)
Type* actualArgType = args[i]->getType();
// 如果实参类型与形参类型不匹配，则尝试进行类型转换
if (formalParamExpectedValueType != actualArgType) {
ConstantValue *constValue = dynamic_cast<ConstantValue *>(args[i]);
if (constValue != nullptr) {
if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
args[i] = ConstantInteger::get(static_cast<float>(constValue->getInt()));
if (formalParamExpectedValueType->isInt() && actualArgType->isFloat()) {
args[i] = ConstantInteger::get(static_cast<int>(constValue->getFloat()));
} else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) {
args[i] = ConstantFloating::get(static_cast<float>(constValue->getInt()));
} else {
args[i] = ConstantFloating::get(static_cast<int>(constValue->getFloat()));
// 如果是常量但不是简单的 int/float 标量转换，
// 或者是指针常量需要 bitcast，则让它进入非常量转换逻辑。
// 例如，一个常量数组的地址，需要 bitcast 成另一种指针类型。
// 目前不知道样例有没有这种情况，所以这里不做处理。
}
} else {
if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
args[i] = builder.createIToFInst(args[i]);
} else {
}
else {
// 1. 标量值类型转换 (例如：int_reg 到 float_reg，float_reg 到 int_reg)
if (formalParamExpectedValueType->isInt() && actualArgType->isFloat()) {
args[i] = builder.createFtoIInst(args[i]);
} else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) {
args[i] = builder.createIToFInst(args[i]);
}
// 2. 指针类型转换 (例如数组退化：`[N x T]*` 到 `T*`，或兼容指针类型之间) TODO：不清楚有没有这种样例
// 这种情况常见于数组参数，实参可能是一个更具体的数组指针类型，
// 而形参是其退化后的基础指针类型。LLVM 的 `bitcast` 指令可以用于
// 在相同大小的指针类型之间进行转换，这对于数组退化至关重要。
// else if (formalParamType->isPointer() && actualArgType->isPointer()) {
// 检查指针基类型是否兼容，或者是否是数组退化导致的类型不同。
// 使用 bitcast，
// args[i] = builder.createBitCastInst(args[i], formalParamType);
// }
// 3. 其他未预期的类型不匹配
// 如果代码执行到这里，说明存在编译器前端未处理的类型不兼容或错误。
else {
// assert(false && "Unhandled type mismatch for function call argument.");
}
}
}

71
src/include/IRBuilder.h
View File

@ -347,68 +347,47 @@ class IRBuilder {
static Type *getIndexedType(Type *pointerType, const std::vector<Value *> &indices) {
assert(pointerType->isPointer() && "base must be a pointer type!");
// Type *CurrentType = pointerType->as<PointerType>()->getBaseType();
// GEP 的类型推断从基指针所指向的类型开始。
// 例如：
// - 如果 pointerType 是 `[20 x [10 x i32]]*` (指向一个二维数组的指针)，
// 那么 `currentWalkType` 将从 `[20 x [10 x i32]]` (二维数组类型) 开始。
// - 如果 pointerType 是 `i32*` (指向一个整数的指针)，
// 那么 `currentWalkType` 将从 `i32` (整数类型) 开始。
// - 如果 pointerType 是 `[20 x [10 x i32]]*`，`currentWalkType` 初始为 `[20 x [10 x i32]]`。
// - 如果 pointerType 是 `i32*`，`currentWalkType` 初始为 `i32`。
// - 如果 pointerType 是 `i32**`，`currentWalkType` 初始为 `i32*`。
Type *currentWalkType = pointerType->as<PointerType>()->getBaseType();
// 遍历所有索引来深入类型层次结构。
// 注意：这里的 `indices` 向量通常已经包含了 `getGEPAddressInst` 添加的第一个“步过”索引（通常是0）。
// 因此，`indices[0]` 对应的是 GEP 操作的第一个逻辑步骤。
// `indices` 向量包含了所有 GEP 索引，包括由 `visitLValue` 等函数添加的初始 `0` 索引。
for (int i = 0; i < indices.size(); ++i) {
if (currentWalkType->isArray()) {
// 情况1：当前类型是数组类型 (例如 `[20 x [10 x i32]]` 或 `[10 x i32]`)。
// 此时，当前的索引用于选择数组中的一个元素（或子数组）。
// 新的 `currentWalkType` 变为该数组的元素类型。
// 例如：`[20 x [10 x i32]]` 经过一个索引后，变为 `[10 x i32]`。
// 情况一：当前遍历类型是 `ArrayType`。
// 索引用于选择数组元素，`currentWalkType` 更新为数组的元素类型。
currentWalkType = currentWalkType->as<ArrayType>()->getElementType();
// } else if (currentWalkType->isStruct()) {
// // 情况2：当前类型是结构体类型。
// // 此时，索引必须是一个常量整数，用于选择结构体中的特定成员。
// // SysY 语言通常只支持数组，但如果你的 IR 支持结构体，这里需要实现。
// ConstantInteger* structIdx = dynamic_cast<ConstantInteger*>(indices[i]);
// assert(structIdx && "Struct index must be a constant integer!");
// assert(structIdx->getInt() >= 0 && "Struct index cannot be negative!");
// // 确保 `StructType` 类有 `getNumMembers()` 和 `getMemberType()` 方法。
// // 如果你的 Type 系统没有这些方法，需要根据实际情况调整。
// assert(structIdx->getInt() < currentWalkType->as<StructType>()->getNumMembers() && "Struct index out of bounds!");
// currentWalkType = currentWalkType->as<StructType>()->getMemberType(structIdx->getInt());
} else if (currentWalkType->isPointer()) {
// 情况二：当前遍历类型是 `PointerType`。
// 这意味着我们正在通过一个指针来访问其指向的内存。
// 索引用于选择该指针所指向的“数组”的元素。
// `currentWalkType` 更新为该指针所指向的基础类型。
// 例如：如果 `currentWalkType` 是 `i32*`，它将变为 `i32`。
// 如果 `currentWalkType` 是 `[10 x i32]*`，它将变为 `[10 x i32]`。
currentWalkType = currentWalkType->as<PointerType>()->getBaseType();
} else {
// 情况3：当前类型既不是数组也不是结构体（即它是一个标量类型，如 `i32` 或 `float`）。
// 情况三：当前遍历类型是标量类型 (例如 `i32`, `float` 等非聚合、非指针类型)。
//
// 如果 `currentWalkType` 是一个标量类型，并且**后面还有未处理的索引** (`i < indices.size() - 1`)，
// 这意味着我们试图对一个标量类型进行进一步的结构性索引，这是**无效的**。
// 例如：`int* ptr; ptr[0][0];`
// - `ptr` 的类型是 `int*`。
// - `currentWalkType` 初始化为 `int`。
// - `i = 0` 时，`currentWalkType` 是 `int`。它不是数组/结构体，类型不变。
// - `i = 1` 时，`currentWalkType` 仍然是 `int`。此时 `i < indices.size() - 1` (即 `1 < 2 - 1 = 1`) 为假。
// 因为 `indices.size()` 是 2 (`[0, 0]`)，`i` 是 1。`i < indices.size() - 1` 是 `1 < 1`，为假。
// 所以不会触发断言，`currentWalkType` 保持 `int`。这是正确的。
// 如果 `currentWalkType` 是标量，并且当前索引 `i` **不是** `indices` 向量中的最后一个索引，
// 这意味着尝试对一个标量类型进行进一步的结构性索引，这是**无效的**。
// 例如：`int x; x[0];` 对应的 GEP 链中，`x` 的类型是 `i32`，再加 `[0]` 索引就是错误。
//
// 让我重新检查一下 `if (i > 0)` 和 `if (i < indices.size() - 1)` 的区别。
// 原始的 `if (i > 0)` 导致 `arr[1]` 失败是因为 `currentWalkType` 变成 `int` 后，
// `i=1` 触发了断言。
//
// LLVM GEP 的行为是：如果当前类型是标量，并且这是 GEP 的**最后一个索引**，那么 GEP 是合法的，
// 最终的类型就是这个标量类型。如果不是最后一个索引，则报错。
// 修正后的判断：
// 如果当前类型是标量，并且当前索引 `i` 不是 `indices` 向量中的**最后一个索引**，
// 那么就意味着尝试对标量进行额外的结构性索引，这是错误的。
// 如果 `currentWalkType` 是标量，且这是**最后一个索引** (`i == indices.size() - 1`)，
// 那么 GEP 是合法的，它只是计算一个偏移地址，最终的类型就是这个标量类型。
// 此时 `currentWalkType` 保持不变，循环结束。
if (i < indices.size() - 1) {
assert(false && "Invalid GEP indexing: attempting to index into a non-aggregate type with further indices.");
assert(false && "Invalid GEP indexing: attempting to index into a non-aggregate/non-pointer type with further indices.");
return nullptr; // 返回空指针表示类型推断失败
}
// 如果 `currentWalkType` 是标量，并且这是最后一个索引，则类型保持不变。
// 这是合法的 GEP 操作，例如 `getelementptr i32, i32* %ptr, i64 5`。
// `currentWalkType` 将是 `i32`，并且循环会在此结束。
// 如果是最后一个索引，且当前类型是标量，则类型保持不变，这是合法的。
// 循环会自然结束，返回正确的 `currentWalkType`。
}
}
// 所有索引处理完毕后，`currentWalkType` 就是 GEP 指令最终计算出的地址所指向的元素的类型。
return currentWalkType;
}
};