fix fn pointers and global data

Author: Hugobros3

src/frontends/llvm/l2s_instr.c

@@ -452,13 +452,18 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
             LLVMValueRef callee = LLVMGetCalledValue(instr);
             callee = remove_ptr_bitcasts(p, callee);
             assert(num_args + 1 == num_ops);
-            String intrinsic = is_llvm_intrinsic(callee);
-            if (!intrinsic)
-                intrinsic = is_shady_intrinsic(callee);
+            String intrinsic = NULL;
+            if (LLVMIsAFunction(callee) || LLVMIsAConstant(callee)) {
+                intrinsic = is_llvm_intrinsic(callee);
+                if (!intrinsic)
+                    intrinsic = is_shady_intrinsic(callee);
+            }
             if (intrinsic) {
                 assert(LLVMIsAFunction(callee));
                 if (strcmp(intrinsic, "llvm.dbg.declare") == 0) {
                     const Node* target = convert_value(p, LLVMGetOperand(instr, 0));
+                    if (target->tag != Variable_TAG)
+                        return (EmittedInstr) { 0 };
                     assert(target->tag == Variable_TAG);
                     const Node* meta = convert_value(p, LLVMGetOperand(instr, 1));
                     assert(meta->tag == RefDecl_TAG);

src/frontends/llvm/l2s_type.c

@@ -36,7 +36,7 @@ const Type* convert_type(Parser* p, LLVMTypeRef t) {
             LLVMGetParamTypes(t, param_types);
             LARRAY(const Type*, cparam_types, num_params);
             for (size_t i = 0; i < num_params; i++)
-                cparam_types[i] = convert_type(p, param_types[i]);
+                cparam_types[i] = qualified_type_helper(convert_type(p, param_types[i]), false);
             const Type* ret_type = convert_type(p, LLVMGetReturnType(t));
             if (LLVMGetTypeKind(LLVMGetReturnType(t)) == LLVMVoidTypeKind)
                 ret_type = empty_multiple_return_type(a);

src/runtime/vulkan/vk_runtime_program.c

@@ -8,6 +8,7 @@
 
 #include "arena.h"
 #include "util.h"
+#include "type.h"
 
 #include "../../shady/transform/memory_layout.h"
 
@@ -42,6 +43,46 @@ VkDescriptorType as_to_descriptor_type(AddressSpace as) {
     }
 }
 
+static void write_value(unsigned char* tgt, const Node* value) {
+    IrArena* a = value->arena;
+    switch (value->tag) {
+        case IntLiteral_TAG: {
+            switch (value->payload.int_literal.width) {
+                case IntTy8: *((uint8_t*) tgt) = (uint8_t) (value->payload.int_literal.value & 0xFF); break;
+                case IntTy16: *((uint16_t*) tgt) = (uint16_t) (value->payload.int_literal.value & 0xFFFF); break;
+                case IntTy32: *((uint32_t*) tgt) = (uint32_t) (value->payload.int_literal.value & 0xFFFFFFFF); break;
+                case IntTy64: *((uint64_t*) tgt) = (uint64_t) (value->payload.int_literal.value); break;
+            }
+            break;
+        }
+        case Composite_TAG: {
+            Nodes values = value->payload.composite.contents;
+            const Type* struct_t = value->payload.composite.type;
+            struct_t = get_maybe_nominal_type_body(struct_t);
+
+            if (struct_t->tag == RecordType_TAG) {
+                LARRAY(FieldLayout, fields, values.count);
+                get_record_layout(a, struct_t, fields);
+                for (size_t i = 0; i < values.count; i++) {
+                    // TypeMemLayout layout = get_mem_layout(value->arena, get_unqualified_type(element->type));
+                    write_value(tgt + fields->offset_in_bytes, values.nodes[i]);
+                }
+            } else if (struct_t->tag == ArrType_TAG) {
+                for (size_t i = 0; i < values.count; i++) {
+                    TypeMemLayout layout = get_mem_layout(value->arena, get_unqualified_type(values.nodes[i]->type));
+                    write_value(tgt, values.nodes[i]);
+                    tgt += layout.size_in_bytes;
+                }
+            } else {
+                assert(false);
+            }
+            break;
+        }
+        default:
+            assert(false);
+    }
+}
+
 static bool extract_resources_layout(VkrSpecProgram* program, VkDescriptorSetLayout layouts[]) {
     VkDescriptorSetLayoutCreateInfo layout_create_infos[MAX_DESCRIPTOR_SETS] = { 0 };
     Growy* bindings_lists[MAX_DESCRIPTOR_SETS] = { 0 };
@@ -78,6 +119,8 @@ static bool extract_resources_layout(VkrSpecProgram* program, VkDescriptorSetLay
 
             for (size_t j = 0; j < struct_t->payload.record_type.members.count; j++) {
                 const Type* member_t = struct_t->payload.record_type.members.nodes[j];
+                assert(member_t->tag == PtrType_TAG);
+                member_t = get_pointee_type(program->arena, member_t);
                 TypeMemLayout layout = get_mem_layout(program->specialized_module->arena, member_t);
 
                 ProgramResourceInfo* constant_res_info = arena_alloc(program->arena, sizeof(ProgramResourceInfo));
@@ -93,6 +136,15 @@ static bool extract_resources_layout(VkrSpecProgram* program, VkDescriptorSetLay
                 res_info->size += sizeof(void*);
 
                 // TODO initial value
+                Nodes annotations = get_declaration_annotations(decl);
+                for (size_t k = 0; k < annotations.count; k++) {
+                    const Node* a = annotations.nodes[k];
+                    if ((strcmp(get_annotation_name(a), "InitialValue") == 0) && resolve_to_int_literal(first(get_annotation_values(a)))->value == j) {
+                        constant_res_info->default_data = calloc(1, layout.size_in_bytes);
+                        write_value(constant_res_info->default_data, get_annotation_values(a).nodes[1]);
+                        //printf("wowie");
+                    }
+                }
             }
 
             if (vkr_can_import_host_memory(program->device))
@@ -394,11 +446,13 @@ static bool prepare_resources(VkrSpecProgram* program) {
             resource->buffer = allocate_buffer_device(program->device, resource->size);
         }
 
-        // TODO: initial data!
-        // if (!resource->host_owned)
-        char* zeroes = calloc(1, resource->size);
-        copy_to_buffer(resource->buffer, 0, zeroes, resource->size);
-        free(zeroes);
+        if (resource->default_data) {
+            copy_to_buffer(resource->buffer, 0, resource->default_data, resource->size);
+        } else {
+            char* zeroes = calloc(1, resource->size);
+            copy_to_buffer(resource->buffer, 0, zeroes, resource->size);
+            free(zeroes);
+        }
 
         if (resource->parent) {
             char* dst = resource->parent->host_ptr;

src/shady/analysis/callgraph.c

@@ -38,7 +38,10 @@ static const Node* ignore_immediate_fn_addr(const Node* node) {
     return node;
 }
 
+static CGNode* analyze_fn(CallGraph* graph, const Node* fn);
+
 static void visit_callsite(CGVisitor* visitor, const Node* callee, const Node* instr) {
+    assert(visitor->root);
     assert(callee->tag == Function_TAG);
     CGNode* target = analyze_fn(visitor->graph, callee);
     // Immediate recursion
@@ -55,10 +58,11 @@ static void visit_callsite(CGVisitor* visitor, const Node* callee, const Node* i
 }
 
 static void search_for_callsites(CGVisitor* visitor, const Node* node) {
-    assert(is_abstraction(visitor->abs));
+    assert((visitor->abs && is_abstraction(visitor->abs)) || !visitor->root);
     switch (node->tag) {
         case Function_TAG: {
             assert(false);
+            // analyze_fn(visitor->graph, node)->is_address_captured = true;
             break;
         }
         case BasicBlock_TAG:
@@ -74,12 +78,15 @@ static void search_for_callsites(CGVisitor* visitor, const Node* node) {
             break;
         }
         case Call_TAG: {
+            assert(visitor->root && "calls can only occur in functions");
             const Node* callee = node->payload.call.callee;
             callee = ignore_immediate_fn_addr(callee);
             if (callee->tag == Function_TAG)
                 visit_callsite(visitor, callee, node);
-            else
+            else {
+                visitor->root->calls_indirect = true;
                 visit_op(&visitor->visitor, NcValue, "callee", callee);
+            }
             visit_ops(&visitor->visitor, NcValue, "args", node->payload.call.args);
             break;
         }
@@ -216,8 +223,29 @@ CallGraph* new_callgraph(Module* mod) {
 
     Nodes decls = get_module_declarations(mod);
     for (size_t i = 0; i < decls.count; i++) {
-        if (decls.nodes[i]->tag == Function_TAG) {
-            analyze_fn(graph, decls.nodes[i]);
+        const Node* decl = decls.nodes[i];
+        if (decl->tag == Function_TAG) {
+            analyze_fn(graph, decl);
+        } else if (decl->tag == GlobalVariable_TAG && decl->payload.global_variable.init) {
+            CGVisitor v = {
+                .visitor = {
+                    .visit_node_fn = (VisitNodeFn) search_for_callsites
+                },
+                .graph = graph,
+                .root = NULL,
+                .abs = NULL,
+            };
+            search_for_callsites(&v, decl->payload.global_variable.init);
+        } else if (decl->tag == Constant_TAG && decl->payload.constant.instruction) {
+            CGVisitor v = {
+                .visitor = {
+                    .visit_node_fn = (VisitNodeFn) search_for_callsites
+                },
+                .graph = graph,
+                .root = NULL,
+                .abs = NULL,
+            };
+            search_for_callsites(&v, decl->payload.constant.instruction);
         }
     }
 

src/shady/analysis/callgraph.h

@@ -24,6 +24,7 @@ struct CGNode_ {
     bool is_recursive;
     /// set to true if the address of this is captured by a FnAddr node that is not immediately consumed by a call
     bool is_address_captured;
+    bool calls_indirect;
 };
 
 typedef struct Callgraph_ {

src/shady/passes/lower_callf.c

@@ -24,6 +24,7 @@ static const Node* lower_callf_process(Context* ctx, const Node* old) {
     if (found) return found;
     IrArena* a = ctx->rewriter.dst_arena;
     Module* m = ctx->rewriter.dst_module;
+    Rewriter* r = &ctx->rewriter;
 
     if (old->tag == Function_TAG) {
         Context ctx2 = *ctx;
@@ -67,6 +68,19 @@ static const Node* lower_callf_process(Context* ctx, const Node* old) {
         return recreate_node_identity(&ctx->rewriter, old);
 
     switch (old->tag) {
+        case FnType_TAG: {
+            Nodes param_types = rewrite_nodes(r, old->payload.fn_type.param_types);
+            Nodes returned_types = rewrite_nodes(&ctx->rewriter, old->payload.fn_type.return_types);
+            const Type* jp_type = qualified_type(a, (QualifiedType) {
+                    .type = join_point_type(a, (JoinPointType) { .yield_types = strip_qualifiers(a, returned_types) }),
+                    .is_uniform = false
+            });
+            param_types = append_nodes(a, param_types, jp_type);
+            return fn_type(a, (FnType) {
+                .param_types = param_types,
+                .return_types = empty(a),
+            });
+        }
         case Return_TAG: {
             Nodes nargs = rewrite_nodes(&ctx->rewriter, old->payload.fn_ret.args);
 

src/shady/passes/mark_leaf_functions.c

@@ -47,10 +47,28 @@ static bool is_leaf_fn(Context* ctx, CGNode* fn_node) {
     info = find_value_dict(const Node*, FnInfo, ctx->fns, fn_node->fn);
     assert(info);
 
-    if (fn_node->is_address_captured || fn_node->is_recursive) {
+    if (fn_node->is_address_captured || fn_node->is_recursive || fn_node->calls_indirect) {
         info->is_leaf = false;
         info->done = true;
-        debugv_print("Function %s can't be a leaf function because %s.\n", get_abstraction_name(fn_node->fn), fn_node->is_address_captured ? "its address is captured" : "it is recursive" );
+        debugv_print("Function %s can't be a leaf function because", get_abstraction_name(fn_node->fn));
+        bool and = false;
+        if (fn_node->is_address_captured) {
+            debugv_print("its address is captured");
+            and = true;
+        }
+        if (fn_node->is_recursive) {
+            if (and)
+                debugv_print(" and ");
+            debugv_print("it is recursive");
+            and = true;
+        }
+        if (fn_node->calls_indirect) {
+            if (and)
+                debugv_print(" and ");
+            debugv_print("it makes indirect calls");
+            and = true;
+        }
+        debugv_print(".\n");
         return false;
     }
 

src/shady/passes/spirv_lift_globals_ssbo.c

@@ -104,7 +104,7 @@ Module* spirv_lift_globals_ssbo(SHADY_UNUSED const CompilerConfig* config, Modul
         if (odecl->tag != GlobalVariable_TAG || odecl->payload.global_variable.address_space != AsGlobal)
             continue;
         if (odecl->payload.global_variable.init)
-            annotations = append_nodes(a, annotations, annotation_values(a, (AnnotationValues) {
+            ctx.lifted_globals_decl->payload.global_variable.annotations = append_nodes(a, ctx.lifted_globals_decl->payload.global_variable.annotations, annotation_values(a, (AnnotationValues) {
                     .name = "InitialValue",
                     .values = mk_nodes(a, int32_literal(a, lifted_globals_count), rewrite_node(&ctx.rewriter, odecl->payload.global_variable.init))
             }));