remove support for untyped ptr in the IR: instead do it in l2s

Author: Hugobros3

include/shady/ir.h

@@ -69,7 +69,6 @@ typedef struct {
     bool check_op_classes;
     bool check_types;
     bool allow_fold;
-    bool untyped_ptrs;
     bool validate_builtin_types; // do @Builtins variables need to match their type in builtins.h ?
     bool is_simt;
 

src/frontends/llvm/l2s.c

@@ -1,13 +1,16 @@
 #include "l2s_private.h"
-#include "shady/ir_private.h"
+
+#include "ir_private.h"
+#include "type.h"
+#include "analysis/verify.h"
 
 #include "log.h"
 #include "dict.h"
 #include "list.h"
 #include "util.h"
+#include "portability.h"
 
 #include "llvm-c/IRReader.h"
-#include "portability.h"
 
 #include <assert.h>
 #include <string.h>
@@ -80,7 +83,7 @@ static TodoBB prepare_bb(Parser* p, Node* fn, LLVMBasicBlockRef bb) {
     while (instr) {
         switch (LLVMGetInstructionOpcode(instr)) {
             case LLVMPHI: {
-                const Node* nparam = var(a, convert_type(p, LLVMTypeOf(instr)), "phi");
+                const Node* nparam = var(a, qualified_type_helper(convert_type(p, LLVMTypeOf(instr)), false), "phi");
                 insert_dict(LLVMValueRef, const Node*, p->map, instr, nparam);
                 append_list(LLVMValueRef, phis, instr);
                 params = append_nodes(a, params, nparam);
@@ -128,7 +131,7 @@ const Node* convert_function(Parser* p, LLVMValueRef fn) {
     for (LLVMValueRef oparam = LLVMGetFirstParam(fn); oparam; oparam = LLVMGetNextParam(oparam)) {
         LLVMTypeRef ot = LLVMTypeOf(oparam);
         const Type* t = convert_type(p, ot);
-        const Node* param = var(a, t, LLVMGetValueName(oparam));
+        const Node* param = var(a, qualified_type_helper(t, false), LLVMGetValueName(oparam));
         insert_dict(LLVMValueRef, const Node*, p->map, oparam, param);
         params = append_nodes(a, params, param);
         if (oparam == LLVMGetLastParam(fn))
@@ -217,6 +220,13 @@ const Node* convert_global(Parser* p, LLVMValueRef global) {
         decl = global_var(p->dst, empty(a), type, name, as);
         if (value && as != AsUniformConstant)
             decl->payload.global_variable.init = convert_value(p, value);
+
+        if (UNTYPED_POINTERS) {
+            Node* untyped_wrapper = constant(p->dst, empty(a), ptr_t, format_string_interned(a, "%s_untyped", name));
+            untyped_wrapper->payload.constant.instruction = quote_helper(a, singleton(ref_decl_helper(a, decl)));
+            untyped_wrapper->payload.constant.instruction = prim_op_helper(a, reinterpret_op, singleton(ptr_t), singleton(ref_decl_helper(a, decl)));
+            decl = untyped_wrapper;
+        }
     } else {
         const Type* type = convert_type(p, LLVMTypeOf(global));
         decl = constant(p->dst, empty(a), type, name);
@@ -241,9 +251,6 @@ bool parse_llvm_into_shady(const CompilerConfig* config, size_t len, const char*
         error_die();
     }
     info_print("LLVM IR parsed successfully\n");
-#if UNTYPED_POINTERS
-    get_module_arena(dst)->config.untyped_ptrs = true; // tolerate untyped ptrs...
-#endif
 
     ArenaConfig aconfig = default_arena_config();
     aconfig.check_types = false;
@@ -278,6 +285,7 @@ bool parse_llvm_into_shady(const CompilerConfig* config, size_t len, const char*
             break;
         global = LLVMGetNextGlobal(global);
     }
+    log_module(DEBUG, config, dirty);
 
     aconfig.check_types = true;
     aconfig.allow_fold = true;

src/frontends/llvm/l2s_instr.c

@@ -76,6 +76,15 @@ static const Node* convert_jump(Parser* p, Node* fn, Node* fn_or_bb, LLVMBasicBl
     return jump_helper(a, dst_bb, nodes(a, params_count, params));
 }
 
+static const Type* type_untyped_ptr(const Type* untyped_ptr_t, const Type* element_type) {
+    IrArena* a = untyped_ptr_t->arena;
+    assert(element_type);
+    assert(untyped_ptr_t->tag == PtrType_TAG);
+    assert(!untyped_ptr_t->payload.ptr_type.is_reference);
+    const Type* typed_ptr_t = ptr_type(a, (PtrType) { .pointed_type = element_type, .address_space = untyped_ptr_t->payload.ptr_type.address_space });
+    return typed_ptr_t;
+}
+
 /// instr may be an instruction or a constantexpr
 EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVMValueRef instr) {
     Node* fn = fn_or_bb;
@@ -223,7 +232,7 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
             r = first(bind_instruction_explicit_result_types(b, prim_op_helper(a, alloca_op, singleton(allocated_t), empty(a)), singleton(allocated_ptr_t), NULL));
             if (UNTYPED_POINTERS) {
                 const Type* untyped_ptr_t = ptr_type(a, (PtrType) { .pointed_type = unit_type(a), .address_space = AsPrivate });
-                r = first(bind_instruction_outputs_count(b, prim_op_helper(a, reinterpret_op, singleton(untyped_ptr_t), singleton(r)), 1, NULL));
+                r = first(bind_instruction_explicit_result_types(b, prim_op_helper(a, reinterpret_op, singleton(untyped_ptr_t), singleton(r)), singleton(untyped_ptr_t), NULL));
             }
             r = prim_op_helper(a, convert_op, singleton(t), singleton(r));
             break;
@@ -232,19 +241,49 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
             Nodes ops = convert_operands(p, num_ops, instr);
             assert(ops.count == 1);
             const Node* ptr = first(ops);
-            r = prim_op_helper(a, load_op, singleton(t), singleton(ptr));
+            if (UNTYPED_POINTERS) {
+                const Type* element_t = t;
+                const Type* untyped_ptr_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)));
+                const Type* typed_ptr = type_untyped_ptr(untyped_ptr_t, element_t);
+                ptr = first(bind_instruction_explicit_result_types(b, prim_op_helper(a, reinterpret_op, singleton(typed_ptr), singleton(ptr)), singleton(typed_ptr), NULL));
+            }
+            r = prim_op_helper(a, load_op, empty(a), singleton(ptr));
             break;
         }
         case LLVMStore: {
             num_results = 0;
             Nodes ops = convert_operands(p, num_ops, instr);
             assert(ops.count == 2);
-            r = prim_op_helper(a, store_op, UNTYPED_POINTERS ? singleton(convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)))) : empty(a), mk_nodes(a, ops.nodes[1], ops.nodes[0]));
+            const Node* ptr = ops.nodes[1];
+            if (UNTYPED_POINTERS) {
+                const Type* element_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)));
+                const Type* untyped_ptr_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 1)));
+                const Type* typed_ptr = type_untyped_ptr(untyped_ptr_t, element_t);
+                ptr = first(bind_instruction_explicit_result_types(b, prim_op_helper(a, reinterpret_op, singleton(typed_ptr), singleton(ptr)), singleton(typed_ptr), NULL));
+            }
+            r = prim_op_helper(a, store_op, empty(a), mk_nodes(a, ptr, ops.nodes[0]));
             break;
         }
         case LLVMGetElementPtr: {
             Nodes ops = convert_operands(p, num_ops, instr);
-            r = prim_op_helper(a, lea_op, UNTYPED_POINTERS ? singleton(convert_type(p, LLVMGetGEPSourceElementType(instr))) : empty(a), ops);
+            const Node* ptr = first(ops);
+            if (UNTYPED_POINTERS) {
+                const Type* element_t = convert_type(p, LLVMGetGEPSourceElementType(instr));
+                const Type* untyped_ptr_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)));
+                const Type* typed_ptr = type_untyped_ptr(untyped_ptr_t, element_t);
+                ptr = first(bind_instruction_explicit_result_types(b, prim_op_helper(a, reinterpret_op, singleton(typed_ptr), singleton(ptr)), singleton(typed_ptr), NULL));
+            }
+            ops = change_node_at_index(a, ops, 0, ptr);
+            r = prim_op_helper(a, lea_op, empty(a), ops);
+            if (UNTYPED_POINTERS) {
+                const Type* element_t = convert_type(p, LLVMGetGEPSourceElementType(instr));
+                const Type* untyped_ptr_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)));
+                bool idk;
+                //element_t = qualified_type_helper(element_t, false);
+                enter_composite(&element_t, &idk, nodes(a, ops.count - 2, &ops.nodes[2]), true);
+                const Type* typed_ptr = type_untyped_ptr(untyped_ptr_t, element_t);
+                r = prim_op_helper(a, reinterpret_op, singleton(untyped_ptr_t), BIND_PREV_R(typed_ptr));
+            }
             break;
         }
         case LLVMTrunc:
@@ -493,6 +532,7 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
                         LLVMAttributeRef attr = attrs[i];
                         size_t k = LLVMGetEnumAttributeKind(attr);
                         size_t e = LLVMGetEnumAttributeKindForName("byval", 5);
+                        uint64_t value = LLVMGetEnumAttributeValue(attr);
                         // printf("p = %zu, i = %zu, k = %zu, e = %zu\n", param_index, i, k, e);
                         if (k == e)
                             decoded[param_index].is_byval = true;

src/frontends/llvm/l2s_meta.c

@@ -27,7 +27,7 @@ static const Node* convert_named_tuple_metadata(Parser* p, LLVMValueRef v, Strin
     String name = LLVMGetValueName(v);
     if (!name || strlen(name) == 0)
         name = unique_name(a, node_name);
-    Node* g = global_var(p->dst, singleton(annotation(a, (Annotation) { .name = "SkipOnInfer" })), NULL, name, AsDebugInfo);
+    Node* g = global_var(p->dst, singleton(annotation(a, (Annotation) { .name = "LLVMMetaData" })), NULL, name, AsDebugInfo);
     const Node* r = ref_decl_helper(a, g);
     insert_dict(LLVMValueRef, const Type*, p->map, v, r);
 

src/frontends/llvm/l2s_postprocess.c

@@ -79,8 +79,36 @@ static Nodes remake_variables(Context* ctx, Nodes old) {
 
 static const Node* process_op(Context* ctx, NodeClass op_class, String op_name, const Node* node) {
     IrArena* a = ctx->rewriter.dst_arena;
+    Rewriter* r = &ctx->rewriter;
     switch (node->tag) {
-        case Variable_TAG: return var(a, node->payload.var.type ? qualified_type_helper(rewrite_node(&ctx->rewriter, node->payload.var.type), false) : NULL, node->payload.var.name);
+        case Variable_TAG: {
+            assert(node->payload.var.type);
+            if (node->payload.var.type->tag == QualifiedType_TAG)
+                return var(a, node->payload.var.type ? rewrite_node(&ctx->rewriter, node->payload.var.type) : NULL, node->payload.var.name);
+            return var(a, qualified_type_helper(rewrite_node(&ctx->rewriter, node->payload.var.type), false), node->payload.var.name);
+        }
+        case Block_TAG: {
+            Nodes yield_types = rewrite_nodes(r, node->payload.block.yield_types);
+            const Node* ninside = rewrite_node(r, node->payload.block.inside);
+            const Node* term = get_abstraction_body(ninside);
+            while (term->tag == Let_TAG) {
+                term = get_abstraction_body(get_let_tail(term));
+            }
+            assert(term->tag == Yield_TAG);
+            yield_types = get_values_types(a, term->payload.yield.args);
+            return block(a, (Block) {
+                .yield_types = yield_types,
+                .inside = ninside,
+            });
+        }
+        case Constant_TAG: {
+            Node* new = recreate_node_identity(r, node);
+            BodyBuilder* bb = begin_body(a);
+            const Node* value = first(bind_instruction(bb, new->payload.constant.instruction));
+            value = first(bind_instruction(bb, prim_op_helper(a, subgroup_assume_uniform_op, empty(a), singleton(value))));
+            new->payload.constant.instruction = yield_values_and_wrap_in_block(bb, singleton(value));
+            return new;
+        }
         case Function_TAG: {
             Context fn_ctx = *ctx;
             fn_ctx.curr_scope = new_scope(node);
@@ -183,7 +211,7 @@ static const Node* process_op(Context* ctx, NodeClass op_class, String op_name,
                                     const Type* jp_type = join_point_type(a, (JoinPointType) {
                                         .yield_types = get_variables_types(a, get_abstraction_params(dst))
                                     });
-                                    join_token = var(a, jp_type, get_abstraction_name(dst));
+                                    join_token = var(a, qualified_type_helper(jp_type, false), get_abstraction_name(dst));
                                     controls->tokens = append_nodes(a, controls->tokens, join_token);
                                     controls->destinations = append_nodes(a, controls->destinations, dst);
                                 }
@@ -193,6 +221,7 @@ static const Node* process_op(Context* ctx, NodeClass op_class, String op_name,
                                 if (fn->tag == BasicBlock_TAG)
                                     fn = (Node*) fn->payload.basic_block.fn;
                                 assert(fn->tag == Function_TAG);
+                                fn = rewrite_node(r, fn);
                                 Node* wrapper = basic_block(a, fn, nparams, format_string_arena(a->arena, "wrapper_to_%s", get_abstraction_name(dst)));
                                 wrapper->payload.basic_block.body = join(a, (Join) {
                                     .args = nparams,
@@ -214,23 +243,25 @@ static const Node* process_op(Context* ctx, NodeClass op_class, String op_name,
             break;
         }
         case GlobalVariable_TAG: {
+            if (lookup_annotation(node, "LLVMMetaData"))
+                return NULL;
             AddressSpace as = node->payload.global_variable.address_space;
             const Node* old_init = node->payload.global_variable.init;
-            Nodes annotations = rewrite_nodes(&ctx->rewriter, node->payload.global_variable.annotations);
-            const Type* type = rewrite_node(&ctx->rewriter, node->payload.global_variable.type);
+            Nodes annotations = rewrite_nodes(r, node->payload.global_variable.annotations);
+            const Type* type = rewrite_node(r, node->payload.global_variable.type);
             ParsedAnnotation* an = find_annotation(ctx->p, node);
             while (an) {
-                annotations = append_nodes(a, annotations, an->payload);
+                annotations = append_nodes(a, annotations, rewrite_node(r, an->payload));
                 if (strcmp(get_annotation_name(an->payload), "Builtin") == 0)
                     old_init = NULL;
                 if (strcmp(get_annotation_name(an->payload), "UniformConstant") == 0)
                     as = AsUniformConstant;
                 an = an->next;
             }
             Node* decl = global_var(ctx->rewriter.dst_module, annotations, type, get_declaration_name(node), as);
-            register_processed(&ctx->rewriter, node, decl);
+            register_processed(r, node, decl);
             if (old_init)
-                decl->payload.global_variable.init = rewrite_node(&ctx->rewriter, old_init);
+                decl->payload.global_variable.init = rewrite_node(r, old_init);
             return decl;
         }
         default: break;

src/frontends/llvm/l2s_type.c

@@ -1,4 +1,5 @@
 #include "l2s_private.h"
+#include "type.h"
 
 #include "portability.h"
 #include "log.h"
@@ -39,6 +40,8 @@ const Type* convert_type(Parser* p, LLVMTypeRef t) {
             const Type* ret_type = convert_type(p, LLVMGetReturnType(t));
             if (LLVMGetTypeKind(LLVMGetReturnType(t)) == LLVMVoidTypeKind)
                 ret_type = empty_multiple_return_type(a);
+            else
+                ret_type = qualified_type_helper(ret_type, false);
             return fn_type(a, (FnType) {
                 .param_types = nodes(a, num_params, cparam_types),
                 .return_types = ret_type == empty_multiple_return_type(a) ? empty(a) : singleton(ret_type)
@@ -96,6 +99,8 @@ const Type* convert_type(Parser* p, LLVMTypeRef t) {
 #if !UNTYPED_POINTERS
             LLVMTypeRef element_type = LLVMGetElementType(t);
             pointee = convert_type(p, element_type);
+#else
+            pointee = unit_type(a);
 #endif
             return ptr_type(a, (PtrType) {
                 .address_space = as,

src/frontends/llvm/l2s_value.c

@@ -80,12 +80,13 @@ const Node* convert_value(Parser* p, LLVMValueRef v) {
                 name = unique_name(a, "constant_expr");
             Nodes annotations = singleton(annotation(a, (Annotation) { .name = "SkipOnInfer" }));
             annotations = empty(a);
-            Node* decl = constant(p->dst, annotations, NULL, name);
+            assert(t);
+            Node* decl = constant(p->dst, annotations, t, name);
             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);
-            Nodes types = singleton(convert_type(p, LLVMTypeOf(v)));
+            Nodes types = singleton(t);
             decl->payload.constant.instruction = bind_last_instruction_and_wrap_in_block_explicit_return_types(bb, emitted.instruction, &types);
             return r;
         }

src/shady/analysis/verify.c

@@ -79,10 +79,12 @@ static void verify_nominal_node(const Node* fn, const Node* n) {
             break;
         }
         case Constant_TAG: {
-            const Type* t = n->payload.constant.instruction->type;
-            bool u = deconstruct_qualified_type(&t);
-            assert(u);
-            assert(is_subtype(n->payload.constant.type_hint, t));
+            if (n->payload.constant.instruction) {
+                const Type* t = n->payload.constant.instruction->type;
+                bool u = deconstruct_qualified_type(&t);
+                assert(u);
+                assert(is_subtype(n->payload.constant.type_hint, t));
+            }
             break;
         }
         case GlobalVariable_TAG: {

src/shady/compile.c

@@ -30,8 +30,9 @@ CompilerConfig default_compiler_config() {
 
         .logging = {
             // most of the time, we are not interested in seeing generated & internal code in the debug output
-            .print_internal = true,
-            .print_generated = true,
+            //.print_internal = true,
+            //.print_generated = true,
+            .print_builtin = true,
         },
 
         .optimisations = {

src/shady/node.c

@@ -140,7 +140,7 @@ const Node* resolve_node_to_definition(const Node* node, NodeResolveConfig confi
             case PrimOp_TAG: {
                 switch (node->payload.prim_op.op) {
                     case quote_op: {
-                        node = first(node->payload.prim_op.operands);;
+                        node = first(node->payload.prim_op.operands);
                         continue;
                     }
                     case load_op: {
@@ -200,22 +200,19 @@ const char* get_string_literal(IrArena* arena, const Node* node) {
     if (!node)
         return NULL;
     switch (node->tag) {
+        case Declaration_GlobalVariable_TAG: {
+            const Node* init = node->payload.global_variable.init;
+            if (init) {
+                return get_string_literal(arena, init);
+            }
+            break;
+        }
+        case Declaration_Constant_TAG: {
+            return get_string_literal(arena, node->payload.constant.instruction);
+        }
         case RefDecl_TAG: {
             const Node* decl = node->payload.ref_decl.decl;
-            switch (is_declaration(decl)) {
-                case Declaration_GlobalVariable_TAG: {
-                    const Node* init = decl->payload.global_variable.init;
-                    if (init)
-                        return get_string_literal(arena, init);
-                    break;
-                }
-                case Declaration_Constant_TAG: {
-                    return get_string_literal(arena, decl->payload.constant.instruction);
-                }
-                default:
-                    break;
-            }
-            return NULL;
+            return get_string_literal(arena, decl);
         }
         case PrimOp_TAG: {
             switch (node->payload.prim_op.op) {