adlint 1.0.0

data/share/demo/may_be_null_arith/may_be_null_arith.c

@@ -0,0 +1,15 @@
+int main(void)
+{
+    int c;
+    int *p = NULL;
+
+    if (rand() == 1) {
+        p = &c;
+    }
+
+    *p = 0;
+    p = p + 1;
+    *p = 2;
+
+    return 0;
+}

data/share/demo/may_be_unset/may_be_unset.c

@@ -0,0 +1,34 @@
+static int j;
+
+int func(int *p)
+{
+    int i;
+    int k;
+
+    if (p != NULL && *p < 0) {
+        i = *p;
+    }
+
+    if (NULL != p && *p > 5) {
+        i = *p;
+    }
+
+    if (p == NULL && *p == 0) {
+        i = 0;
+    }
+
+    if (p && *p == rand()) {
+        i = *p;
+    }
+
+    {
+        struct Foo { int val; } *p = may_return_null();
+        if (p && p->val == 0) {
+            p->val = 1;
+        }
+    }
+
+    k = j;
+
+    return i * k;
+}

data/share/demo/mmapped_io/mmapped_io.c

@@ -0,0 +1,23 @@
+extern volatile unsigned char *vptr;
+extern unsigned char *ptr;
+
+int main(void)
+{
+    unsigned short us;
+    unsigned long ul;
+    unsigned char *puc;
+
+    vptr = (volatile unsigned char *) 0x1111U;
+    ptr = (unsigned char *) 0x1111U;
+
+    us = (unsigned short) vptr;
+    ul = (unsigned long) vptr;
+    us = (unsigned short) ptr;
+    ul = (unsigned long) ptr;
+
+    puc = (unsigned char *) 0x1111U;
+    us = (unsigned short) puc;
+    ul = (unsigned long) puc;
+
+    return 0;
+}

data/share/demo/multi_break/multi_break.c

@@ -0,0 +1,33 @@
+int main(void)
+{
+    for (int i = 0; i < 10; i++) {
+        if (i == 1) {
+            break;
+        }
+        switch (i) {
+        case 5:
+            break;
+        default:
+            break;
+        }
+        if (i == 6) {
+            break;
+        }
+    }
+
+    while (1) {
+        if (rand() == 1) {
+            break;
+        }
+        do {
+            if (rand() == 2) {
+                break;
+            }
+        } while (1);
+        if (rand() == 3) {
+            break;
+        }
+    }
+
+    return 0;
+}

data/share/demo/multi_decl/multi_decl_1.c

@@ -0,0 +1,17 @@
+#include "multi_decl_1.h"
+
+int g1;
+struct Point g2;
+
+int foo(void)
+{
+    return 0;
+}
+
+struct Point *bar(int i)
+{
+    static struct Point p;
+    p.x = i;
+    p.y = i * 2;
+    return &p;
+}

data/share/demo/multi_decl/multi_decl_1.h

@@ -0,0 +1,6 @@
+extern int g1;
+extern struct Point { int x, y; } g2;
+
+extern int foo(void);
+extern struct Point *bar(int);
+extern int baz(void);

data/share/demo/multi_decl/multi_decl_2.c

@@ -0,0 +1,13 @@
+#include "multi_decl_2.h"
+
+extern int g1;
+extern struct Point { int x, y; } g2;
+
+extern int foo(void);
+extern struct Point *bar(int);
+extern int baz(void);
+
+static int baz(void)
+{
+    return foo() + bar(0)->x;
+}

data/share/demo/multi_decl/multi_decl_2.h

@@ -0,0 +1,6 @@
+extern int g1;
+extern struct Point { int x, y; } g2;
+
+extern int foo(void);
+extern struct Point *bar(int);
+extern int baz(void);

data/share/demo/multi_decl/multi_decl_3.c

@@ -0,0 +1,22 @@
+#include "multi_decl_1.h"
+#include "multi_decl_2.h"
+
+extern int Hoge;
+
+struct Hoge {
+    int i;
+    int HogeHoge;
+};
+
+typedef struct HogeHoge {
+    int Hoge;
+    int HogeHoge;
+} HogeHoge;
+
+static int Hoge;
+
+int main(void)
+{
+Hoge:
+    return baz();
+}

data/share/demo/multi_def/multi_def_1.c

@@ -0,0 +1,36 @@
+#include "multi_def_1.h"
+
+int g1;
+struct Point g2;
+
+int foo(void)
+{
+    return 0;
+}
+
+struct Point *bar(int i)
+{
+    static struct Point p;
+    p.x = i;
+    p.y = i + 1;
+    return &p;
+}
+
+int baz(void)
+{
+    return foo();
+}
+
+int g1 = 0;
+
+int foo(void)
+{
+    return 1;
+}
+
+int foo = 1;
+
+int g1(void)
+{
+    return 0;
+}

data/share/demo/multi_def/multi_def_1.h

@@ -0,0 +1,6 @@
+extern int g1;
+extern struct Point { int x, y; } g2;
+
+extern int foo(void);
+extern struct Point *bar(int);
+extern int baz(void);

data/share/demo/multi_def/multi_def_2.c

@@ -0,0 +1,22 @@
+#include "multi_def_2.h"
+
+int g1;
+struct Point g2;
+
+int foo(void)
+{
+    return 0;
+}
+
+struct Point *bar(int i)
+{
+    static struct Point p;
+    p.x = i;
+    p.y = i + 1;
+    return &p;
+}
+
+int baz(void)
+{
+    return foo();
+}

data/share/demo/multi_def/multi_def_2.h

@@ -0,0 +1,6 @@
+extern int g1;
+extern struct Point { int x, y; } g2;
+
+extern int foo(void);
+extern struct Point *bar(int);
+extern int baz(void);

data/share/demo/multi_def/multi_def_3.c

@@ -0,0 +1,6 @@
+#include "multi_def_1.h"
+
+int main(void)
+{
+    return bar(g1)->y;
+}

data/share/demo/multi_typedef/multi_typedef.c

@@ -0,0 +1,11 @@
+#include "multi_typedef_1.h"
+
+typedef struct { int x, y; } Point;
+
+#include "multi_typedef_2.h"
+
+int main(void)
+{
+    Point p = { 1, 2 };
+    return p.x;
+}

data/share/demo/multi_typedef/multi_typedef_1.h

@@ -0,0 +1 @@
+typedef struct { int x, y, z; } Point;

data/share/demo/multi_typedef/multi_typedef_2.h

@@ -0,0 +1 @@
+typedef struct { int r, g, b; } Point;

data/share/demo/must_be_false/must_be_false.c

@@ -0,0 +1,53 @@
+int main(void)
+{
+    const int i = rand();
+    const unsigned short us = (unsigned short) rand();
+
+    if (i < 0) {
+        if (i > us) {
+            return 0;
+        }
+    }
+    else {
+        for (int j = -1; j > i; j++) {
+            puts("hoge\n");
+        }
+        while (i == -5) {
+            return 1;
+        }
+        do {
+            puts("hoge\n");
+        } while (i == -10);
+    }
+
+#define A (1)
+#define B (1)
+
+    if (A - B) {
+        puts("hoge\n");
+    }
+
+    if (A - B) {
+        puts("hoge\n");
+    }
+    else {
+        puts("hoge\n");
+    }
+
+    while (A - B) {
+        puts("hoge\n");
+    }
+
+    {
+        int k;
+        for (k = 0; A - B; k++) {
+            puts("hoge\n");
+        }
+    }
+
+    for (int k = 0; A - B; k++) {
+        puts("hoge\n");
+    }
+
+    return 0;
+}

data/share/demo/must_be_null/must_be_null.c

@@ -0,0 +1,13 @@
+int main(void)
+{
+    int *p = may_return_null();
+
+    if (p) {
+        *p = 1;
+    }
+    else {
+        *p = 2;
+    }
+
+    return 0;
+}

data/share/demo/must_be_null_arith/must_be_null_arith.c

@@ -0,0 +1,14 @@
+int main(void)
+{
+    int *p = may_return_null();
+
+    if (p) {
+        *p = 1;
+    }
+    else {
+        p = p + 1;
+        *p = 0;
+    }
+
+    return 0;
+}

data/share/demo/must_be_true/must_be_true.c

@@ -0,0 +1,21 @@
+int main(void)
+{
+    const int i = rand();
+    const unsigned short us = (unsigned short) rand();
+
+    if (i < 0) {
+        if (i < us) {
+            return 0;
+        }
+    }
+    else {
+        for (int j = 0; j < i; j++) {
+            puts("hoge\n");
+        }
+        while (i != -5) {
+            return 1;
+        }
+    }
+
+    return 0;
+}

data/share/demo/no_eof_nl/no_eof_nl.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+    return 0;
+}

data/share/demo/no_void_arg/no_void_arg.c

@@ -0,0 +1,14 @@
+int foo()
+{
+    return 0;
+}
+
+int (*bar())()
+{
+    return 0;
+}
+
+int baz(int (*p)())
+{
+    return p(0);
+}

data/share/demo/null_stmt/null_stmt.c

@@ -0,0 +1,19 @@
+static int foo(const int n)
+{
+    int i;
+    int j = 0;
+
+    for (i = 0; i < n; i++);
+    {
+        j += n;
+    }
+
+    return j;
+}
+
+static int bar(const int n)
+{
+    int i = n;
+
+    return i++;;
+}

data/share/demo/octal_const/octal_const.c

@@ -0,0 +1,20 @@
+#define ZERO_1 0
+#define ZERO_2 (0)
+
+#define OCTAL_1 0160
+#define OCTAL_2 (0160)
+
+int i1 = 0;
+int i2 = (0);
+int i3 = ZERO_1;
+int i4 = ZERO_2;
+int i5 = 0160;
+int i6 = (0160);
+int i7 = OCTAL_1;
+int i8 = OCTAL_2;
+
+char c1 = 'a';
+char c2 = '\012';
+
+char *p1 = "foo";
+char *p2 = "fo\012o";

data/share/demo/output_by_param/output_by_param.c

@@ -0,0 +1,17 @@
+void foo(int *p, char *buf)
+{
+    if (p && buf) {
+        *p = 0;
+        buf[0] = 0;
+    }
+}
+
+int bar(void)
+{
+    int i = 0;
+    char buf[100] = { 0 };
+
+    foo(&i, buf);
+
+    return buf[i];
+}

data/share/demo/overflow/overflow.c

@@ -0,0 +1,74 @@
+extern long foo(void);
+extern unsigned long bar(void);
+
+static void baz(void)
+{
+    const int i = rand();
+
+    if (i > 127) {
+        const signed char c = (signed char) i;
+    }
+    /* __adlint__inspect(i); // 2 -> 1 */
+    if (i < -128) {
+        const signed char c = (signed char) i;
+    }
+    /* __adlint__inspect(i); // 4 -> 1 */
+
+    if (i > 100) {
+        const signed char c = (signed char) i;
+    }
+    /* __adlint__inspect(i); // 5 -> 1 */
+    if (i < -100) {
+        const signed char c = (signed char) i;
+    }
+    /* __adlint__inspect(i); // 5 -> 1 */
+
+    if (i > -129 && i < 128) {
+        const signed char c = (signed char) i;
+    }
+}
+
+int main(void)
+{
+    const long l = foo();
+    const unsigned long ul = bar();
+    long r;
+
+    r = 0x1FFFFFFFL << 1;
+    r = 0x1FFFFFFFL << 2;
+    r = 0x1FFFFFFFL << 3;
+    r = 0x1FFFFFFFL << 4;
+
+    if (l >= 0x1FFFFFFFL) {
+        r = l << 1;
+        r = l << 2;
+        r = l << 3;
+        r = l << 4;
+    }
+
+    if (l < 500) {
+        r = l << 1;
+        r = l << 2;
+    }
+
+    if ((l > 0) && (l < 500)) {
+        r = l << 1;
+        r = l << 2;
+    }
+
+    r = l << 1;
+
+    if (ul < 500) {
+        r = ul << 1;
+        r = ul << 2;
+    }
+
+    if (ul <= 0x1FFFFFFFUL) {
+        r = ul << 1;
+        r = ul << 2;
+        r = ul << 3;
+        r = ul << 4;
+    }
+
+    return 0;
+}

data/share/demo/press_release/press_release.c

@@ -0,0 +1,40 @@
+#include <math.h>
+#include <stdlib.h>
+
+static int CalledRecursively(void);
+
+static int Function(void)
+{
+    return CalledRecursively();
+}
+
+static void OutputByParam(int **param)
+{
+    int result = Function() + rand();
+    *param = &result;
+}
+
+static int CalledRecursively(void)
+{
+    int *result;
+    OutputByParam(&result);
+    return *result;
+}
+
+int main(int argc, char *argv[])
+{
+    int i;
+    int *ptr = NULL;
+
+    if (argc < 2) {
+        return *ptr;
+    }
+
+    if (rand() == 1) {
+        ptr = &i;
+        *ptr = CalledRecursively();
+    }
+    *ptr = 2;
+
+    return 0;
+}

data/share/demo/retn_lvar_addr/retn_lvar_addr.c

@@ -0,0 +1,47 @@
+int *foo(int i)
+{
+    int n = i;
+    return &n;
+}
+
+int *bar(int i)
+{
+    static int n;
+    return &n;
+}
+
+void baz(int **pp)
+{
+    int i = 0;
+    *pp = &i;
+}
+
+void qux(void)
+{
+    int *p;
+    {
+        int i;
+        p = &i;
+    }
+}
+
+int *gpi;
+char *gpc;
+
+void hoge(long ** p)
+{
+    int i = 0;
+    static const char s[] = "aaa";
+    static const long l = 1;
+
+    gpi = &i;
+    gpc = s;
+    gpc = &s[0];
+    *p = &l;
+}
+
+void hogehoge(int i)
+{
+    static int *p;
+    p = &i;
+}

data/share/demo/shift_expr/shift_expr.c

@@ -0,0 +1,14 @@
+int main(void)
+{
+    const int i = -1;
+    int j;
+    const unsigned int ui = 1;
+
+    j = i >> 3;
+    j = (int) (ui >> 3);
+
+    j = i << 3;
+    j = (int) (ui << 3);
+
+    return 0;
+}

data/share/demo/should_be_typedef/should_be_typedef.c

@@ -0,0 +1,51 @@
+#define OM_1 int
+
+#define OM_2 unsigned int
+
+#define OM_3 int *
+
+#define OM_4 const int *
+
+#define OM_5 int **
+
+#define OM_6 volatile int * const
+
+#define OM_7 void
+
+#define OM_8 static const
+
+#define OM_9 static volatile
+
+#define OM_10 static const volatile
+
+#define OM_11 extern const
+
+#define OM_12 volatile extern
+
+#define OM_13 const volatile
+
+#define FM_1(x) int
+
+#define FM_2(x) unsigned int
+
+#define FM_3(x) int *
+
+#define FM_4(x) const int *
+
+#define FM_5(x) int **
+
+#define FM_6(x) volatile int * const
+
+#define FM_7(x) void
+
+#define FM_8(x) static const
+
+#define FM_9(x) static volatile
+
+#define FM_10(x) static const volatile
+
+#define FM_11(x) extern const
+
+#define FM_12(x) volatile extern
+
+#define FM_13(x) const volatile