Handle null pointer constants of _BitInt type

Author: fuhsnn

parse.c

@@ -226,6 +226,7 @@ static Node *assign(Token **rest, Token *tok);
 static long_double_t eval_double(Node *node);
 static void eval_fp(Node *node, FPVal *fval);
 static uint64_t *eval_bitint(Node *node);
+static uint64_t *eval_bitint_clean(Node *node);
 static Node *conditional(Token **rest, Token *tok);
 static Node *new_add(Node *lhs, Node *rhs, Token *tok);
 static Node *new_sub(Node *lhs, Node *rhs, Token *tok);
@@ -2412,9 +2413,8 @@ write_gvar_data(Relocation *cur, Initializer *init, char *buf, int offset, EvalK
     }
 
     if (init->ty->kind == TY_BITINT) {
-      uint64_t *data = eval_bitint(node);
-      if (init->ty->bit_cnt < init->ty->size * 8)
-        eval_bitint_sign_ext(init->ty->bit_cnt, data, init->ty->size * 8, init->ty->is_unsigned);
+      uint64_t *data = eval_bitint_clean(node);
+
       memcpy(buf + offset, data, init->ty->size);
       free(data);
       return cur;
@@ -3538,6 +3538,23 @@ bool is_const_fp(Node *node, FPVal *fval) {
   return !failed;
 }
 
+bool is_const_zero_bitint(Node *node) {
+  bool failed = false;
+  bool *prev = eval_recover;
+  eval_recover = &failed;
+
+  char *data = (char *)eval_bitint_clean(node);
+
+  eval_recover = prev;
+  if (failed)
+    return false;
+
+  for (int i = 0; i < node->ty->size; i++)
+    if (data[i] != 0)
+      return false;
+  return true;
+}
+
 static int64_t const_expr2(Token **rest, Token *tok, Type **ty) {
   Node *node = conditional(rest, tok);
   add_type(node);
@@ -3777,6 +3794,15 @@ static uint64_t *eval_bitint(Node *node) {
   return (void *)eval_error(node);
 }
 
+static uint64_t *eval_bitint_clean(Node *node) {
+  uint64_t *data = eval_bitint(node);
+
+  Type *ty = node->ty;
+  if (ty->bit_cnt < ty->size * 8)
+    eval_bitint_sign_ext(ty->bit_cnt, data, ty->size * 8, ty->is_unsigned);
+  return data;
+}
+
 static Node *atomic_op(Node *binary, bool return_old) {
   // ({
   //   T *addr = &obj; T old = *addr; T new;

slimcc.h

@@ -95,6 +95,7 @@ typedef struct Member Member;
 typedef struct Relocation Relocation;
 typedef struct LocalLabel LocalLabel;
 typedef struct EnumVal EnumVal;
+typedef union FPVal FPVal;
 typedef struct AsmContext AsmContext;
 typedef struct FuncObj FuncObj;
 
@@ -647,6 +648,10 @@ Obj *parse(Token *tok);
 Token *skip_paren(Token *tok);
 Obj *new_lvar(Type *ty);
 bool is_const_var(Obj *var);
+bool is_const_expr(Node *node, int64_t *val);
+bool is_const_fp(Node *node, FPVal *fval);
+bool is_const_zero_bitint(Node *node);
+Obj *eval_var_opt(Node *node, int *ofs, bool let_array, bool let_atomic);
 bool equal_tok(Token *a, Token *b);
 char *new_unique_name(void);
 Obj *get_symbol_var(char *);
@@ -695,13 +700,13 @@ struct EnumVal {
   int64_t val;
 };
 
-typedef union {
+union FPVal {
   uint64_t chunk[2];
   uint32_t chunk32[4];
   long_double_t ld;
   double d;
   float f;
-} FPVal;
+};
 
 typedef enum {
   TY_VOID,
@@ -845,8 +850,6 @@ bool is_redundant_cast(Node *expr, Type *ty);
 bool is_compatible(Type *t1, Type *t2);
 bool is_compatible2(Type *t1, Type *t2);
 bool is_record_compat(Type *t1, Type *t2);
-bool is_const_expr(Node *node, int64_t *val);
-bool is_const_fp(Node *node, FPVal *fval);
 bool is_nullptr(Node *node);
 bool is_ptr(Type *ty);
 int next_pow_of_two(int val);
@@ -870,7 +873,6 @@ Type *new_derived_type(Type *newty, QualMask qual, Type *ty, Token *tok);
 Type *aligned_type(int align, Type *ty);
 Type *qual_type(QualMask msk, Type *ty, Token *tok);
 void cvqual_type(Type **ty_p, Type *ty2);
-Obj *eval_var_opt(Node *node, int *ofs, bool let_array, bool let_atomic);
 bool mem_iter(Member **mem);
 Node *assign_cast(Type *to, Node *expr);
 

type.c

@@ -291,11 +291,11 @@ static void cast_if_not(Type *ty, Node **node) {
 }
 
 static bool int_to_ptr(Node **node) {
-  if (!is_integer((*node)->ty))
-    return false;
-  if ((*node)->ty->size != ty_nullptr->size)
+  if (is_integer((*node)->ty) || (*node)->ty->kind == TY_BITINT) {
     *node = new_cast(*node, pointer_to(ty_void));
-  return true;
+    return true;
+  }
+  return false;
 }
 
 static bool match_enum_val(EnumVal **e, int64_t val, Token *name) {
@@ -584,6 +584,9 @@ bool is_nullptr(Node *node) {
     node->ty->kind == TY_PTR && is_compatible2(node->ty->base, ty_void))
     node = node->m.lhs;
 
+  if (node->ty->kind == TY_BITINT)
+    return is_const_zero_bitint(node);
+
   int64_t val;
   return is_integer(node->ty) && is_const_expr(node, &val) && val == 0;
 }
@@ -643,10 +646,14 @@ static Type *cond_ptr_conv(Node **lhs, Node **rhs, Node **cond) {
   Type *ty1 = (*lhs)->ty;
   Type *ty2 = (*rhs)->ty;
 
-  if (ty1->kind == TY_PTR && (int_to_ptr(rhs) || is_nullptr(*rhs)))
+  if (ty1->kind == TY_NULLPTR && ty2->kind == TY_NULLPTR)
+    return ty_nullptr;
+
+  if (ty1->kind == TY_PTR && is_ptr(ty2) && is_nullptr(*rhs))
     return ty1;
-  if (ty2->kind == TY_PTR && (int_to_ptr(lhs) || is_nullptr(*lhs)))
+  if (ty2->kind == TY_PTR && is_ptr(ty1) && is_nullptr(*lhs))
     return ty2;
+
   if (ty1->kind == TY_PTR && ty2->kind == TY_PTR) {
     if (ty1->base->kind == TY_VOID || ty2->base->kind == TY_VOID)
       return pointer_to(qual_type(ty1->base->qual | ty2->base->qual, ty_void, NULL));
@@ -656,10 +663,13 @@ static Type *cond_ptr_conv(Node **lhs, Node **rhs, Node **cond) {
 
     return pointer_to(ty_void);
   }
-  if (ty1->kind == TY_NULLPTR && ty2->kind == TY_NULLPTR)
-    return ty_nullptr;
 
-  internal_error();
+  if (ty1->kind == TY_PTR && int_to_ptr(rhs))
+    return ty1;
+  if (ty2->kind == TY_PTR && int_to_ptr(lhs))
+    return ty2;
+
+  error_tok((*cond)->tok, "invalid operand");
 }
 
 static void add_int_type(Node *node) {
@@ -785,8 +795,9 @@ void add_type(Node *node) {
     node->ty = ty_int;
     ptr_convert(&node->m.lhs);
     ptr_convert(&node->m.rhs);
-    if ((is_ptr(node->m.lhs->ty) && (is_ptr(node->m.rhs->ty) || int_to_ptr(&node->m.rhs))) ||
-      (is_ptr(node->m.rhs->ty) && (is_ptr(node->m.lhs->ty) || int_to_ptr(&node->m.lhs))))
+    if ((is_ptr(node->m.lhs->ty) && is_ptr(node->m.rhs->ty)) ||
+      (is_ptr(node->m.lhs->ty) && int_to_ptr(&node->m.rhs)) ||
+      (is_ptr(node->m.rhs->ty) && int_to_ptr(&node->m.lhs)))
       return;
     usual_arith_conv(&node->m.lhs, &node->m.rhs);
     return;