From 1e6f6ed711d9c14d7f5c718048d6aa945bd49734 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Fri, 25 Jul 2025 03:26:10 +0800 Subject: [PATCH] =?UTF-8?q?[midend]=20GEP=E7=B1=BB=E5=9E=8B=E6=8E=A8?= =?UTF-8?q?=E6=96=AD=E5=87=BD=E6=95=B0getIndexedType=E9=80=BB=E8=BE=91?= =?UTF-8?q?=E4=BF=AE=E5=A4=8D=EF=BC=8C=E5=A2=9E=E5=8A=A0=E6=95=B0=E7=BB=84?= =?UTF-8?q?type=E7=BC=93=E5=AD=98=E6=B1=A0=E9=81=BF=E5=85=8D=E7=9B=B8?= =?UTF-8?q?=E5=90=8Ctype=20=3D=3D=E6=93=8D=E4=BD=9C=E8=BF=94=E5=9B=9E?= =?UTF-8?q?=E5=81=87=EF=BC=8C=E4=BF=AE=E5=A4=8D=E5=AE=9E=E5=8F=82=E5=BD=A2?= =?UTF-8?q?=E5=8F=82=E7=B1=BB=E5=9E=8B=E8=BD=AC=E6=8D=A2=E5=88=A4=E6=96=AD?= =?UTF-8?q?=E9=80=BB=E8=BE=91=EF=BC=8Cstarttime=20stoptime=E6=8F=90?= =?UTF-8?q?=E4=BE=9B=E6=94=AF=E6=8C=81=EF=BC=88=E5=BE=85=E5=90=8E=E7=AB=AF?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/IR.cpp | 13 ++++++-- src/SysYIRGenerator.cpp | 65 +++++++++++++++++++++++++++---------- src/include/IRBuilder.h | 71 +++++++++++++++-------------------------- 3 files changed, 85 insertions(+), 64 deletions(-) diff --git a/src/IR.cpp b/src/IR.cpp index c694839..da4292b 100644 --- a/src/IR.cpp +++ b/src/IR.cpp @@ -105,8 +105,17 @@ FunctionType*FunctionType::get(Type *returnType, const std::vector ¶ } ArrayType *ArrayType::get(Type *elementType, unsigned numElements) { - // TODO:可以考虑在这里添加缓存，避免重复创建相同的数组类型 - return new ArrayType(elementType, numElements); + static std::set> arrayTypes; + auto iter = std::find_if(arrayTypes.begin(), arrayTypes.end(), [&](const std::unique_ptr &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) { diff --git a/src/SysYIRGenerator.cpp b/src/SysYIRGenerator.cpp index 7618d18..09b1214 100644 --- a/src/SysYIRGenerator.cpp +++ b/src/SysYIRGenerator.cpp @@ -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 args = {}; if (funcName == "starttime" || funcName == "stoptime") { - // 如果是starttime或stoptime函数 - // TODO: 这里需要处理starttime和stoptime函数的参数 - // args.emplace_back() + args.emplace_back( + ConstantInteger::get(static_cast(ctx->getStart()->getLine()))); } else { if (ctx->funcRParams() != nullptr) { args = std::any_cast>(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()->getBaseType() != args[i]->getType())) { - ConstantValue * constValue = dynamic_cast(args[i]); + // 形参的类型 (e.g., i32, float, i32*, [10 x i32]*) + Type* formalParamExpectedValueType = formalParamsAlloca[i]->getType()->as()->getBaseType(); + // 实参的实际类型 (e.g., i32, float, i32*, [67 x i32]*) + Type* actualArgType = args[i]->getType(); + // 如果实参类型与形参类型不匹配，则尝试进行类型转换 + if (formalParamExpectedValueType != actualArgType) { + ConstantValue *constValue = dynamic_cast(args[i]); if (constValue != nullptr) { - if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) { - args[i] = ConstantInteger::get(static_cast(constValue->getInt())); + if (formalParamExpectedValueType->isInt() && actualArgType->isFloat()) { + args[i] = ConstantInteger::get(static_cast(constValue->getFloat())); + } else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) { + args[i] = ConstantFloating::get(static_cast(constValue->getInt())); } else { - args[i] = ConstantFloating::get(static_cast(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."); } } } diff --git a/src/include/IRBuilder.h b/src/include/IRBuilder.h index 49941fd..d9e92ef 100644 --- a/src/include/IRBuilder.h +++ b/src/include/IRBuilder.h @@ -347,68 +347,47 @@ class IRBuilder { static Type *getIndexedType(Type *pointerType, const std::vector &indices) { assert(pointerType->isPointer() && "base must be a pointer type!"); - // Type *CurrentType = pointerType->as()->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()->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()->getElementType(); - // } else if (currentWalkType->isStruct()) { - // // 情况2：当前类型是结构体类型。 - // // 此时，索引必须是一个常量整数，用于选择结构体中的特定成员。 - // // SysY 语言通常只支持数组，但如果你的 IR 支持结构体，这里需要实现。 - // ConstantInteger* structIdx = dynamic_cast(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()->getNumMembers() && "Struct index out of bounds!"); - // currentWalkType = currentWalkType->as()->getMemberType(structIdx->getInt()); + } else if (currentWalkType->isPointer()) { + // 情况二：当前遍历类型是 `PointerType`。 + // 这意味着我们正在通过一个指针来访问其指向的内存。 + // 索引用于选择该指针所指向的“数组”的元素。 + // `currentWalkType` 更新为该指针所指向的基础类型。 + // 例如：如果 `currentWalkType` 是 `i32*`，它将变为 `i32`。 + // 如果 `currentWalkType` 是 `[10 x i32]*`，它将变为 `[10 x i32]`。 + currentWalkType = currentWalkType->as()->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; } };