Experiment: Make size_t/ptrdiff_t match pointer size on 8/16 bit architectures

dmd/mtype.d

@@ -892,10 +892,38 @@ version (IN_LLVM)
         twstring = twchar.immutableOf().arrayOf();
         tdstring = tdchar.immutableOf().arrayOf();
 
+version (IN_LLVM)
+{
+        switch (target.ptrsize)
+        {
+            case 1:
+                tsize_t    = basic[Tuns8];
+                tptrdiff_t = basic[Tint8];
+                break;
+            case 2:
+                tsize_t    = basic[Tuns16];
+                tptrdiff_t = basic[Tint16];
+                break;
+            case 4:
+                tsize_t    = basic[Tuns32];
+                tptrdiff_t = basic[Tint32];
+                break;
+            case 8:
+                tsize_t    = basic[Tuns64];
+                tptrdiff_t = basic[Tint64];
+                break;
+            default:
+                assert(0, "Unsupported target pointer size");
+        }
+}
+else
+{
         const isLP64 = target.isLP64;
 
         tsize_t    = basic[isLP64 ? Tuns64 : Tuns32];
         tptrdiff_t = basic[isLP64 ? Tint64 : Tint32];
+}
+
         thash_t = tsize_t;
     }
 

dmd/typesem.d

@@ -1071,6 +1071,18 @@ extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc)
             }
             else
             {
+version (IN_LLVM)
+{
+                // Kludge for 8/16 bit targets and `__LINE__` default arguments of type int:
+                // insert hidden cast if the parameter type is size_t.
+                // Without this, importing object.d fails (Exception constructors taking size_t line numbers).
+                if (e.isLineInitExp() && target.ptrsize < 4 && fparam.type.equivalent(Type.tsize_t))
+                {
+                    if (!e.type)
+                        e.type = Type.tint32;
+                    e = e.castTo(sc, fparam.type);
+                }
+}
                 e = inferType(e, fparam.type);
                 Initializer iz = new ExpInitializer(e.loc, e);
                 iz = iz.initializerSemantic(sc, fparam.type, INITnointerpret);

tests/codegen/size_t_16bit.d

@@ -0,0 +1,26 @@
+// A minimal test wrt. size_t on a 16-bit architecture.
+
+// REQUIRES: target_AVR
+// RUN: %ldc -mtriple=avr -betterC -output-ll -of=%t.ll %s && FileCheck %s < %t.ll
+// RUN: %ldc -mtriple=avr -betterC -c %s
+
+static assert(size_t.sizeof == 2);
+static assert(ptrdiff_t.sizeof == 2);
+
+int testBoundsCheck(int[] arr)
+{
+    return arr[1];
+}
+
+// __LINE__ expressions are of type int
+void takeIntLine(int line = __LINE__) {}
+// special case for 8/16 bit targets: __LINE__ magically cast to size_t
+void takeSizeTLine(size_t line = __LINE__) {}
+
+void testDefaultLineArgs()
+{
+    // CHECK: call {{.*}}takeIntLine{{.*}}(i32 [[@LINE+1]])
+    takeIntLine();
+    // CHECK: call {{.*}}takeSizeTLine{{.*}}(i16 zeroext [[@LINE+1]])
+    takeSizeTLine();
+}