Update types for i686 target

5 files changed, 239 insertions, 105 deletions

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<String> clangFlags;
 
-    LlvmTarget(String targetName, String targetTriple, List<String> clangFlags) {
+    LlvmTarget(
+        String targetName,
+        String targetTriple,
+        LlvmTypeScalar sizeT,
+        List<String> 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<String> 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<Integer> 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<Integer> patioOffsets
+        List<Integer> patioOffsets,
+        LlvmTarget platformTarget
     ) {
-        return patioDataOffsetToLlvmType(patioDataLayout, TreePVector.from(patioOffsets));
+        return patioDataOffsetToLlvmType(
+            patioDataLayout,
+            TreePVector.from(patioOffsets),
+            platformTarget
+        );
     }
 
     private static LlvmType patioDataOffsetToLlvmType(
         PatioDataLayout patioDataLayout,
-        PVector<Integer> patioOffsets
+        PVector<Integer> 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<LlvmOperand> sizeOf(
+    static PatioToLlvmFunctionContext.Result<LlvmOperand> 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<String, Integer> exceptionTypeNameToTag;
 
     private PatioToLlvmGlobalContext(
-        LlvmTarget target,
+        LlvmTarget platformTarget,
         PMap<String, Integer> 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<LlvmModule> 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,