l2s: parsing improvements

Author: Hugobros3

src/frontends/llvm/l2s_instr.c

@@ -272,10 +272,19 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
         } case LLVMSExt: {
             // reinterpret as signed, convert to change size, reinterpret back to target T
             const Type* src_t = convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0)));
-            const Type* signed_src_t = change_int_t_sign(src_t, true);
-            const Type* signed_dst_t = change_int_t_sign(t, true);
-            r = prim_op_helper(a, convert_op, singleton(signed_dst_t), reinterpret_operands(b, convert_operands(p, num_ops, instr), signed_src_t));
-            r = prim_op_helper(a, reinterpret_op, singleton(t), BIND_PREV_R(signed_dst_t));
+            Nodes ops = convert_operands(p, num_ops, instr);
+            if (src_t->tag == Bool_TAG) {
+                assert(t->tag == Int_TAG);
+                const Node* zero = int_literal(a, (IntLiteral) { .value = 0, .width = t->payload.int_type.width, .is_signed = t->payload.int_type.is_signed });
+                uint64_t i = UINT64_MAX >> (64 - int_size_in_bytes(t->payload.int_type.width) * 8);
+                const Node* ones = int_literal(a, (IntLiteral) { .value = i, .width = t->payload.int_type.width, .is_signed = t->payload.int_type.is_signed });
+                r = prim_op_helper(a, select_op, empty(a), mk_nodes(a, first(ops), ones, zero));
+            } else {
+                const Type* signed_src_t = change_int_t_sign(src_t, true);
+                const Type* signed_dst_t = change_int_t_sign(t, true);
+                r = prim_op_helper(a, convert_op, singleton(signed_dst_t), reinterpret_operands(b, ops, signed_src_t));
+                r = prim_op_helper(a, reinterpret_op, singleton(t), BIND_PREV_R(signed_dst_t));
+            }
             break;
         } case LLVMFPToUI:
         case LLVMFPToSI:
@@ -439,6 +448,14 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
                     // TODO
                     return (EmittedInstr) { 0 };
                 }
+                if (strcmp(intrinsic, "llvm.dbg.value") == 0) {
+                    // TODO
+                    return (EmittedInstr) { 0 };
+                }
+                if (string_starts_with(intrinsic, "llvm.lifetime")) {
+                    // don't care
+                    return (EmittedInstr) { 0 };
+                }
                 if (string_starts_with(intrinsic, "llvm.memcpy")) {
                     Nodes ops = convert_operands(p, num_ops, instr);
                     num_results = 0;

src/frontends/llvm/l2s_postprocess.c

@@ -65,6 +65,17 @@ bool lexical_scope_is_nested(Nodes scope, Nodes parentMaybe) {
 
 bool compare_nodes(Nodes* a, Nodes* b);
 
+static Nodes remake_variables(Context* ctx, Nodes old) {
+    IrArena* a = ctx->rewriter.dst_arena;
+    LARRAY(const Node*, nvars, old.count);
+    for (size_t i = 0; i < old.count; i++) {
+        const Node* node = old.nodes[i];
+            nvars[i] = var(a, node->payload.var.type ? qualified_type_helper(rewrite_node(&ctx->rewriter, node->payload.var.type), false) : NULL, node->payload.var.name);
+        assert(nvars[i]->tag == Variable_TAG);
+    }
+    return nodes(a, old.count, nvars);
+}
+
 static const Node* process_op(Context* ctx, NodeClass op_class, String op_name, const Node* node) {
     IrArena* a = ctx->rewriter.dst_arena;
     switch (node->tag) {
@@ -156,7 +167,6 @@ static const Node* process_op(Context* ctx, NodeClass op_class, String op_name,
                         } else if (compare_nodes(dom_lexical_scope, dst_lexical_scope)) {
                             debug_print("We need to introduce a control() block at %s, pointing at %s\n.", get_abstraction_name(dom->node), get_abstraction_name(dst));
                             Controls** found = find_value_dict(const Node, Controls*, ctx->controls, dom->node);
-                            assert(found);
                             if (found) {
                                 Controls* controls = *found;
                                 const Node* join_token = NULL;
@@ -174,15 +184,15 @@ static const Node* process_op(Context* ctx, NodeClass op_class, String op_name,
                                     controls->tokens = append_nodes(a, controls->tokens, join_token);
                                     controls->destinations = append_nodes(a, controls->destinations, dst);
                                 }
-                                Nodes nargs = recreate_variables(&ctx->rewriter, get_abstraction_params(dst));
-
+                                Nodes nparams = remake_variables(ctx, get_abstraction_params(dst));
+                                //register_processed_list(&ctx->rewriter, get_abstraction_params(dst), nparams);
                                 Node* fn = src;
                                 if (fn->tag == BasicBlock_TAG)
                                     fn = (Node*) fn->payload.basic_block.fn;
                                 assert(fn->tag == Function_TAG);
-                                Node* wrapper = basic_block(a, fn, nargs, format_string_arena(a->arena, "wrapper_to_%s", get_abstraction_name(dst)));
+                                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 = nargs,
+                                    .args = nparams,
                                     .join_point = join_token
                                 });
                                 return jump_helper(a, wrapper, rewrite_nodes(&ctx->rewriter, node->payload.jump.args));
@@ -247,7 +257,7 @@ void postprocess(Parser* p, Module* src, Module* dst) {
 
     ctx.rewriter.rewrite_op_fn = (RewriteOpFn) process_op;
     ctx.rewriter.config.process_variables = true;
-    // ctx.rewriter.config.search_map = false;
+    ctx.rewriter.config.search_map = true;
     // ctx.rewriter.config.write_map = false;
 
     rewrite_module(&ctx.rewriter);