11506 smatch resync

@@ -27,10 +27,12 @@
 {
         struct symbol *ret;
 
         if (!sym)
                 return NULL;
+        if (sym->type == SYM_BASETYPE)
+                return sym;
         ret = get_base_type(sym);
         if (!ret)
                 return NULL;
         if (ret->type == SYM_RESTRICT || ret->type == SYM_NODE)
                 return get_real_base_type(ret);

@@ -73,10 +75,14 @@
         }
         right = get_type(expr->right);
         if (!right)
                 return NULL;
 
+        if (expr->op == '-' &&
+            (is_ptr_type(left) && is_ptr_type(right)))
+                return ssize_t_ctype;
+
         if (left->type == SYM_PTR || left->type == SYM_ARRAY)
                 return left;
         if (right->type == SYM_PTR || right->type == SYM_ARRAY)
                 return right;
 

@@ -267,10 +273,13 @@
                 ret = &ulong_ctype;
                 break;
         case EXPR_LOGICAL:
                 ret = &int_ctype;
                 break;
+        case EXPR_OFFSETOF:
+                ret = &ulong_ctype;
+                break;
         default:
                 return NULL;
         }
 
         if (ret && ret->type == SYM_TYPEOF)

@@ -281,44 +290,25 @@
 }
 
 static struct symbol *get_final_type_helper(struct expression *expr)
 {
         /*
-         * I'm not totally positive I understand types...
+         * The problem is that I wrote a bunch of Smatch to think that
+         * you could do get_type() on an expression and it would give
+         * you what the comparison was type promoted to.  This is wrong
+         * but fixing it is a big of work...  Hence this horrible hack.
          *
-         * So, when you're doing pointer math, and you do a subtraction, then
-         * the sval_binop() and whatever need to know the type of the pointer
-         * so they can figure out the alignment.  But the result is going to be
-         * and ssize_t.  So get_operation_type() gives you the pointer type
-         * and get_type() gives you ssize_t.
-         *
-         * Most of the time the operation type and the final type are the same
-         * but this just handles the few places where they are different.
-         *
          */
 
         expr = strip_parens(expr);
         if (!expr)
                 return NULL;
 
-        switch (expr->type) {
-        case EXPR_COMPARE:
+        if (expr->type == EXPR_COMPARE)
                 return &int_ctype;
-        case EXPR_BINOP: {
-                struct symbol *left, *right;
 
-                if (expr->op != '-')
                         return NULL;
-
-                left = get_type(expr->left);
-                right = get_type(expr->right);
-                if (type_is_ptr(left) || type_is_ptr(right))
-                        return ssize_t_ctype;
-                }
-        }
-
-        return NULL;
 }
 
 struct symbol *get_type(struct expression *expr)
 {
         return get_type_helper(expr);

@@ -395,20 +385,11 @@
         return type_unsigned(sym);
 }
 
 int is_pointer(struct expression *expr)
 {
-        struct symbol *sym;
-
-        sym = get_type(expr);
-        if (!sym)
-                return 0;
-        if (sym == &string_ctype)
-                return 0;
-        if (sym->type == SYM_PTR)
-                return 1;
-        return 0;
+        return type_is_ptr(get_type(expr));
 }
 
 int returns_pointer(struct symbol *sym)
 {
         if (!sym)

@@ -440,11 +421,11 @@
 
         if (!base_type || !type_bits(base_type))
                 base_type = &llong_ctype;
         ret.type = base_type;
 
-        if (type_unsigned(base_type)) {
+        if (type_unsigned(base_type) || is_ptr_type(base_type)) {
                 ret.value = 0;
                 return ret;
         }
 
         ret.value = (~0ULL) << type_positive_bits(base_type);

@@ -602,11 +583,11 @@
         struct symbol *tmp, *sub;
         int chunk_len;
 
         if (strncmp(name, ".", 1) == 0)
                 name += 1;
-        if (strncmp(name, "->", 2) == 0)
+        else if (strncmp(name, "->", 2) == 0)
                 name += 2;
 
         FOR_EACH_PTR(symbol_list, tmp) {
                 if (!tmp->ident) {
                         sub = get_real_base_type(tmp);

@@ -617,14 +598,16 @@
                 }
 
                 if (strcmp(tmp->ident->name, name) == 0)
                         return tmp;
 
-                chunk_len = strlen(tmp->ident->name);
+                chunk_len = tmp->ident->len;
                 if (strncmp(tmp->ident->name, name, chunk_len) == 0 &&
                     (name[chunk_len] == '.' || name[chunk_len] == '-')) {
                         sub = get_real_base_type(tmp);
+                        if (sub->type == SYM_PTR)
+                                sub = get_real_base_type(sub);
                         return get_member_from_string(sub->symbol_list, name + chunk_len);
                 }
 
         } END_FOR_EACH_PTR(tmp);
 

@@ -739,11 +722,11 @@
 
         if (!type)
                 return snprintf(buf, size, "<unknown>");
 
         if (type->type == SYM_BASETYPE) {
-                return snprintf(buf, size, base_type_str(type));
+                return snprintf(buf, size, "%s", base_type_str(type));
         } else if (type->type == SYM_PTR) {
                 type = get_real_base_type(type);
                 n = type_str_helper(buf, size, type);
                 if (n > size)
                         return n;

@@ -793,10 +776,12 @@
                 type = get_real_base_type(type);
                 n += type_str_helper(buf + n, size - n, type);
                 if (n > size)
                         return n;
                 return n + snprintf(buf + n, size - n, "}");
+        } else if (type->type == SYM_ENUM) {
+                return snprintf(buf, size, "enum %s", type->ident ? type->ident->name : "<unknown>");
         } else {
                 return snprintf(buf, size, "<type %d>", type->type);
         }
 }