From 848f096578b7148f632369730243a17bd29bd48e Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Thu, 28 Dec 2023 08:55:03 +0000 Subject: Update types for i686 target --- .../compiler/backends/llvm/LlvmTarget.java | 28 +- .../backends/llvm/codegen/PatioToLlvm.java | 293 ++++++++++++++------- .../llvm/codegen/PatioToLlvmFunctionContext.java | 5 + .../llvm/codegen/PatioToLlvmGlobalContext.java | 12 +- .../llvm/codegen/PatioToLlvmModuleContext.java | 6 +- 5 files changed, 239 insertions(+), 105 deletions(-) (limited to 'src/main/java') diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmTarget.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmTarget.java index ea462382..35159998 100644 --- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmTarget.java +++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmTarget.java @@ -1,18 +1,28 @@ package org.shedlang.compiler.backends.llvm; +import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypeScalar; +import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypes; + import java.util.List; public enum LlvmTarget { - AMD64("amd64", "x86_64-unknown-linux-gnu", List.of()), - I686("i686", "i686-unknown-linux-gnu", List.of("-m32")); + AMD64("amd64", "x86_64-unknown-linux-gnu", LlvmTypes.INT_64, List.of()), + I686("i686", "i686-unknown-linux-gnu", LlvmTypes.INT_32, List.of("-m32")); private final String targetName; private final String targetTriple; + private final LlvmTypeScalar sizeT; private final List clangFlags; - LlvmTarget(String targetName, String targetTriple, List clangFlags) { + LlvmTarget( + String targetName, + String targetTriple, + LlvmTypeScalar sizeT, + List clangFlags + ) { this.targetName = targetName; this.targetTriple = targetTriple; + this.sizeT = sizeT; this.clangFlags = clangFlags; } @@ -24,6 +34,18 @@ public enum LlvmTarget { return this.targetTriple; } + public LlvmTypeScalar sizeT() { + return this.sizeT; + } + + public LlvmTypeScalar patioIntType() { + return this.sizeT; + } + + public LlvmTypeScalar cIntType() { + return LlvmTypes.INT_32; + } + public List clangFlags() { return this.clangFlags; } diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvm.java b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvm.java index 545a4e2f..025dc602 100644 --- a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvm.java +++ b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvm.java @@ -3,6 +3,7 @@ package org.shedlang.compiler.backends.llvm.codegen; import org.pcollections.PVector; import org.pcollections.TreePVector; import org.shedlang.compiler.backends.llvm.LlvmCodeGenLocalVariableSpace; +import org.shedlang.compiler.backends.llvm.LlvmTarget; import org.shedlang.compiler.backends.llvm.codegen.errors.SizeofJmpBufError; import org.shedlang.compiler.backends.llvm.ir.ast.*; import org.shedlang.compiler.backends.llvm.ir.ast.instructions.*; @@ -26,24 +27,30 @@ import java.util.Optional; import java.util.stream.StreamSupport; public class PatioToLlvm { - private static final LlvmFunctionDeclaration ALLOC_DECLARATION = new LlvmFunctionDeclaration( - "shed__runtime__gc_alloc", - LlvmTypes.pointer(LlvmTypes.INT_8), - List.of( - new LlvmParam(LlvmTypes.INT_64, "size"), - new LlvmParam(LlvmTypes.INT_64, "children_offset"), - new LlvmParam(LlvmTypes.INT_64, "children_count") - ) - ); + private static LlvmFunctionDeclaration allocDeclaration(LlvmTarget platformTarget) { + return new LlvmFunctionDeclaration( + "shed__runtime__gc_alloc", + LlvmTypes.pointer(LlvmTypes.INT_8), + List.of( + new LlvmParam(platformTarget.sizeT(), "size"), + new LlvmParam(platformTarget.sizeT(), "children_offset"), + new LlvmParam(platformTarget.sizeT(), "children_count") + ) + ); + } private static final LlvmType EXCEPTION_TAG_TYPE = LlvmTypes.INT_32; - private static final LlvmType EXCEPTION_VALUE_TYPE = LlvmTypes.INT_64; + + private static LlvmType exceptionValueType(LlvmTarget platformTarget) { + return platformTarget.patioIntType(); + } private static final Lazy JMP_BUF_SIZE = Lazy.of(() -> readJmpBufSize()); private static int readJmpBufSize() { try { var sizeofJmpBufString = Files.readString( + // TODO: use jmp_buf size for target ShedCompilerFiles.getRoot().resolve("runtime/target/amd64/sizeof_jmp_buf.txt") ); return Integer.parseInt(sizeofJmpBufString.strip()); @@ -56,13 +63,15 @@ public class PatioToLlvm { return LlvmTypes.array(JMP_BUF_SIZE.get(), LlvmTypes.INT_8); } - private static final LlvmFunctionDeclaration SETJMP_DECLARATION = new LlvmFunctionDeclaration( - "_setjmp", - LlvmTypes.INT_32, - List.of( - new LlvmParam(LlvmTypes.pointer(LlvmTypes.VOID), "env") - ) - ); + private static LlvmFunctionDeclaration setjmpDeclaration(LlvmTarget platformTarget) { + return new LlvmFunctionDeclaration( + "_setjmp", + platformTarget.cIntType(), + List.of( + new LlvmParam(LlvmTypes.pointer(LlvmTypes.VOID), "env") + ) + ); + } private static final LlvmGlobalDefinition EXCEPTION_HANDLER_DECLARATION = new LlvmGlobalDefinition( "patio__runtime__exceptions_exception_handler", @@ -73,23 +82,27 @@ public class PatioToLlvm { false ); - private static final LlvmGlobalDefinition EXCEPTION_VALUE_DECLARATION = new LlvmGlobalDefinition( - "patio__runtime__exceptions_exception_value", - LlvmTypes.INT_64, - Optional.empty(), - false, - false, - false - ); + private static LlvmGlobalDefinition exceptionValueDeclaration(LlvmTarget platformTarget) { + return new LlvmGlobalDefinition( + "patio__runtime__exceptions_exception_value", + exceptionValueType(platformTarget), + Optional.empty(), + false, + false, + false + ); + } - private static final LlvmFunctionDeclaration THROW_DECLARATION = new LlvmFunctionDeclaration( - "patio__runtime__exceptions_throw", - LlvmTypes.pointer(LlvmTypes.VOID), - List.of( - new LlvmParam(EXCEPTION_TAG_TYPE, "exception_tag"), - new LlvmParam(EXCEPTION_VALUE_TYPE, "exception_value") - ) - ); + private static LlvmFunctionDeclaration throwDeclaration(LlvmTarget platformTarget) { + return new LlvmFunctionDeclaration( + "patio__runtime__exceptions_throw", + LlvmTypes.pointer(LlvmTypes.VOID), + List.of( + new LlvmParam(EXCEPTION_TAG_TYPE, "exception_tag"), + new LlvmParam(exceptionValueType(platformTarget), "exception_value") + ) + ); + } private static final LlvmFunctionDeclaration RETHROW_DECLARATION = new LlvmFunctionDeclaration( "patio__runtime__exceptions_rethrow", @@ -104,11 +117,11 @@ public class PatioToLlvm { PatioToLlvmGlobalContext globalContext ) { var context = globalContext.enterModule() - .addTopLevelEntity(ALLOC_DECLARATION) - .addTopLevelEntity(SETJMP_DECLARATION) + .addTopLevelEntity(allocDeclaration(globalContext.platformTarget())) + .addTopLevelEntity(setjmpDeclaration(globalContext.platformTarget())) .addTopLevelEntity(EXCEPTION_HANDLER_DECLARATION) - .addTopLevelEntity(EXCEPTION_VALUE_DECLARATION) - .addTopLevelEntity(THROW_DECLARATION) + .addTopLevelEntity(exceptionValueDeclaration(globalContext.platformTarget())) + .addTopLevelEntity(throwDeclaration(globalContext.platformTarget())) .addTopLevelEntity(RETHROW_DECLARATION); for (var patioCompilationUnitElement : patioCompilationUnit.elements()) { @@ -120,7 +133,10 @@ public class PatioToLlvm { case PatioFunctionDeclaration patioFunctionDeclaration -> { context = context.addFunctionNameToReturnType( patioFunctionDeclaration.name(), - patioTypeToLlvmType(patioFunctionDeclaration.returnType()) + patioTypeToLlvmType( + patioFunctionDeclaration.returnType(), + globalContext.platformTarget() + ) ); } case PatioExceptionTypeDefinition patioExceptionTypeDefinition -> { @@ -132,7 +148,10 @@ public class PatioToLlvm { case PatioFunctionDefinition patioFunctionDefinition -> { context = context.addFunctionNameToReturnType( patioFunctionDefinition.name(), - patioTypeToLlvmType(patioFunctionDefinition.returnType()) + patioTypeToLlvmType( + patioFunctionDefinition.returnType(), + globalContext.platformTarget() + ) ); } } @@ -173,8 +192,14 @@ public class PatioToLlvm { ) { return context.addTopLevelEntity(new LlvmGlobalDefinition( patioDataElementImmutable.name(), - patioDataLayoutToLlvmType(patioDataElementImmutable.value().layout()), - Optional.of(patioDataValueToLlvmOperand(patioDataElementImmutable.value())), + patioDataLayoutToLlvmType( + patioDataElementImmutable.value().layout(), + context.platformTarget() + ), + Optional.of(patioDataValueToLlvmOperand( + patioDataElementImmutable.value(), + context.platformTarget() + )), true, true, true @@ -187,8 +212,14 @@ public class PatioToLlvm { ) { return context.addTopLevelEntity(new LlvmGlobalDefinition( patioDataElementMutable.name(), - patioDataLayoutToLlvmType(patioDataElementMutable.initialValue().layout()), - Optional.of(patioDataValueToLlvmOperand(patioDataElementMutable.initialValue())), + patioDataLayoutToLlvmType( + patioDataElementMutable.initialValue().layout(), + context.platformTarget() + ), + Optional.of(patioDataValueToLlvmOperand( + patioDataElementMutable.initialValue(), + context.platformTarget() + )), false, true, true @@ -201,10 +232,13 @@ public class PatioToLlvm { ) { return context.addTopLevelEntity(new LlvmFunctionDeclaration( patioFunctionDeclaration.name(), - patioTypeToLlvmType(patioFunctionDeclaration.returnType()), + patioTypeToLlvmType( + patioFunctionDeclaration.returnType(), + context.platformTarget() + ), patioFunctionDeclaration.params().stream() .map(patioParam -> new LlvmParam( - patioTypeToLlvmType(patioParam.type()), + patioTypeToLlvmType(patioParam.type(), context.platformTarget()), patioParam.name() )) .toList() @@ -215,12 +249,14 @@ public class PatioToLlvm { PatioFunctionDefinition patioFunctionDefinition, PatioToLlvmModuleContext moduleContext ) { + var platformTarget = moduleContext.platformTarget(); + var functionContext = moduleContext.enterFunction(); for (var patioLocal : patioFunctionDefinition.locals()) { functionContext = functionContext.addPatioLocalToType( patioLocal.ref(), - patioTypeToLlvmType(patioLocal.type()) + patioTypeToLlvmType(patioLocal.type(), platformTarget) ); } for (var patioParam : patioFunctionDefinition.params()) { @@ -239,10 +275,16 @@ public class PatioToLlvm { return moduleContext.addTopLevelEntity(new LlvmFunctionDefinition( patioFunctionDefinition.name(), - patioTypeToLlvmType(patioFunctionDefinition.returnType()), + patioTypeToLlvmType( + patioFunctionDefinition.returnType(), + platformTarget + ), StreamSupport.stream(patioFunctionDefinition.params().spliterator(), false) .map(patioParam -> new LlvmParam( - patioTypeToLlvmType(patioParam.type()), + patioTypeToLlvmType( + patioParam.type(), + platformTarget + ), patioParam.name() )) .toList(), @@ -267,7 +309,11 @@ public class PatioToLlvm { ) { return switch (patioInstruction) { case PatioAllocHeap patioAllocHeap -> { - var sizeResult = sizeOf(patioDataLayoutToLlvmType(patioAllocHeap.layout()), context); + var llvmType = patioDataLayoutToLlvmType( + patioAllocHeap.layout(), + context.platformTarget() + ); + var sizeResult = sizeOf(llvmType, context); var size = sizeResult.value(); context = sizeResult.context(); @@ -283,7 +329,8 @@ public class PatioToLlvm { var offset = offsetResult.value(); context = offsetResult.context(); - yield context.addInstruction(ALLOC_DECLARATION.call( + var allocDeclaration = allocDeclaration(context.platformTarget()); + yield context.addInstruction(allocDeclaration.call( Optional.of(target), List.of( size, @@ -300,7 +347,10 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmAlloca( target, - patioDataLayoutToLlvmType(patioAllocStack.layout()) + patioDataLayoutToLlvmType( + patioAllocStack.layout(), + context.platformTarget() + ) )); } @@ -316,7 +366,7 @@ public class PatioToLlvm { target, LlvmTypes.INT_1, patioOperandToLlvmOperand(patioBoolToInt.value(), context), - LlvmTypes.INT_64 + context.platformTarget().patioIntType() )); } @@ -365,7 +415,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmPtrToInt( target, patioOperandToLlvmOperand(patioDataPtrToInt.value(), context), - LlvmTypes.INT_64 + context.platformTarget().patioIntType() )); } @@ -426,7 +476,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmAdd( target, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntAdd.left(), context), patioOperandToLlvmOperand(patioIntAdd.right(), context) )); @@ -440,7 +490,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmIcmp( target, LlvmConditionCode.EQ, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntEquals.left(), context), patioOperandToLlvmOperand(patioIntEquals.right(), context) )); @@ -454,7 +504,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmIcmp( target, LlvmConditionCode.NE, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntNotEqual.left(), context), patioOperandToLlvmOperand(patioIntNotEqual.right(), context) )); @@ -467,7 +517,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmSub( target, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntSub.left(), context), patioOperandToLlvmOperand(patioIntSub.right(), context) )); @@ -480,7 +530,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmTrunc( target, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntToBool.value(), context), LlvmTypes.INT_1 )); @@ -493,7 +543,7 @@ public class PatioToLlvm { yield context.addInstruction(new LlvmIntToPtr( target, - LlvmTypes.INT_64, + context.platformTarget().patioIntType(), patioOperandToLlvmOperand(patioIntToDataPtr.value(), context) )); } @@ -545,14 +595,21 @@ public class PatioToLlvm { context = context.addInstruction(new LlvmGetElementPtr( pointer, - LlvmTypes.pointer(patioDataLayoutToLlvmType(patioMemoryLoad.layout())), + LlvmTypes.pointer(patioDataLayoutToLlvmType( + patioMemoryLoad.layout(), + context.platformTarget() + )), patioOperandToLlvmOperand(patioMemoryLoad.pointer(), context), patioDataOffsetsToLlvmOffsets(patioMemoryLoad.layout(), patioMemoryLoad.offset()) )); context = context.addInstruction(new LlvmLoad( target, - patioDataOffsetToLlvmType(patioMemoryLoad.layout(), patioMemoryLoad.offset()), + patioDataOffsetToLlvmType( + patioMemoryLoad.layout(), + patioMemoryLoad.offset(), + context.platformTarget() + ), pointer )); @@ -566,13 +623,20 @@ public class PatioToLlvm { context = context.addInstruction(new LlvmGetElementPtr( pointer, - LlvmTypes.pointer(patioDataLayoutToLlvmType(patioMemoryStore.layout())), + LlvmTypes.pointer(patioDataLayoutToLlvmType( + patioMemoryStore.layout(), + context.platformTarget() + )), patioOperandToLlvmOperand(patioMemoryStore.pointer(), context), patioDataOffsetsToLlvmOffsets(patioMemoryStore.layout(), patioMemoryStore.offset()) )); context = context.addInstruction(new LlvmStore( - patioDataOffsetToLlvmType(patioMemoryStore.layout(), patioMemoryStore.offset()), + patioDataOffsetToLlvmType( + patioMemoryStore.layout(), + patioMemoryStore.offset(), + context.platformTarget() + ), patioOperandToLlvmOperand(patioMemoryStore.value(), context), pointer )); @@ -650,7 +714,7 @@ public class PatioToLlvm { )); context = context.addTerminatorInstruction(new LlvmSwitch( - LlvmTypes.INT_64, + patioOperandToLlvmType(patioSwitch.value(), context), patioOperandToLlvmOperand(patioSwitch.value(), context), switchDefaultStartLabel, llvmSwitchCases @@ -667,7 +731,8 @@ public class PatioToLlvm { } case PatioThrow throw_ -> { - context = context.addInstruction(THROW_DECLARATION.call( + var throwDeclaration = throwDeclaration(context.platformTarget()); + context = context.addInstruction(throwDeclaration.call( Optional.empty(), List.of( new LlvmOperandInt(context.exceptionTag(throw_.exceptionTypeName())), @@ -717,7 +782,8 @@ public class PatioToLlvm { var setjmpValue = setjmpValueResult.value(); context = setjmpValueResult.context(); - context = context.addInstruction(SETJMP_DECLARATION.call( + var setjmpDeclaration = setjmpDeclaration(context.platformTarget()); + context = context.addInstruction(setjmpDeclaration.call( Optional.of(setjmpValue), List.of(jmpBuf) )); @@ -769,6 +835,8 @@ public class PatioToLlvm { var exceptionValueTarget = exceptionValueTargetResult.value(); context = exceptionValueTargetResult.context(); + var exceptionValueDeclaration = exceptionValueDeclaration(context.platformTarget()); + branches.add(new Branch( catchBodyStartLabel, catchBodyEndLabel, @@ -776,8 +844,8 @@ public class PatioToLlvm { restorePreviousExceptionHandlerInstruction, new LlvmLoad( exceptionValueTarget, - LlvmTypes.INT_64, - new LlvmVariableGlobal(EXCEPTION_VALUE_DECLARATION.name()) + exceptionValueType(context.platformTarget()), + new LlvmVariableGlobal(exceptionValueDeclaration.name()) ) ), catchClause.body(), @@ -1001,21 +1069,28 @@ public class PatioToLlvm { private static LlvmType patioDataOffsetToLlvmType( PatioDataLayout patioDataLayout, - List patioOffsets + List patioOffsets, + LlvmTarget platformTarget ) { - return patioDataOffsetToLlvmType(patioDataLayout, TreePVector.from(patioOffsets)); + return patioDataOffsetToLlvmType( + patioDataLayout, + TreePVector.from(patioOffsets), + platformTarget + ); } private static LlvmType patioDataOffsetToLlvmType( PatioDataLayout patioDataLayout, - PVector patioOffsets + PVector patioOffsets, + LlvmTarget platformTarget ) { // TODO: check that offset is valid? return switch (patioDataLayout) { case PatioDataLayoutArray patioDataLayoutArray -> patioDataOffsetToLlvmType( patioDataLayoutArray.element(), - patioOffsets.minus(0) + patioOffsets.minus(0), + platformTarget ); case PatioDataLayoutBool patioDataLayoutBool -> @@ -1031,12 +1106,13 @@ public class PatioToLlvm { LlvmTypes.pointer(LlvmTypes.VOID); case PatioDataLayoutInt patioDataLayoutInt -> - LlvmTypes.INT_64; + platformTarget.patioIntType(); case PatioDataLayoutStruct patioDataLayoutStruct -> patioDataOffsetToLlvmType( patioDataLayoutStruct.elements().get(patioOffsets.get(0)), - patioOffsets.minus(0) + patioOffsets.minus(0), + platformTarget ); }; } @@ -1066,7 +1142,7 @@ public class PatioToLlvm { LlvmTypes.pointer(LlvmTypes.VOID); case PatioInt patioInt -> - LlvmTypes.INT_64; + context.platformTarget().patioIntType(); case PatioLocalRef patioLocalRef -> context.patioLocalToType(patioLocalRef); @@ -1096,7 +1172,10 @@ public class PatioToLlvm { } - private static LlvmType patioTypeToLlvmType(PatioType patioType) { + private static LlvmType patioTypeToLlvmType( + PatioType patioType, + LlvmTarget platformTarget + ) { return switch (patioType) { case PatioBoolType patioBoolType -> LlvmTypes.INT_1; @@ -1111,19 +1190,25 @@ public class PatioToLlvm { LlvmTypes.pointer(LlvmTypes.VOID); case PatioIntType patioIntType -> - LlvmTypes.INT_64; + platformTarget.patioIntType(); case PatioVoidType patioVoidType -> LlvmTypes.VOID; }; } - private static LlvmType patioDataLayoutToLlvmType(PatioDataLayout layout) { + private static LlvmType patioDataLayoutToLlvmType( + PatioDataLayout layout, + LlvmTarget platformTarget + ) { return switch (layout) { case PatioDataLayoutArray patioDataLayoutArray -> LlvmTypes.array( patioDataLayoutArray.size(), - patioDataLayoutToLlvmType(patioDataLayoutArray.element()) + patioDataLayoutToLlvmType( + patioDataLayoutArray.element(), + platformTarget + ) ); case PatioDataLayoutBool patioDataLayoutBool -> @@ -1139,24 +1224,33 @@ public class PatioToLlvm { LlvmTypes.pointer(LlvmTypes.VOID); case PatioDataLayoutInt patioDataLayoutInt -> - LlvmTypes.INT_64; + platformTarget.patioIntType(); case PatioDataLayoutStruct patioDataLayoutStruct -> LlvmTypes.structure( patioDataLayoutStruct.elements().stream() - .map(element -> patioDataLayoutToLlvmType(element)) + .map(element -> patioDataLayoutToLlvmType(element, platformTarget)) .toList() ); }; } - private static LlvmOperand patioDataLayoutToZeroedLlvmOperand(PatioDataLayout layout) { + private static LlvmOperand patioDataLayoutToZeroedLlvmOperand( + PatioDataLayout layout, + LlvmTarget platformTarget + ) { return switch (layout) { case PatioDataLayoutArray patioDataLayoutArray -> new LlvmOperandArray( - patioDataLayoutToLlvmType(patioDataLayoutArray.element()), + patioDataLayoutToLlvmType( + patioDataLayoutArray.element(), + platformTarget + ), Lists.repeat( - patioDataLayoutToZeroedLlvmOperand(patioDataLayoutArray.element()), + patioDataLayoutToZeroedLlvmOperand( + patioDataLayoutArray.element(), + platformTarget + ), patioDataLayoutArray.size() ) ); @@ -1180,21 +1274,27 @@ public class PatioToLlvm { new LlvmOperandStructure( patioDataLayoutStruct.elements().stream() .map(element -> new LlvmTypedOperand( - patioDataLayoutToLlvmType(element), - patioDataLayoutToZeroedLlvmOperand(element) + patioDataLayoutToLlvmType(element, platformTarget), + patioDataLayoutToZeroedLlvmOperand(element, platformTarget) )) .toList() ); }; } - private static LlvmOperand patioDataValueToLlvmOperand(PatioDataValue value) { + private static LlvmOperand patioDataValueToLlvmOperand( + PatioDataValue value, + LlvmTarget platformTarget + ) { return switch (value) { case PatioDataValueArray patioDataValueArray -> { - var llvmType = patioDataLayoutToLlvmType(patioDataValueArray.elementLayout()); + var llvmType = patioDataLayoutToLlvmType( + patioDataValueArray.elementLayout(), + platformTarget + ); var llvmElements = patioDataValueArray.elements().stream() - .map(element -> patioDataValueToLlvmOperand(element)) + .map(element -> patioDataValueToLlvmOperand(element, platformTarget)) .toList(); yield new LlvmOperandArray(llvmType, llvmElements); @@ -1216,15 +1316,15 @@ public class PatioToLlvm { new LlvmOperandStructure( patioDataValueStruct.elements().stream() .map(element -> new LlvmTypedOperand( - patioDataLayoutToLlvmType(element.layout()), - patioDataValueToLlvmOperand(element) + patioDataLayoutToLlvmType(element.layout(), platformTarget), + patioDataValueToLlvmOperand(element, platformTarget) )) .toList() ); }; } - public static PatioToLlvmFunctionContext.Result sizeOf( + static PatioToLlvmFunctionContext.Result sizeOf( LlvmType type, PatioToLlvmFunctionContext context ) { @@ -1249,7 +1349,7 @@ public class PatioToLlvm { new LlvmPtrToInt( size, sizePtr, - LlvmTypes.INT_64 + context.platformTarget().patioIntType() ) ) .toResult(size); @@ -1272,7 +1372,10 @@ public class PatioToLlvm { .addInstruction( new LlvmGetElementPtr( offsetPtr, - LlvmTypes.pointer(patioDataLayoutToLlvmType(patioDataLayout)), + LlvmTypes.pointer(patioDataLayoutToLlvmType( + patioDataLayout, + context.platformTarget() + )), new LlvmOperandNull(), patioDataOffsetsToLlvmOffsets(patioDataLayout, patioOffset) ) @@ -1281,7 +1384,7 @@ public class PatioToLlvm { new LlvmPtrToInt( offset, offsetPtr, - LlvmTypes.INT_64 + context.platformTarget().patioIntType() ) ) .toResult(offset); diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmFunctionContext.java b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmFunctionContext.java index c27beec6..8ec1e6b3 100644 --- a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmFunctionContext.java +++ b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmFunctionContext.java @@ -5,6 +5,7 @@ import org.pcollections.PStack; import org.pcollections.PVector; import org.shedlang.compiler.backends.NameAllocator; import org.shedlang.compiler.backends.llvm.LlvmCodeGenLocalVariableSpace; +import org.shedlang.compiler.backends.llvm.LlvmTarget; import org.shedlang.compiler.backends.llvm.ir.ast.LlvmBasicBlock; import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmBrUnconditional; import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmInstruction; @@ -60,6 +61,10 @@ class PatioToLlvmFunctionContext { this.loopLabels = loopLabels; } + LlvmTarget platformTarget() { + return this.moduleContext.platformTarget(); + } + LlvmType functionNameToReturnType(String functionName) { return this.moduleContext.functionNameToReturnType(functionName); } diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmGlobalContext.java b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmGlobalContext.java index 4077ce6e..ab0a241f 100644 --- a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmGlobalContext.java +++ b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmGlobalContext.java @@ -9,25 +9,25 @@ public class PatioToLlvmGlobalContext { return new PatioToLlvmGlobalContext(target, P.map()); } - private final LlvmTarget target; + private final LlvmTarget platformTarget; private final PMap exceptionTypeNameToTag; private PatioToLlvmGlobalContext( - LlvmTarget target, + LlvmTarget platformTarget, PMap exceptionTypeNameToTag ) { - this.target = target; + this.platformTarget = platformTarget; this.exceptionTypeNameToTag = exceptionTypeNameToTag; } - public LlvmTarget target() { - return this.target; + public LlvmTarget platformTarget() { + return this.platformTarget; } PatioToLlvmGlobalContext allocateExceptionTag(String exceptionTypeName) { var tag = this.exceptionTypeNameToTag.size() + 1; return new PatioToLlvmGlobalContext( - this.target, + this.platformTarget, this.exceptionTypeNameToTag.plus(exceptionTypeName, tag) ); } diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmModuleContext.java b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmModuleContext.java index 538d66b9..6315e0aa 100644 --- a/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmModuleContext.java +++ b/src/main/java/org/shedlang/compiler/backends/llvm/codegen/PatioToLlvmModuleContext.java @@ -33,11 +33,15 @@ class PatioToLlvmModuleContext { PatioToLlvmGlobalContext.Result toModule() { return this.globalContext.toResult(new LlvmModule( - this.globalContext.target().targetTriple(), + this.globalContext.platformTarget().targetTriple(), this.topLevelEntities )); } + LlvmTarget platformTarget() { + return this.globalContext.platformTarget(); + } + PatioToLlvmModuleContext addFunctionNameToReturnType(String functionName, LlvmType returnType) { return new PatioToLlvmModuleContext( this.globalContext, -- cgit v1.2.3