feat!: improved NORET detection in type system

Author: Dax89

include/redasm/context.h

@@ -209,6 +209,7 @@ RD_API bool rd_expect_be16(const RDContext* self, RDAddress address, u16 v);
 RD_API bool rd_expect_be32(const RDContext* self, RDAddress address, u32 v);
 RD_API bool rd_expect_be64(const RDContext* self, RDAddress address, u64 v);
 RD_API bool rd_read_ptr(const RDContext* ctx, RDAddress address, RDAddress* v);
+RD_API bool rd_read_code_ptr(const RDContext* ctx, RDAddress address, RDAddress* v);
 RD_API bool rd_follow_ptr(RDContext* ctx, RDAddress address, RDAddress* v);
 RD_API bool rd_write_byte(RDContext* self, RDAddress address, u8 v);
 RD_API bool rd_write_le16(RDContext* self, RDAddress address, u16 v);

src/core/context.c

@@ -45,6 +45,54 @@ static void _rd_teardown_range(RDContext* self, const RDSegmentFull* seg,
     }
 }
 
+static bool _rd_read_ptr(const RDContext* ctx, unsigned int ptr_size,
+                         RDAddress address, RDAddress* v) {
+    bool is_be = ctx->processorplugin->flags & RD_PF_BE;
+
+    switch(ptr_size) {
+        case sizeof(u8): {
+            u8 ptr_v;
+            if(!rd_read_byte(ctx, address, &ptr_v)) return false;
+            *v = (RDAddress)ptr_v;
+            return true;
+        }
+
+        case sizeof(u16): {
+            u16 ptr_v;
+            if(is_be ? !rd_read_be16(ctx, address, &ptr_v)
+                     : !rd_read_le16(ctx, address, &ptr_v))
+                return false;
+
+            *v = (RDAddress)ptr_v;
+            return true;
+        }
+
+        case sizeof(u32): {
+            u32 ptr_v;
+            if(is_be ? !rd_read_be32(ctx, address, &ptr_v)
+                     : !rd_read_le32(ctx, address, &ptr_v))
+                return false;
+
+            *v = (RDAddress)ptr_v;
+            return true;
+        }
+
+        case sizeof(u64): {
+            u64 ptr_v;
+            if(is_be ? !rd_read_be64(ctx, address, &ptr_v)
+                     : !rd_read_le64(ctx, address, &ptr_v))
+                return false;
+
+            *v = (RDAddress)ptr_v;
+            return true;
+        }
+
+        default: break;
+    }
+
+    return false;
+}
+
 void rd_i_expand_range(RDContext* self, const RDSegmentFull* seg, usize* start,
                        usize* end) {
     assert(start && end);
@@ -724,50 +772,11 @@ bool rd_read_be64(const RDContext* self, RDAddress address, u64* v) {
 }
 
 bool rd_read_ptr(const RDContext* ctx, RDAddress address, RDAddress* v) {
-    bool is_be = ctx->processorplugin->flags & RD_PF_BE;
-
-    switch(ctx->processorplugin->ptr_size) {
-        case sizeof(u8): {
-            u8 ptr_v;
-            if(!rd_read_byte(ctx, address, &ptr_v)) return false;
-            *v = (RDAddress)ptr_v;
-            return true;
-        }
-
-        case sizeof(u16): {
-            u16 ptr_v;
-            if(is_be ? !rd_read_be16(ctx, address, &ptr_v)
-                     : !rd_read_le16(ctx, address, &ptr_v))
-                return false;
-
-            *v = (RDAddress)ptr_v;
-            return true;
-        }
-
-        case sizeof(u32): {
-            u32 ptr_v;
-            if(is_be ? !rd_read_be32(ctx, address, &ptr_v)
-                     : !rd_read_le32(ctx, address, &ptr_v))
-                return false;
-
-            *v = (RDAddress)ptr_v;
-            return true;
-        }
-
-        case sizeof(u64): {
-            u64 ptr_v;
-            if(is_be ? !rd_read_be64(ctx, address, &ptr_v)
-                     : !rd_read_le64(ctx, address, &ptr_v))
-                return false;
-
-            *v = (RDAddress)ptr_v;
-            return true;
-        }
-
-        default: break;
-    }
+    return _rd_read_ptr(ctx, rd_get_ptr_size(ctx), address, v);
+}
 
-    return false;
+bool rd_read_code_ptr(const RDContext* ctx, RDAddress address, RDAddress* v) {
+    return _rd_read_ptr(ctx, rd_get_code_ptr_size(ctx), address, v);
 }
 
 bool rd_follow_ptr(RDContext* ctx, RDAddress address, RDAddress* v) {

src/core/function.c

@@ -241,6 +241,8 @@ const char* rd_i_function_to_str(const RDFunction* self, RDContext* ctx) {
         str_push(&ctx->tdef_buf, ' ');
     }
 
+    if(rd_function_is_noret(self)) str_append(&ctx->tdef_buf, "noreturn ");
+
     RDName n; // try to get the name
     if(rd_i_get_name(ctx, self->address, false, &n))
         str_append(&ctx->tdef_buf, n.value);
@@ -264,8 +266,6 @@ const char* rd_i_function_to_str(const RDFunction* self, RDContext* ctx) {
         str_push(&ctx->tdef_buf, ')');
     }
 
-    if(rd_function_is_noret(self)) str_append(&ctx->tdef_buf, " noreturn");
-
     assert(!vect_is_empty(&ctx->tdef_buf));
     return ctx->tdef_buf.data;
 }

src/core/worker.c

@@ -77,13 +77,36 @@ static void _rd_worker_apply_function_types(RDContext* ctx) {
     RDTypeDef** it;
     vect_each(it, &ctx->typedefs) {
         const RDTypeDef* tdef = *it;
-        if(tdef->kind != RD_TKIND_FUNC) continue;
+
+        if(tdef->kind != RD_TKIND_FUNC || tdef->flags & RD_TFLAG_BUILTIN)
+            continue;
 
         RDAddress address;
         if(!rd_get_address(ctx, tdef->name, &address)) continue;
 
-        RDFunction* f = rd_i_find_function(ctx, address);
-        if(f) rd_i_function_set_type_def(f, tdef);
+        const RDSegmentFull* seg = rd_i_db_find_segment(ctx, address);
+        if(!seg) continue;
+
+        usize idx = rd_i_address2index(seg, address);
+
+        if(rd_flagsbuffer_has_func(seg->flags, idx)) {
+            RDFunction* f = rd_i_find_function(ctx, address);
+            if(!f || f->type_def == tdef) continue;
+
+            if(f->type_def && !(f->type_def->flags & RD_TFLAG_BUILTIN))
+                continue;
+
+            rd_i_function_set_type_def(f, tdef);
+        }
+        else if(rd_flagsbuffer_has_type(seg->flags, idx)) {
+            RDTypeFull t;
+            if(!rd_i_get_type(ctx, address, &t) || t.base.def == tdef) continue;
+            if(t.base.count > 0 || t.base.def->kind != RD_TKIND_FUNC) continue;
+            if(!(t.base.def->flags & RD_TFLAG_BUILTIN)) continue;
+
+            rd_i_set_type(ctx, address, tdef->name, 0, t.base.mod,
+                          RD_CONFIDENCE_LIBRARY);
+        }
     }
 }
 

src/db/db.c

@@ -132,12 +132,7 @@ void rd_i_db_load(RDContext* ctx) {
 
     // restore NORET status in KB
     RDTypeDef** it;
-    vect_each(it, &ctx->typedefs) {
-        rd_i_typedef_measure(ctx, *it);
-
-        if((*it)->kind == RD_TKIND_FUNC && (*it)->func_.is_noret)
-            rd_i_kb_add_noret(ctx, (*it)->name);
-    }
+    vect_each(it, &ctx->typedefs) { rd_i_typedef_measure(ctx, *it); }
 
     _rd_i_db_query_get_all_functions(ctx, &ctx->functions);
     _rd_i_db_query_get_all_sregval(ctx, &ctx->db->segment_regs,

src/io/flags.c

@@ -4,12 +4,12 @@
 /*
  * RDFlags: 32 bits per address.
  *
- * 31     27 26          22 21 20 19    17 16          9 8 7        0
+ * 31     27 26          21 20 19 18    16 15          9 8 7        0
  * ┌────────┬──────────────┬─────┬────────┬────────────┬─┬──────────┐
  * │  free  │  structure   │class│arrival │  preserve  │V│  value   │
  * └────────┴──────────────┴─────┴────────┴────────────┴─┴──────────┘
- *  └───── cleared by clear ─────┘ └────── survives clear ─────────┘
- *  └────── cleared by undefine ──────────┘ └─ survives undefine ──┘
+ *           └─ cleared by clear ─┘└──────── survives clear ────────┘
+ *           └──── cleared by undefine ────┘└─ survives undefine ───┘
  *
  * Ordering is forced by the masks: a flag survives an operation if it sits
  * BELOW that operation's cut. Both masks cut below the class bits, so both
@@ -18,15 +18,16 @@
  *
  * The three tiers, by who owns the truth:
  *   preserve   knowledge: users, loaders, DB rows. Class-agnostic and
- *              head-only: FL_NORET marks an instruction, a function EP or an
- *              IAT slot alike, exactly like FL_IMPORTED. Never retracted
- *              implicitly.
+ *              head-only. Never retracted implicitly.
  *   arrival    how control REACHES here (call/jump/fall-through). Owned by the
  *              referrer, not by this cell's decode: a byte change here does not
  *              invalidate them, so they survive clear + re-decode. Dropped by
  *              undefine ("means nothing") or by becoming a TAIL ("cannot live
  *              mid-item").
  *   structure  what these bytes DECODE TO. Re-derived on every decode.
+ *              FL_NORET lives here: it means "this instruction terminates
+ *              flow", derived from the callee's type (RDFunctionType.is_noret),
+ *              NOT "the symbol here never returns" - that lives in the type.
  *
  * FL_FLOW and FL_FUNC are mutually exclusive, enforced symmetrically by both
  * setters so the outcome does not depend on discovery order.
@@ -35,7 +36,7 @@
  *
  * FL_FLOW: set on the DESTINATION instruction:
  * - means "reached by fall-through from the previous instruction".
- * - never set on function entries (FL_FUNC) or noreturn functions (FL_NORET)
+ * - never set on function entries (FL_FUNC)
  * - both clear FL_FLOW automatically in their set functions.
  */
 
@@ -51,23 +52,22 @@ static const RDFlags FL_XREFOUT = 1U << 12;
 static const RDFlags FL_XREFIN = 1U << 13;
 static const RDFlags FL_EXPORTED = 1U << 14;
 static const RDFlags FL_IMPORTED = 1U << 15;
-static const RDFlags FL_NORET = 1U << 16;
 
 // covers bits 0-15 (NOTE: always add the last flag above)
-#define FL_UNDEFINE_MASK ((RDFlags)((FL_NORET << 1) - 1))
+#define FL_UNDEFINE_MASK ((RDFlags)((FL_IMPORTED << 1) - 1))
 #define FL_HAS_INFO                                                            \
     ((RDFlags)(FL_UNDEFINE_MASK & ~(FL_VALUE | FL_PATCH | 0xFF)))
 
 // [ARRIVAL]
-static const RDFlags FL_FLOW = 1U << 17;
-static const RDFlags FL_JMPDST = 1U << 18;
-static const RDFlags FL_FUNC = 1U << 19;
+static const RDFlags FL_FLOW = 1U << 16;
+static const RDFlags FL_JMPDST = 1U << 17;
+static const RDFlags FL_FUNC = 1U << 18;
 
-// covers bits 0-17 (NOTE: always add the last flag above)
+// covers bits 0-18 (NOTE: always add the last flag above)
 #define FL_CLEAR_MASK ((RDFlags)((FL_FUNC << 1) - 1))
 
-// [CLASS]: 2-bit field, bits 20-21
-#define FL_CLASS_SHIFT 20
+// [CLASS]: 2-bit field, bits 19-20
+#define FL_CLASS_SHIFT 19
 #define FL_CLASS_MASK ((RDFlags)(3U << FL_CLASS_SHIFT))
 
 typedef enum {
@@ -78,9 +78,9 @@ typedef enum {
 } RDFlagsClass;
 
 // [STRUCTURE] CODE
-// kind: 2-bit field, bits 22-23.
+// kind: 2-bit field, bits 21-22.
 // JUMP/CALL are mutually exclusive.
-#define FL_KIND_SHIFT 22
+#define FL_KIND_SHIFT 21
 #define FL_KIND_MASK ((RDFlags)(3U << FL_KIND_SHIFT))
 
 typedef enum {
@@ -89,14 +89,15 @@ typedef enum {
     FL_KI_CALL,
 } RDFlagsKind;
 
+static const RDFlags FL_NORET = 1U << 23;
 static const RDFlags FL_COND = 1U << 24;
 static const RDFlags FL_DSLOT = 1U << 25;
 static const RDFlags FL_OPOVER = 1U << 26;
 
 // [STRUCTURE] DATA
-static const RDFlags FL_TYPE = 1U << 22;
-static const RDFlags FL_FIELD = 1U << 23;
-static const RDFlags FL_ITEM = 1U << 24;
+static const RDFlags FL_TYPE = 1U << 23;
+static const RDFlags FL_FIELD = 1U << 24;
+static const RDFlags FL_ITEM = 1U << 25;
 
 static RDFlagsClass _rd_flags_class(RDFlags self) {
     return (RDFlagsClass)((self & FL_CLASS_MASK) >> FL_CLASS_SHIFT);
@@ -145,7 +146,9 @@ bool rd_i_flags_has_call(RDFlags self) {
     return _rd_flags_kind(self) == FL_KI_CALL;
 }
 
-bool rd_i_flags_has_noret(RDFlags self) { return self & FL_NORET; }
+bool rd_i_flags_has_noret(RDFlags self) {
+    return rd_i_flags_has_code(self) && (self & FL_NORET);
+}
 
 bool rd_i_flags_has_cond(RDFlags self) {
     return rd_i_flags_has_code(self) && (self & FL_COND);
@@ -238,7 +241,10 @@ void rd_i_flags_set_func(RDFlags* self) {
     *self &= ~FL_FLOW; // function entries break flow
 }
 
-void rd_i_flags_set_noret(RDFlags* self) { *self |= FL_NORET; }
+void rd_i_flags_set_noret(RDFlags* self) {
+    assert(rd_i_flags_has_code(*self));
+    *self |= FL_NORET;
+}
 
 void rd_i_flags_set_cond(RDFlags* self) {
     assert(rd_i_flags_has_jump(*self) || rd_i_flags_has_call(*self));

src/kb/kb.c

@@ -168,15 +168,6 @@ static const char* _rd_kb_get_param(const RDKBObject* obj, RDType* t,
     return rd_kbobject_get_str(obj, "name");
 }
 
-static void _rd_kb_apply_noret(RDContext* ctx) {
-    const char** it;
-    vect_each(it, &ctx->kb->noret_names) {
-        RDAddress address;
-        if(!rd_get_address(ctx, *it, &address)) continue;
-        rd_i_set_noret(ctx, address);
-    }
-}
-
 static void _rd_kb_load_dependencies(const RDKBObject* root, RDContext* ctx) {
     const RDKBObject* manifest = rd_kbobject_get_table(root, "manifest");
     if(!manifest) return;
@@ -313,7 +304,6 @@ static bool _rd_kb_load_functions(const RDKBObject* root, RDContext* ctx) {
         rd_typedef_register(tdef, ctx);
     }
 
-    _rd_kb_apply_noret(ctx);
     return true;
 }
 
@@ -399,30 +389,10 @@ void rd_i_kb_destroy(RDKB* self) {
     }
 
     vect_destroy(&self->ordinal_modules);
-    vect_destroy(&self->noret_names);
     vect_destroy(&self->files);
     rd_free(self);
 }
 
-void rd_i_kb_add_noret(RDContext* ctx, const char* name) {
-    assert(name);
-
-    usize idx =
-        vect_lower_bound(&ctx->kb->noret_names, name, rd_i_strcmp_key_pred);
-
-    if(idx == vect_length(&ctx->kb->noret_names) ||
-       name != *vect_at(&ctx->kb->noret_names, idx)) {
-        vect_ins(&ctx->kb->noret_names, idx, name);
-    }
-}
-
-bool rd_i_kb_is_noret(const RDContext* ctx, const char* name) {
-    assert(name);
-
-    usize idx = vect_bsearch(&ctx->kb->noret_names, name, rd_i_strcmp_key_pred);
-    return idx < vect_length(&ctx->kb->noret_names);
-}
-
 const char* rd_i_kb_find_ordinal_name(RDContext* ctx, const char* module,
                                       u32 ordinal) {
     const RDKBOrdinalModule* mod =

src/kb/kb.h

@@ -39,20 +39,12 @@ typedef struct RDKB {
         usize length;
         usize capacity;
     } ordinal_modules;
-
-    struct {
-        const char** data;
-        usize length;
-        usize capacity;
-    } noret_names;
 } RDKB;
 
 void rd_i_kb_paths_init(const char** kb_paths);
 void rd_i_kb_paths_deinit(RDPathVect* self);
 
 RDKB* rd_i_kb_create(void);
 void rd_i_kb_destroy(RDKB* self);
-void rd_i_kb_add_noret(RDContext* ctx, const char* name);
-bool rd_i_kb_is_noret(const RDContext* ctx, const char* name);
 const char* rd_i_kb_find_ordinal_name(RDContext* ctx, const char* module,
                                       u32 ordinal);