made functions external

lit/mem/arg_style.thorin

@@ -8,59 +8,64 @@
 .let I32 = .Idx _32;
 .let Tas = (I32, 0);
 
-.con f1 [mem: %mem.M, a: I32, ret: .Cn [%mem.M, I32]] = {
+// We want the functions to be extern.
+// Functions with argstyle might stay until code gen and can not be inlined in general.
+// Therefore, we need to handle them explicitely.
+// As such functions prevent code gen, we want to ignore the extern flag.
+
+.con .extern f1 [mem: %mem.M, a: I32, ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con f2 [[mem: %mem.M, a: I32], ret: .Cn [%mem.M, I32]] = {
+.con .extern f2 [[mem: %mem.M, a: I32], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con g1 [mem: %mem.M, a: I32, b:I32, ret: .Cn [%mem.M, I32]] = {
+.con .extern g1 [mem: %mem.M, a: I32, b:I32, ret: .Cn [%mem.M, I32]] = {
     .let c = %core.wrap.add _32 0 (a,b);
     ret (mem,c)
 };
 
-.con g2 [[mem: %mem.M, a: I32, b:I32], ret: .Cn [%mem.M, I32]] = {
+.con .extern g2 [[mem: %mem.M, a: I32, b:I32], ret: .Cn [%mem.M, I32]] = {
     .let c = %core.wrap.add _32 0 (a,b);
     ret (mem,c)
 };
 
-.con g3 [[mem: %mem.M, [a: I32, b:I32]], ret: .Cn [%mem.M, I32]] = {
+.con .extern g3 [[mem: %mem.M, [a: I32, b:I32]], ret: .Cn [%mem.M, I32]] = {
     .let c = %core.wrap.add _32 0 (a,b);
     ret (mem,c)
 };
 
-.con g4 [mem: %mem.M, [a: I32, b:I32], ret: .Cn [%mem.M, I32]] = {
+.con .extern g4 [mem: %mem.M, [a: I32, b:I32], ret: .Cn [%mem.M, I32]] = {
     .let c = %core.wrap.add _32 0 (a,b);
     ret (mem,c)
 };
 
-.con h1 [mem: %mem.M, a: I32, x:%mem.Ptr (I32, 0), ret: .Cn [%mem.M, I32]] = {
+.con .extern h1 [mem: %mem.M, a: I32, x:%mem.Ptr (I32, 0), ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con h2 [mem: %mem.M, [a: I32, x:%mem.Ptr (I32, 0)], ret: .Cn [%mem.M, I32]] = {
+.con .extern h2 [mem: %mem.M, [a: I32, x:%mem.Ptr (I32, 0)], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con h3 [[mem: %mem.M, a: I32, x:%mem.Ptr (I32, 0)], ret: .Cn [%mem.M, I32]] = {
+.con .extern h3 [[mem: %mem.M, a: I32, x:%mem.Ptr (I32, 0)], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con h4 [[mem: %mem.M, [a: I32, x:%mem.Ptr (I32, 0)]], ret: .Cn [%mem.M, I32]] = {
+.con .extern h4 [[mem: %mem.M, [a: I32, x:%mem.Ptr (I32, 0)]], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con e1 [mem: %mem.M, a: I32, [], ret: .Cn [%mem.M, I32]] = {
+.con .extern e1 [mem: %mem.M, a: I32, [], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con e2 [mem: %mem.M, [a: I32, []], ret: .Cn [%mem.M, I32]] = {
+.con .extern e2 [mem: %mem.M, [a: I32, []], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
-.con e3 [[mem: %mem.M, [a: I32, []]], ret: .Cn [%mem.M, I32]] = {
+.con .extern e3 [[mem: %mem.M, [a: I32, []]], ret: .Cn [%mem.M, I32]] = {
     ret (mem,a)
 };
 
@@ -69,11 +74,9 @@
     .let (mem2,p) = %mem.alloc Tas mem;
     // .let mem3 = %mem.store Tas (mem2, p, argc);
 
-    // .con cont_f1 [mem:%mem.M, v:I32] = {
+    // .con .extern cont_f1 [mem:%mem.M, v:I32] = {
     //     f1 ()
     // };
     return (mem2, argc)
 
 };
-
-// TODO: check for 1+x, 2+x, a+b