address spaces are no longer inherently logical or physical

Author: Hugobros3

include/shady/grammar.json

@@ -2,53 +2,32 @@
   "address-spaces": [
     {
       "name": "Generic",
-      "llvm-id": 0,
-      "physical": true
+      "llvm-id": 0
     },
     {
-      "name": "GlobalPhysical",
+      "name": "Global",
       "description": "Global memory, all threads see the same data (not necessarily consistent!)",
-      "llvm-id": 1,
-      "physical": true
+      "llvm-id": 1
     },
     {
-      "name": "SharedPhysical",
+      "name": "Shared",
       "description": "Points into workgroup-private memory (aka shared memory)",
-      "llvm-id": 3,
-      "physical": true
+      "llvm-id": 3
     },
     {
-      "name": "SubgroupPhysical",
+      "name": "Subgroup",
       "description": [
         "Points into subgroup-private memory",
         "All threads in a subgroup see the same contents for the same address, but threads in different subgroups see different data.",
         "Needs to be lowered to something else since targets do not understand this" ],
-      "llvm-id": 9,
-      "physical": true
+      "llvm-id": 9
     },
     {
-      "name": "PrivatePhysical",
+      "name": "Private",
       "description": [
         "Points into thread-private memory (all threads see different contents for the same address)"
       ],
-      "llvm-id": 5,
-      "physical": true
-    },
-    {
-      "name": "GlobalLogical",
-      "llvm-id": 388
-    },
-    {
-      "name": "SharedLogical",
-      "llvm-id": 387
-    },
-    {
-      "name": "SubgroupLogical",
-      "llvm-id": 386
-    },
-    {
-      "name": "PrivateLogical",
-      "llvm-id": 385
+      "llvm-id": 5
     },
     {
       "name": "Input",
@@ -74,8 +53,8 @@
       "llvm-id": 392
     },
     {
-      "name": "FunctionLogical",
-      "description": "Weird SPIR-V nonsense: this is like PrivateLogical, but with non-static lifetimes (ie function lifetime)",
+      "name": "Function",
+      "description": "Weird SPIR-V nonsense: this is like Private, but with non-static lifetimes (ie function lifetime)",
       "llvm-id": 393
     },
     {

include/shady/ir.h

@@ -73,8 +73,10 @@ typedef struct {
     bool validate_builtin_types; // do @Builtins variables need to match their type in builtins.h ?
     bool is_simt;
 
-    bool allow_subgroup_memory;
-    bool allow_shared_memory;
+    struct {
+        bool physical;
+        bool allowed;
+    } address_spaces[NumAddressSpaces];
 
     struct {
         /// Selects which type the subgroup intrinsic primops use to manipulate masks
@@ -278,7 +280,6 @@ typedef struct CompilerConfig_ {
     struct {
         bool spv_shuffle_instead_of_broadcast_first;
         bool force_join_point_lifting;
-        bool assume_no_physical_global_ptrs;
         bool restructure_everything;
         bool recover_structure;
     } hacks;

samples/fib.slim

@@ -5,10 +5,10 @@ fn fib varying u32(varying u32 n) {
 }
 
 @Builtin("SubgroupLocalInvocationId")
-input u32 subgroup_local_id;
+var input u32 subgroup_local_id;
 
 @Builtin("SubgroupId")
-uniform input u32 subgroup_id;
+var uniform input u32 subgroup_id;
 
 @EntryPoint("Compute") @WorkgroupSize(32, 1, 1) fn main() {
     val n = subgroup_local_id % u32 16;

src/driver/cli.c

@@ -93,7 +93,6 @@ F(lower.emulate_physical_memory, emulate-physical-memory) \
 F(lower.emulate_generic_ptrs, emulate-generic-pointers) \
 F(dynamic_scheduling, dynamic-scheduling) \
 F(hacks.force_join_point_lifting, lift-join-points) \
-F(hacks.assume_no_physical_global_ptrs, assume-no-physical-global-ptrs) \
 F(logging.print_internal, print-internal) \
 F(logging.print_generated, print-builtin) \
 F(logging.print_generated, print-generated) \

src/frontends/llvm/l2s_annotations.c

@@ -29,6 +29,23 @@ static const Node* assert_and_strip_fn_addr(const Node* fn) {
     return fn;
 }
 
+static const Node* look_past_stuff(const Node* thing) {
+    if (thing->tag == Constant_TAG) {
+        const Node* instr = thing->payload.constant.instruction;
+        assert(instr->tag == PrimOp_TAG);
+        thing = instr;
+    }
+    if (thing->tag == PrimOp_TAG) {
+        switch (thing->payload.prim_op.op) {
+            case reinterpret_op:
+            case convert_op:
+            case lea_op: thing = first(thing->payload.prim_op.operands); break;
+            default: assert(false);
+        }
+    }
+    return thing;
+}
+
 void process_llvm_annotations(Parser* p, LLVMValueRef global) {
     IrArena* a = get_module_arena(p->dst);
     const Type* t = convert_type(p, LLVMGlobalGetValueType(global));
@@ -39,19 +56,11 @@ void process_llvm_annotations(Parser* p, LLVMValueRef global) {
     assert(value->tag == Composite_TAG && value->payload.composite.contents.count == arr_size);
     for (size_t i = 0; i < arr_size; i++) {
         const Node* entry = value->payload.composite.contents.nodes[i];
+        entry = look_past_stuff(entry);
         assert(entry->tag == Composite_TAG);
         const Node* annotation_payload = entry->payload.composite.contents.nodes[1];
         // eliminate dummy reinterpret cast
-        if (annotation_payload->tag == Constant_TAG) {
-            const Node* instr = annotation_payload->payload.constant.instruction;
-            assert(instr->tag == PrimOp_TAG);
-            switch (instr->payload.prim_op.op) {
-                case reinterpret_op:
-                case convert_op:
-                case lea_op: annotation_payload = first(instr->payload.prim_op.operands); break;
-                default: assert(false);
-            }
-        }
+        annotation_payload = look_past_stuff(annotation_payload);
         if (annotation_payload->tag == RefDecl_TAG) {
             annotation_payload = annotation_payload->payload.ref_decl.decl;
         }

src/frontends/llvm/l2s_instr.c

@@ -219,10 +219,10 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
         case LLVMAlloca: {
             assert(t->tag == PtrType_TAG);
             const Type* allocated_t = convert_type(p, LLVMGetAllocatedType(instr));
-            const Type* allocated_ptr_t = ptr_type(a, (PtrType) { .pointed_type = allocated_t, .address_space = AsPrivatePhysical });
+            const Type* allocated_ptr_t = ptr_type(a, (PtrType) { .pointed_type = allocated_t, .address_space = AsPrivate });
             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 = AsPrivatePhysical });
+                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 = prim_op_helper(a, convert_op, singleton(t), singleton(r));
@@ -308,24 +308,13 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
             if (src_t->tag == PtrType_TAG && t->tag == PtrType_TAG) {
                 if ((t->payload.ptr_type.address_space == AsGeneric)) {
                     switch (src_t->payload.ptr_type.address_space) {
-                        case AsPrivatePhysical:
-                        case AsSubgroupPhysical:
-                        case AsSharedPhysical:
-                        case AsGlobalPhysical:
-                            op = convert_op;
-                            break;
                         case AsGeneric: // generic-to-generic isn't a conversion.
                             break;
                         default: {
-                            warn_print("Cannot cast address space %s to Generic! Ignoring.\n", get_address_space_name(src_t->payload.ptr_type.address_space));
-                            r = quote_helper(a, singleton(src));
-                            goto shortcut;
+                            op = convert_op;
+                            break;
                         }
                     }
-                } else if (!is_physical_as(t->payload.ptr_type.address_space)) {
-                    warn_print("Cannot cast address space %s since it's non-physical. Ignoring.\n", get_address_space_name(src_t->payload.ptr_type.address_space));
-                    r = quote_helper(a, singleton(src));
-                    goto shortcut;
                 }
             } else {
                 assert(opcode != LLVMAddrSpaceCast);

src/frontends/slim/parser.c

@@ -996,30 +996,48 @@ static const Node* accept_fn_decl(ctxparams, Nodes annotations) {
 }
 
 static const Node* accept_global_var_decl(ctxparams, Nodes annotations) {
-    AddressSpace as;
-    if (accept_token(ctx, private_tok))
-        as = AsPrivateLogical;
-    else if (accept_token(ctx, shared_tok))
-        as = AsSharedLogical;
-    else if (accept_token(ctx, subgroup_tok))
-        as = AsSubgroupLogical;
-    else if (accept_token(ctx, global_tok))
-        as = AsGlobalLogical;
-    else if (accept_token(ctx, extern_tok))
-        as = AsExternal;
-    else if (accept_token(ctx, input_tok))
-        as = AsInput;
-    else if (accept_token(ctx, output_tok))
-        as = AsOutput;
-    else if (accept_token(ctx, uniform_tok)) {
-        if (accept_token(ctx, input_tok)) {
+    if (!accept_token(ctx, var_tok))
+        return NULL;
+
+    AddressSpace as = NumAddressSpaces;
+    bool uniform = false, logical = false;
+    while (true) {
+        AddressSpace nas = accept_address_space(ctx);
+        if (nas != NumAddressSpaces) {
+            if (as != NumAddressSpaces && as != nas) {
+                error("Conflicting address spaces for definition: %s and %s.\n", get_address_space_name(as), get_address_space_name(nas));
+            }
+            as = nas;
+            continue;
+        }
+        if (accept_token(ctx, logical_tok)) {
+            logical = true;
+            continue;
+        }
+        if (accept_token(ctx, uniform_tok)) {
+            uniform = true;
+            continue;
+        }
+        break;
+    }
+
+    if (as == NumAddressSpaces) {
+        error("Address space required for global variable declaration.\n");
+    }
+
+    if (uniform) {
+        if (as == AsInput)
             as = AsUInput;
-        } else {
-            expect(false && "expected 'input'");
-            return NULL;
+        else {
+            error("'uniform' can only be used with 'input' currently.\n");
         }
-    } else
-        return NULL;
+    }
+
+    if (logical) {
+        annotations = append_nodes(arena, annotations, annotation(arena, (Annotation) {
+            .name = "Logical"
+        }));
+    }
 
     const Type* type = accept_unqualified_type(ctx);
     expect(type);

src/frontends/slim/token.h

@@ -26,6 +26,7 @@ TEXT_TOKEN(input) \
 TEXT_TOKEN(output) \
 TOKEN(extern, "extern") \
 TEXT_TOKEN(generic) \
+TEXT_TOKEN(logical) \
 TEXT_TOKEN(var) \
 TEXT_TOKEN(val) \
 TEXT_TOKEN(let) \

src/frontends/spirv/s2s.c

@@ -203,33 +203,36 @@ AddressSpace convert_storage_class(SpvStorageClass class) {
     switch (class) {
         case SpvStorageClassInput:                 return AsInput;
         case SpvStorageClassOutput:                return AsOutput;
-        case SpvStorageClassWorkgroup:             return AsSharedPhysical;
-        case SpvStorageClassCrossWorkgroup:        return AsGlobalPhysical;
-        case SpvStorageClassPhysicalStorageBuffer: return AsGlobalPhysical;
-        case SpvStorageClassPrivate:               return AsPrivatePhysical;
-        case SpvStorageClassFunction:              return AsPrivatePhysical;
+        case SpvStorageClassWorkgroup:             return AsShared;
+        case SpvStorageClassCrossWorkgroup:        return AsGlobal;
+        case SpvStorageClassPhysicalStorageBuffer: return AsGlobal;
+        case SpvStorageClassPrivate:               return AsPrivate;
+        case SpvStorageClassFunction:              return AsPrivate;
         case SpvStorageClassGeneric:               return AsGeneric;
         case SpvStorageClassPushConstant:          return AsPushConstant;
         case SpvStorageClassAtomicCounter:
-        error("TODO");
+            break;
         case SpvStorageClassImage:                 return AsImage;
-            error("TODO");
-        case SpvStorageClassStorageBuffer:         return AsGlobalLogical;
+            break;
+        case SpvStorageClassStorageBuffer:         return AsShaderStorageBufferObject;
         case SpvStorageClassUniformConstant:
-        case SpvStorageClassUniform:               return AsGlobalPhysical; // TODO: should probably depend on CL/VK flavours!
+        case SpvStorageClassUniform:               return AsGlobal; // TODO: should probably depend on CL/VK flavours!
         case SpvStorageClassCallableDataKHR:
         case SpvStorageClassIncomingCallableDataKHR:
         case SpvStorageClassRayPayloadKHR:
         case SpvStorageClassHitAttributeKHR:
         case SpvStorageClassIncomingRayPayloadKHR:
         case SpvStorageClassShaderRecordBufferKHR:
-            error("Unsupported");
+            break;
         case SpvStorageClassCodeSectionINTEL:
         case SpvStorageClassDeviceOnlyINTEL:
         case SpvStorageClassHostOnlyINTEL:
         case SpvStorageClassMax:
-            error("Unsupported");
+            break;
+        default:
+            break;
     }
+    error("s2s: Unsupported storage class: %d\n", class);
 }
 
 typedef struct {

src/shady/api/generator_grammar.c

@@ -10,18 +10,6 @@ static void generate_address_spaces(Growy* g, json_object* address_spaces) {
     }
     growy_append_formatted(g, "\tNumAddressSpaces,\n");
     growy_append_formatted(g, "} AddressSpace;\n\n");
-
-    growy_append_formatted(g, "static inline bool is_physical_as(AddressSpace as) {\n");
-    growy_append_formatted(g, "\tswitch(as) {\n");
-    for (size_t i = 0; i < json_object_array_length(address_spaces); i++) {
-        json_object* as = json_object_array_get_idx(address_spaces, i);
-        String name = json_object_get_string(json_object_object_get(as, "name"));
-        if (json_object_get_boolean(json_object_object_get(as, "physical")))
-            growy_append_formatted(g, "\t\tcase As%s: return true;\n", name);
-    }
-    growy_append_formatted(g, "\t\tdefault: return false;\n");
-    growy_append_formatted(g, "\t}\n");
-    growy_append_formatted(g, "}\n\n");
 }
 
 static void generate_node_tags(Growy* g, json_object* nodes) {