l2s: simplify and fix llvm 14

Author: Hugobros3

src/frontends/llvm/l2s.c

@@ -111,7 +111,7 @@ const Node* convert_function(Parser* p, LLVMValueRef fn) {
     assert(fn_type->tag == FnType_TAG);
     assert(fn_type->payload.fn_type.param_types.count == params.count);
     Node* f = function(p->dst, params, LLVMGetValueName(fn), empty(a), fn_type->payload.fn_type.return_types);
-    const Node* r = f;
+    const Node* r = fn_addr_helper(a, f);
     insert_dict(LLVMValueRef, const Node*, p->map, fn, r);
 
     if (LLVMCountBasicBlocks(fn) > 0) {

src/frontends/llvm/l2s_annotations.c

@@ -22,6 +22,13 @@ void add_annotation(Parser* p, const Node* n, ParsedAnnotation a) {
     }
 }
 
+static const Node* assert_and_strip_fn_addr(const Node* fn) {
+    assert(fn->tag == FnAddr_TAG);
+    fn = fn->payload.fn_addr.fn;
+    assert(fn->tag == Function_TAG);
+    return fn;
+}
+
 void process_llvm_annotations(Parser* p, LLVMValueRef global) {
     IrArena* a = get_module_arena(p->dst);
     const Type* t = convert_type(p, LLVMGlobalGetValueType(global));
@@ -51,40 +58,29 @@ void process_llvm_annotations(Parser* p, LLVMValueRef global) {
         if (annotation_payload->tag == GlobalVariable_TAG) {
             annotation_payload = annotation_payload->payload.global_variable.init;
         }
-        const char* ostr = get_string_literal(a, annotation_payload);
+
+        NodeResolveConfig resolve_config = default_node_resolve_config();
+        // both of those assumptions are hacky but this front-end is a hacky deal anyways.
+        resolve_config.assume_globals_immutability = true;
+        resolve_config.allow_incompatible_types = true;
+        const char* ostr = get_string_literal(a, resolve_node_to_definition(annotation_payload, resolve_config));
         char* str = calloc(strlen(ostr) + 1, 1);
         memcpy(str, ostr, strlen(ostr) + 1);
         if (strcmp(strtok(str, "::"), "shady") == 0) {
             const Node* target = entry->payload.composite.contents.nodes[0];
-            if (target->tag == RefDecl_TAG) {
-                target = target->payload.ref_decl.decl;
-            }
-            while (target->tag == Constant_TAG) {
-                const Node* instr = target->payload.constant.instruction;
-                assert(instr->tag == PrimOp_TAG);
-                switch (instr->payload.prim_op.op) {
-                    case quote_op:
-                    case reinterpret_op:
-                    case convert_op:
-                    case lea_op: target = first(instr->payload.prim_op.operands); break;
-                    default: assert(false);
-                }
-            }
-            if (target->tag == RefDecl_TAG) {
-                target = target->payload.ref_decl.decl;
-            }
+            target = resolve_node_to_definition(target, resolve_config);
 
             char* keyword = strtok(NULL, "::");
             if (strcmp(keyword, "entry_point") == 0) {
-                assert(target->tag == Function_TAG);
+                target = assert_and_strip_fn_addr(target);
                 add_annotation(p, target,  (ParsedAnnotation) {
                     .payload = annotation_value(a, (AnnotationValue) {
                         .name = "EntryPoint",
                         .value = string_lit_helper(a, strtok(NULL, "::"))
                     })
                 });
             } else if (strcmp(keyword, "workgroup_size") == 0) {
-                assert(target->tag == Function_TAG);
+                target = assert_and_strip_fn_addr(target);
                 add_annotation(p, target,  (ParsedAnnotation) {
                     .payload = annotation_values(a, (AnnotationValues) {
                         .name = "WorkgroupSize",

src/frontends/llvm/l2s_value.c

@@ -81,7 +81,7 @@ const Node* convert_value(Parser* p, LLVMValueRef v) {
             Nodes annotations = singleton(annotation(a, (Annotation) { .name = "SkipOnInfer" }));
             annotations = empty(a);
             Node* decl = constant(p->dst, annotations, NULL, name);
-            r = decl;
+            r = ref_decl_helper(a, decl);
             insert_dict(LLVMTypeRef, const Type*, p->map, v, r);
             BodyBuilder* bb = begin_body(a);
             EmittedInstr emitted = convert_instruction(p, NULL, bb, v);