Subversion Repositories openrisc_me

x.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: fdmul.c =================================================================== --- fdmul.c (nonexistent) +++ fdmul.c (revision 154) @@ -0,0 +1,2 @@ +double +foo (float a, float b) { return (double) a * (double) b; }

fdmul.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: PYRBUG.c =================================================================== --- PYRBUG.c (nonexistent) +++ PYRBUG.c (revision 154) @@ -0,0 +1,17 @@ +typedef struct +{ + int v; + int h; +} Point; + +typedef struct +{ + int top, left, bottom, right; +} Rect; + +int +x_PtInRect (Point pt, Rect *r) +{ + return pt.v >= r->top && pt.v < r->bottom + && pt.h >= r->left && pt.h < r->right; +}

PYRBUG.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xmtst.c =================================================================== --- xmtst.c (nonexistent) +++ xmtst.c (revision 154) @@ -0,0 +1,26 @@ +p1 (int b, int *p, int a) +{ + p[0] = p[1]; + return p[0]; +} +p2 (int b, int *p, int a) +{ + p[0] = p[1]; + return p[0] == 0; +} +p3 (int b, int *p, int a) +{ + p[0] = p[1]; + a = p[0]; + if (a) + return 0; + return a; +} +p4 (int b, int *p, int a) +{ + a = p[1]; + p[0] = p[1]; + if (a) + return 0; + return a; +}

xmtst.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bfx.c =================================================================== --- bfx.c (nonexistent) +++ bfx.c (revision 154) @@ -0,0 +1,9 @@ +foo (x, c) +{ + return x << -c; +} + +main () +{ + printf ("%x\n", foo (0xf05, -4)); +}

bfx.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: flo.c =================================================================== --- flo.c (nonexistent) +++ flo.c (revision 154) @@ -0,0 +1,7 @@ +foo (a) + double a; +{ + double b = 0.0; + + return (a == 0); +}

flo.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG13.c =================================================================== --- BUG13.c (nonexistent) +++ BUG13.c (revision 154) @@ -0,0 +1,19 @@ +struct tree_common +{ + int uid; + unsigned int code : 8; + unsigned int code2 : 8; + unsigned external_attr : 1; + unsigned public_attr : 1; + +}; + +static int +duplicate_decls (x) + register struct tree_common *x; +{ + if (x->external_attr) + if (x->code) + if (x->code2) + x->public_attr = 1; +}

BUG13.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: UHIcmp.c =================================================================== --- UHIcmp.c (nonexistent) +++ UHIcmp.c (revision 154) @@ -0,0 +1,280 @@ +#define type unsigned short + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} +

UHIcmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xorn.c =================================================================== --- xorn.c (nonexistent) +++ xorn.c (revision 154) @@ -0,0 +1,31 @@ +int +xorn (a, b) + int a, b; +{ + return a ^ ~b; +} + +int +not (a) + int a; +{ + return ~a; +} + +int +xor (a, b) + int a, b; +{ + return a ^ b; +} + +main () +{ + int i, j; + + for (i = 0; i <= 1; i++) + for (j = 0; j <= 1; j++) + printf ("%d op %d = %d = %d?\n", i, j, + 1 & xor (i, not (j)), + 1 & xorn (i, j)); +}

xorn.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mdouble.c =================================================================== --- mdouble.c (nonexistent) +++ mdouble.c (revision 154) @@ -0,0 +1,6 @@ +double +foo (double a) +{ + + return 1.123486712; +}

mdouble.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sound.c =================================================================== --- sound.c (nonexistent) +++ sound.c (revision 154) @@ -0,0 +1,13 @@ + +main () +{ + char audio[8192]; + int i; + + for (i = 0; i < 4095; i += 1) + audio[i] = i / 8, + audio[8191 - i] = i / 8; + + for (;;) + write (1, audio, 8192); +}

sound.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mchar.c =================================================================== --- mchar.c (nonexistent) +++ mchar.c (revision 154) @@ -0,0 +1,11 @@ +int +foo (char *a, char *b) +{ + int x; + *a = *b; + x = *b; + if ((char) x) + return 1; + else + return 0; +}

mchar.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: di.c =================================================================== --- di.c (nonexistent) +++ di.c (revision 154) @@ -0,0 +1,12 @@ +long long +foo (a, b) + long long a, b; +{ + return a * b; +} + +main () +{ + int a = foo ((long long) 2, (long long) 3); + printf ("%d\n", a); +}

di.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bt.c =================================================================== --- bt.c (nonexistent) +++ bt.c (revision 154) @@ -0,0 +1,7 @@ +main () +{ + int i; + + for (i = 1000000; --i;) + ; +}

bt.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: scc.c =================================================================== --- scc.c (nonexistent) +++ scc.c (revision 154) @@ -0,0 +1,11 @@ +foo (a, b) +{ + if (a < 0) + goto ret1; + if (a == 0) + return 2; + return 3; + ret1: + return 1; +} +

scc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: QIcmp.c =================================================================== --- QIcmp.c (nonexistent) +++ QIcmp.c (revision 154) @@ -0,0 +1,280 @@ +#define type signed char + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} +

QIcmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xc.c =================================================================== --- xc.c (nonexistent) +++ xc.c (revision 154) @@ -0,0 +1,11 @@ +foo (a, p) + int *p; +{ + int b; + + a++; + b = *p; + if (a) + return 1; + return b; +}

xc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dump-noaddr.c =================================================================== --- dump-noaddr.c (nonexistent) +++ dump-noaddr.c (revision 154) @@ -0,0 +1,48 @@ +#if MASK & 1 +#define t16(x) x x x x x x x x x x x x x x x x +#define M (sizeof (t16(t16(t16(t16(t16(" ")))))) - 1) +#endif +#if MASK & 2 +#define M 1048576 +#endif + +typedef struct s { + int c; + void *vp; + struct s *s; +}s; + +typedef int (*fpt) (const char *, void *, int *); + +int M_var = M; + +extern void exit (int); + +int +f (int start, int end, int *a, int *b, int c, s *sp) +{ + int count = 0; + int i; + + for (i = start; i <= end; i++) + { + a[i] = b[i] + c; + count ++; + } + (*(fpt)sp->s->vp) ("Hello World!\n", &exit, &M_var); + return count; +} + +int +g (int i) +{ + switch (i) + { + case 1: return 42; + case 2: return 60; + case 3: return 7; + case 4: return 3; + case 5: return M; + default: return 0; + } +}

dump-noaddr.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: call386.c =================================================================== --- call386.c (nonexistent) +++ call386.c (revision 154) @@ -0,0 +1,20 @@ +void foo () {} + +int main () +{ + int i; + for (i = 100000; i >= 0; i--) + { + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + } + return 0; +}

call386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bit.c =================================================================== --- bit.c (nonexistent) +++ bit.c (revision 154) @@ -0,0 +1,13 @@ +bar (a) +{ + return (a == 0); +} + +foo (a) + int a; +{ + if ((a & (1 << 26)) >= 0) + return 1; + else + return 2; +}

bit.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: a.c =================================================================== --- a.c (nonexistent) +++ a.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return a & 65535; +}

a.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: 386.c =================================================================== --- 386.c (nonexistent) +++ 386.c (revision 154) @@ -0,0 +1,23 @@ +foo (a, p) + int *p; +{ + p[0] = a; + a = (short) a; + return a; +} + +main () +{ + int i; + foobar (i, &i); +} + + +foobar (a, b) +{ + int c; + + c = a % b; + a = a / b; + return a + b; +}

386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG22.c =================================================================== --- BUG22.c (nonexistent) +++ BUG22.c (revision 154) @@ -0,0 +1,6 @@ + +void +Rotate (float angle) +{ + float mag = (angle < 0) ? -angle : angle; +}

BUG22.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: selfrec.c =================================================================== --- selfrec.c (nonexistent) +++ selfrec.c (revision 154) @@ -0,0 +1,5 @@ +int +foo (a) +{ + return foo (a - 1) * a; +}

selfrec.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cc.c =================================================================== --- cc.c (nonexistent) +++ cc.c (revision 154) @@ -0,0 +1,96 @@ +cc8 (a, b) +{ + if (a < 0) + goto L1; + if (a == 0) + goto L2; + L1:b++; + L2:b++; + return b; +} + +cc7 (a) + long long a; +{ + if (a < 0) + return 1; + else + return 0; +} + +cc6 (float a, double p) +{ + p = a; + if (p < 0) + return p; + else + return p + 1; +} + +cc5 (p, a) + char *p; + char a; +{ + p[2] = a; + if (a) + return 0; + else + return 1; +} + + +cc4 (a, b, p) + int a, b; + int *p; +{ + a = (int short)b; + *p = a; + if ((int) a < 0) + return 0; + else + return 1; +} + + +cc1 (a, b) +{ + int x = 0; + + if ((int) a < (int) b) + { + if ((unsigned) a < (unsigned) b) + x++; + x++; + } + + return x; +} + +cc2 (a, b) +{ + int x = 0; + + if ((int) a <= (int) b) + { + if ((int) a < (int) b) + x++; + x++; + } + + return x; +} + +cc3 (a, b) +{ + int x = 0; + + a += b; + if ((unsigned) a > 0) + { + if (a == 0) + x++; + x++; + } + + return x; +}

cc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: QIset.c =================================================================== --- QIset.c (nonexistent) +++ QIset.c (revision 154) @@ -0,0 +1,216 @@ +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type char + +reg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = reg1; } + +reg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = indreg1; } + +reg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = imm1; } + +reg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = limm1; } + +reg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adr1; } + +reg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrreg1; } + +reg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrx1; } + +reg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = regx1; } + +indreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = reg1; } + +indreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = indreg1; } + +indreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = imm1; } + +indreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = limm1; } + +indreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adr1; } + +indreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrreg1; } + +indreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrx1; } + +indreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = regx1; } + +adr0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = reg1; } + +adr0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = indreg1; } + +adr0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = imm1; } + +adr0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = limm1; } + +adr0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adr1; } + +adr0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrreg1; } + +adr0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrx1; } + +adr0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = regx1; } + +adrreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = reg1; } + +adrreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = indreg1; } + +adrreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = imm1; } + +adrreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = limm1; } + +adrreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adr1; } + +adrreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrreg1; } + +adrreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrx1; } + +adrreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = regx1; } + +adrx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = reg1; } + +adrx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = indreg1; } + +adrx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = imm1; } + +adrx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = limm1; } + +adrx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adr1; } + +adrx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrreg1; } + +adrx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrx1; } + +adrx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = regx1; } + +regx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = reg1; } + +regx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = indreg1; } + +regx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = imm1; } + +regx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = limm1; } + +regx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adr1; } + +regx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrreg1; } + +regx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrx1; } + +regx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = regx1; } +

QIset.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: i.c =================================================================== --- i.c (nonexistent) +++ i.c (revision 154) @@ -0,0 +1,8 @@ +ase (p) + short *p; +{ + int a; + + a = *p; + *p = a + 1; +}

i.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xs.c =================================================================== --- xs.c (nonexistent) +++ xs.c (revision 154) @@ -0,0 +1,9 @@ +foo (a, b) +{ + for (b = 0; b < 10; b++) + ; + for (a = 0; a < 10; a++) + ; + a = b << 1; + return a; +}

xs.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: flt_const.c =================================================================== --- flt_const.c (nonexistent) +++ flt_const.c (revision 154) @@ -0,0 +1,5 @@ +double +foo () +{ + return 3.141592653589793238462643; +}

flt_const.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: divdf.c =================================================================== --- divdf.c (nonexistent) +++ divdf.c (revision 154) @@ -0,0 +1,5 @@ +double +foo (float a, float b) +{ + return (double)a / (double)b; +}

divdf.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mul.c =================================================================== --- mul.c (nonexistent) +++ mul.c (revision 154) @@ -0,0 +1,5 @@ +void +mulqi (char *p, char a, char b) +{ + p[0] = a/b; +}

mul.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dump-noaddr.x =================================================================== --- dump-noaddr.x (nonexistent) +++ dump-noaddr.x (revision 154) @@ -0,0 +1,49 @@ +# This checks if -fdump-noaddr dumps are done consistently. +proc dump_compare { src options } { + global srcdir subdir + global tmpdir + + exec echo $src + + global torture_with_loops + set option_list $torture_with_loops + set dumpbase dump-noaddr + # ??? passing -dumpbase to the gcc driver doesn't work, since it will pass + # another -dumpbase option to override it. + # loop through all the options + foreach option $option_list { +# c-torture-compile ${dumpbase}_1 "$option $options -DMASK=1 -x c -da -fdump-tree-all" +# c-torture-compile ${dumpbase}_2 "$option $options -DMASK=2 -x c -da -fdump-tree-all" +# c-torture-compile ${dumpbase}_3 "$option $options -DMASK=3 -x c -da -fdump-tree-all" + file delete -force dump1 + file delete -force dump2 + file mkdir dump1 + file mkdir dump2 + cd dump1 + c-torture-compile $src "$option $options -DMASK=1 -x c --param ggc-min-heapsize=1 -da -fdump-tree-all -fdump-noaddr" + cd ../dump2 + c-torture-compile $src "$option $options -DMASK=2 -x c -da -fdump-tree-all -fdump-noaddr" + cd .. + foreach dump1 [lsort [glob -nocomplain dump1/*]] { + regsub dump1/ $dump1 dump2/ dump2 + set dumptail "gcc.c-torture/unsorted/[file tail $dump1]" + #puts "$option $dump1" + set tmp [ diff "$dump1" "$dump2" ] + if { $tmp == 0 } { + untested "$dumptail, $option comparison" + } elseif { $tmp == 1 } { + pass "$dumptail, $option comparison" + } else { + fail "$dumptail, $option comparison" + } + #exec diff $dump1 $dump2 + } + } + file delete -force dump1 + file delete -force dump2 +} + +catch {dump_compare $src $options} result +puts $result +verbose result +return 1 Index: q.c =================================================================== --- q.c (nonexistent) +++ q.c (revision 154) @@ -0,0 +1,7 @@ + +unsigned +reg0indreg1 (r0, p1) + unsigned short r0; unsigned short p1; +{ + return (r0 + p1); +}

q.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG5.c =================================================================== --- BUG5.c (nonexistent) +++ BUG5.c (revision 154) @@ -0,0 +1,18 @@ +enum bar +{ + one, + two +}; + +enum bar foo; + +void bar() +{ + switch (foo) + { + case one: + case two: + printf ("one to two\n"); + break; + } +}

BUG5.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bb0.c =================================================================== --- bb0.c (nonexistent) +++ bb0.c (revision 154) @@ -0,0 +1,5 @@ +foo (a) +{ + return (a & 0xfff000) != 0; + +}

bb0.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sc.c =================================================================== --- sc.c (nonexistent) +++ sc.c (revision 154) @@ -0,0 +1,5 @@ +foo (a, b) + int a, b; +{ + return (a < 0) | (a <= 0) | (a == 0) | (a != 0) | (a >= 0) | (a > 0); +}

sc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bitw.c =================================================================== --- bitw.c (nonexistent) +++ bitw.c (revision 154) @@ -0,0 +1,9 @@ +foo (a) + unsigned a; +{ + unsigned b = 0; + + if ((a & 12345678) > b) + return 1; + return 0; +}

bitw.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: loop386.c =================================================================== --- loop386.c (nonexistent) +++ loop386.c (revision 154) @@ -0,0 +1,15 @@ +foo (a) +{ + do + { + puts ("a"); + a -= 1; + } + while (a != 0); +} + +main () +{ + int p[100]; + printf ("%d\n", foo (3)); +}

loop386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ex.c =================================================================== --- ex.c (nonexistent) +++ ex.c (revision 154) @@ -0,0 +1,11 @@ +foo (a, b) +{ + if ((a & (1 << b)) == 0) + return 1; + return 0; +} + +main () +{ + printf ("%d\n", foo ()); +}

ex.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: unsorted.exp =================================================================== --- unsorted.exp (nonexistent) +++ unsorted.exp (revision 154) @@ -0,0 +1,54 @@ +# +# Expect driver script for GCC Regression Tests +# Copyright (C) 1993, 1997, 2007 Free Software Foundation +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# . +# +# Written by Jeffrey Wheat (cassidy@cygnus.com) +# + +# +# These tests come from Torbjorn Granlund's (tege@cygnus.com) +# C torture test suite, and other contributors. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +# +# This loop will run c-torture on any *.c file found in this directory. +# If a *.c has a corresponding *.exp file, then the test is skipped as +# as the *.exp will drive the test itself. It is done this way so that +# generic tests do not need a separate .exp for it. Only the tests that +# require unique options need their own .exp file. +# + +foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.c]] { + if [file exists [file rootname $testcase].exp] then { + verbose "INFO:\"[file rootname $testcase].exp\" exists, skipping test" 3 + continue + } + + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $testcase] then { + continue + } + + c-torture $testcase +} Index: bugc.c =================================================================== --- bugc.c (nonexistent) +++ bugc.c (revision 154) @@ -0,0 +1,7 @@ + +int +reg0indreg1 (r0, p1) + short r0; short *p1; +{ + return (r0); +}

bugc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: m5.c =================================================================== --- m5.c (nonexistent) +++ m5.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return a * 5 + 12; +}

m5.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: lll.c =================================================================== --- lll.c (nonexistent) +++ lll.c (revision 154) @@ -0,0 +1,45 @@ + +byte_match_count2 (buf, n, xm, m1, m2, m3, m4) + unsigned *buf; + unsigned n; + unsigned xm; + unsigned m1, m2, m3, m4; +{ + unsigned w, cnt = 0; + unsigned *bp; + + n /= 4; + + bp = buf; + while (bp < buf + n) + { + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + } + return cnt; +}

lll.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: set386.c =================================================================== --- set386.c (nonexistent) +++ set386.c (revision 154) @@ -0,0 +1,5 @@ +foo (a, p) + int *p; +{ + *p = a > 0; +}

set386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: delay.c =================================================================== --- delay.c (nonexistent) +++ delay.c (revision 154) @@ -0,0 +1,11 @@ +foo (a, b) +{ + if (a == 1) + goto foo1; + if (a == 2) + goto foo2; + foo1: + return 2; + foo2: + return 3; +}

delay.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: time.c =================================================================== --- time.c (nonexistent) +++ time.c (revision 154) @@ -0,0 +1,7 @@ +main () +{ + int i; + for (i = 3000000; --i;) + { + } +}

time.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: USIcmp.c =================================================================== --- USIcmp.c (nonexistent) +++ USIcmp.c (revision 154) @@ -0,0 +1,280 @@ +#define type unsigned int + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} +

USIcmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: b88.c =================================================================== --- b88.c (nonexistent) +++ b88.c (revision 154) @@ -0,0 +1,12 @@ +foo (double d) +{ + d = -d; + if (d < 0.0) + return 1; + return 2; +} + +main () +{ + foo (0.0); +}

b88.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: shft.c =================================================================== --- shft.c (nonexistent) +++ shft.c (revision 154) @@ -0,0 +1,15 @@ +foo (a) + int a; +{ + int b = 8; + + if ((a << b) >= 0) + return 1; + return a; +} + +main () +{ + if (foo (0x00ffffff) == 1) + puts ("y"); +}

shft.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: move.c =================================================================== --- move.c (nonexistent) +++ move.c (revision 154) @@ -0,0 +1,9 @@ +typedef char type; + +type +foo (b) +{ + type a; + for (a = 10; a < b; a++) + ; +}

move.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: str.c =================================================================== --- str.c (nonexistent) +++ str.c (revision 154) @@ -0,0 +1,13 @@ +typedef struct +{ + char a; + char b; +} foo; + +bar () +{ + foo foobar[100]; + foobar[1].a = 'a'; + foobar[2].a = 'b'; + barfoo (foobar); +}

str.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: test.c =================================================================== --- test.c (nonexistent) +++ test.c (revision 154) @@ -0,0 +1,6 @@ +foo (a) +{ + if (a & 38) + return 1; + return 0; +}

test.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pp.c =================================================================== --- pp.c (nonexistent) +++ pp.c (revision 154) @@ -0,0 +1,9 @@ +foo (a, b, c, d, e, i0, f, i1) + double a, b, c, d, e, f; + int i0, i1; +{} + +main () +{ + foo (1.0, 2.0, 3.0, 4.0, 5.0, 1, 6.0, 2); +}

pp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: b.c =================================================================== --- b.c (nonexistent) +++ b.c (revision 154) @@ -0,0 +1,4 @@ +main () +{ + *(short *) 25 = 123; +}

b.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG23.c =================================================================== --- BUG23.c (nonexistent) +++ BUG23.c (revision 154) @@ -0,0 +1,18 @@ +main() +{ + static char static_char_array[1]; + static char *static_char_pointer; + static char static_char; + char char_array[1]; + char *char_pointer; + char character; + + char *cp, c; + + c = cp - static_char_array; /* error */ + c = cp - static_char_pointer; + c = cp - &static_char; /* error */ + c = cp - char_array; + c = cp - char_pointer; + c = cp - &character; +}

BUG23.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: const.c =================================================================== --- const.c (nonexistent) +++ const.c (revision 154) @@ -0,0 +1,4 @@ +main (a) +{ + return a + (~0 - 240); +}

const.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: seq.c =================================================================== --- seq.c (nonexistent) +++ seq.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return a < 0; +}

seq.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: DFcmp.c =================================================================== --- DFcmp.c (nonexistent) +++ DFcmp.c (revision 154) @@ -0,0 +1,280 @@ +#define type double + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)((int)&glob0)) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)((int)&glob1)) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} +

DFcmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: lop.c =================================================================== --- lop.c (nonexistent) +++ lop.c (revision 154) @@ -0,0 +1,6 @@ +lop (a) +{ + do + a--; + while (a >= -1); +}

lop.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: trunc.c =================================================================== --- trunc.c (nonexistent) +++ trunc.c (revision 154) @@ -0,0 +1,11 @@ +main () +{ + printf ("%x, %x\n", (unsigned char) main, main); +} + +foo (p) + char *p; +{ + p[0] = (char)foo; + p[1] = (char)foo; +}

trunc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ic.c =================================================================== --- ic.c (nonexistent) +++ ic.c (revision 154) @@ -0,0 +1,7 @@ +foo (int *ip, int a) +{ + a++; + if (a < ip[a]) + return 1; + return 0; +}

ic.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: 86.c =================================================================== --- 86.c (nonexistent) +++ 86.c (revision 154) @@ -0,0 +1,19 @@ +m32 (a) + int *a; +{ + a[1] = a[0]; +} + +m16 (a) + short *a; +{ + a[1] = a[0]; +} + + +m8 (a) + char *a; +{ + a[1] = a[0]; +} +

86.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: andsi.c =================================================================== --- andsi.c (nonexistent) +++ andsi.c (revision 154) @@ -0,0 +1,4 @@ +foo () +{ + return (int)&foo; +}

andsi.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: msp.c =================================================================== --- msp.c (nonexistent) +++ msp.c (revision 154) @@ -0,0 +1,10 @@ +#ifdef STACK_SIZE +# define A_SIZE (STACK_SIZE/sizeof(int)) +#else +# define A_SIZE 16384 +#endif +foo () +{ + int a[A_SIZE]; + bar (a); +}

msp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cmul.c =================================================================== --- cmul.c (nonexistent) +++ cmul.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return a * 84; +}

cmul.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: r.c =================================================================== --- r.c (nonexistent) +++ r.c (revision 154) @@ -0,0 +1,7 @@ +r (a, b) +{ + if (a < b) + return 1; + else + return 2; +}

r.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG6.c =================================================================== --- BUG6.c (nonexistent) +++ BUG6.c (revision 154) @@ -0,0 +1,8 @@ +main() +{ + unsigned long L; + double D; + D = L = -3; + printf("L=%lu, D=%g\n", L, D); + return 0; +}

BUG6.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bb1.c =================================================================== --- bb1.c (nonexistent) +++ bb1.c (revision 154) @@ -0,0 +1,8 @@ +foo (a) +{ + int b = 32; + if (b & a) + return 1; + else + return 0; +}

bb1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: float.c =================================================================== --- float.c (nonexistent) +++ float.c (revision 154) @@ -0,0 +1,6 @@ +double +foo (a, b, c) + double a, b, c; +{ + return a * b + c * a; +}

float.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: loadhicc.c =================================================================== --- loadhicc.c (nonexistent) +++ loadhicc.c (revision 154) @@ -0,0 +1,15 @@ +typedef int xtype; + +foo (p, pc) + xtype *p; + char *pc; +{ + xtype a; + unsigned b = 0; + + a = *p; + p[1] = a; + if ((unsigned) p[1] > 0) + return 1; + return a; +}

loadhicc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mm.c =================================================================== --- mm.c (nonexistent) +++ mm.c (revision 154) @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a * 2; +}

mm.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cmpsi386.c =================================================================== --- cmpsi386.c (nonexistent) +++ cmpsi386.c (revision 154) @@ -0,0 +1,14 @@ +foo (a, p) + register int a; + int *p; +{ + + for (a = 10000000; a >= *p; a--) + ; +} + +main () +{ + int a; + foo (a, a); +}

cmpsi386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: or.c =================================================================== --- or.c (nonexistent) +++ or.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return a | 0xffff0101; +}

or.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mu.c =================================================================== --- mu.c (nonexistent) +++ mu.c (revision 154) @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a * b; +}

mu.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dshift.c =================================================================== --- dshift.c (nonexistent) +++ dshift.c (revision 154) @@ -0,0 +1,10 @@ +foo (b, c) + unsigned b, c; +{ + return (b << 12) | (c >> 20); +} + +main () +{ + printf ("0x%x\n", foo (0x11223344, 0xaabbccdd)); +}

dshift.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: arr.c =================================================================== --- arr.c (nonexistent) +++ arr.c (revision 154) @@ -0,0 +1,9 @@ +foo (a, b, c) +{ + bar (a, b); + { + int arr[10]; + arr[c] = b; + bar (arr[0], arr[1]); + } +}

arr.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xdi.c =================================================================== --- xdi.c (nonexistent) +++ xdi.c (revision 154) @@ -0,0 +1,15 @@ +foo (long long *p, int a, int b) +{ + *(p + a + b) = 876243243874343LL; +} + +bar (p, pp) + long long *p, *pp; +{ + long long a; + *p++ = a; + fee (*p); + *p++ = *pp--; + *p++ = *pp--; + return (int) p; +}

xdi.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: modcc.c =================================================================== --- modcc.c (nonexistent) +++ modcc.c (revision 154) @@ -0,0 +1,4 @@ +foo (a, b) +{ + return (a % b) == 0; +}

modcc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: shm.c =================================================================== --- shm.c (nonexistent) +++ shm.c (revision 154) @@ -0,0 +1,5 @@ +foo (int *p) +{ + int a = *p; + return a >> 24; +}

shm.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bf.c =================================================================== --- bf.c (nonexistent) +++ bf.c (revision 154) @@ -0,0 +1,31 @@ +typedef unsigned long uint32; +typedef signed long sint32; + +uint32 +ext (sint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src >> o5 : (src << (( - o5 - w5) & 31)) >> (32 - w5); +} + +uint32 +extu (uint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src >> o5 : (src << (( - o5 - w5) & 31)) >> (32 - w5); +} + +uint32 +mak (uint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src << o5 : (src << (32 - w5)) >> (( - o5 - w5) & 31); +} + +uint32 +rot (uint32 src, unsigned o5) +{ + return (src >> o5) | (src << (( - o5) & 31)); +} + +main (int argc, char **argv) +{ + printf ("%x\n", clr (0xffffffff, atoi (argv[2]), atoi (argv[1]))); +}

bf.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: forgetcc.c =================================================================== --- forgetcc.c (nonexistent) +++ forgetcc.c (revision 154) @@ -0,0 +1,11 @@ +foo (hp, p, a) + short *hp; + int *p; + int a; +{ + hp[10] = a; + p[0] = 10; + if (hp[10] > 0) + return 1; + return 0; +}

forgetcc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: addcc.c =================================================================== --- addcc.c (nonexistent) +++ addcc.c (revision 154) @@ -0,0 +1,18 @@ +foo (p, a, b) + int *p; + int a; + int b; +{ + + a += p[0]; + b += p[1]; + if (a == 0) + return b; + return a; +} + + +bar (a) +{ + return -a > 0 ? 1 : 2; +}

addcc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: f1.c =================================================================== --- f1.c (nonexistent) +++ f1.c (revision 154) @@ -0,0 +1,5 @@ +double +foo () +{ + return 1.2587624368724; +}

f1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: move_qhi.c =================================================================== --- move_qhi.c (nonexistent) +++ move_qhi.c (revision 154) @@ -0,0 +1,12 @@ +move (a, b) + char a, b; +{ + char s; + s = a; + if (s) + gurka (s); + foo (b, a); + a = bar (); + b = bar (); + gra (s); +}

move_qhi.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: csebug.c =================================================================== --- csebug.c (nonexistent) +++ csebug.c (revision 154) @@ -0,0 +1,7 @@ + +int +reg0indreg1 (r0, p1) + short r0; short *p1; +{ + return (r0 + *p1); +}

csebug.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mword1.c =================================================================== --- mword1.c (nonexistent) +++ mword1.c (revision 154) @@ -0,0 +1,12 @@ +int +foo (a, b) +int *a, *b; +{ + int x; + *a = (*b + 1); + x = *b; + if ((int) x) + return 1; + else + return 0; +}

mword1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: trivial.c =================================================================== --- trivial.c (nonexistent) +++ trivial.c (revision 154) @@ -0,0 +1 @@ +foo () {}

trivial.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xfoo.c =================================================================== --- xfoo.c (nonexistent) +++ xfoo.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return (a & ~0xfff) == 0; +}

xfoo.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: shift.c =================================================================== --- shift.c (nonexistent) +++ shift.c (revision 154) @@ -0,0 +1,7 @@ +foo (a) +{ + if (a >= 0) + return (unsigned) a << 10; + else + return (int) a << 10; +}

shift.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: nand.c =================================================================== --- nand.c (nonexistent) +++ nand.c (revision 154) @@ -0,0 +1,4 @@ +nadn (a, b) +{ + return (~a) | (~b); +}

nand.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: c.c =================================================================== --- c.c (nonexistent) +++ c.c (revision 154) @@ -0,0 +1,17 @@ +foo (a, b) + long long a, b; +{ + if (a & ~b) + return 1; + else + return 0; +} + +bar (a, b) + long long a, b; +{ + if (a & ~b & ((long long) 87612378)) + return 1; + else + return 0; +}

c.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: rel.c =================================================================== --- rel.c (nonexistent) +++ rel.c (revision 154) @@ -0,0 +1,8 @@ +foo (int *c, int b) +{ + int a; + + a = *c + b; + c[1] = a; + return b; +}

rel.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG24.c =================================================================== --- BUG24.c (nonexistent) +++ BUG24.c (revision 154) @@ -0,0 +1,15 @@ +struct ack { + char a, b, c; +}; + +main() +{ + struct ack bad; + + foo(bad); +} + +foo(c) + struct ack c; +{ +}

BUG24.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: test-loop.c =================================================================== --- test-loop.c (nonexistent) +++ test-loop.c (revision 154) @@ -0,0 +1,7 @@ +main () +{ + int i; + for (i = 100; i >= -1; i--) + foo (); + +}

test-loop.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: jmp.c =================================================================== --- jmp.c (nonexistent) +++ jmp.c (revision 154) @@ -0,0 +1,20 @@ +foo (a) +{ + if (a) + goto a1; + goto a2; + a1: goto a3; + a2: goto a4; + a3: goto a5; + a4: goto a6; + a5: goto a7; + a6: goto a8; + a7: goto a9; + a8: goto a10; + a9: goto a11; + a10: goto a12; + a11: goto a13; + a12:; + a13:; + return -a; +}

jmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ifreg.c =================================================================== --- ifreg.c (nonexistent) +++ ifreg.c (revision 154) @@ -0,0 +1,12 @@ +union foo +{ + float f; + int i; +}; + +foo (int a, float c) +{ + union foo b; + b.i = a; + return b.f + c; +}

ifreg.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: structret.c =================================================================== --- structret.c (nonexistent) +++ structret.c (revision 154) @@ -0,0 +1,69 @@ +struct foo +{ + int a, b, c, d; + double doubl; +} s1, s2; + +#ifndef ONLY2 + +struct foo +structret (s1, i1, i2, s2) + struct foo s1, s2; + int i1, i2; +{ + if (i1 != i2) + { + if (i1 < i2) + return s1; + else + return s2; + } + s2.a = 11; + s2.b = 22; + s2.c = s1.c; + s2.d = s1.d; + return s2; +} + +#endif + +#ifndef ONLY1 + +struct foo +mani (a, b) +{ + return structret (s1, a, b, s2); +} + +init () +{ + s1.a = 1; + s1.b = 2; + s1.c = 3; + s1.d = 4; + s1.doubl = 3.1415; + s2.a = -1; + s2.b = -2; + s2.c = -3; + s2.d = -4; + s2.doubl = 2.71818; +} + +main () +{ + struct foo s; + + init (); + s = mani (1, 1); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); + + init (); + s = mani (2, 1); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); + + init (); + s = mani (1, 2); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); +} + +#endif

structret.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pmt.c =================================================================== --- pmt.c (nonexistent) +++ pmt.c (revision 154) @@ -0,0 +1,6 @@ +long long +foo (a, b) + long long a, b; +{ + return a; +}

pmt.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: a1.c =================================================================== --- a1.c (nonexistent) +++ a1.c (revision 154) @@ -0,0 +1,7 @@ +int +foo (a, p) + int *p; +{ + p[0] = 85 * a; + p[1] = -86 * a; +}

a1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: s.c =================================================================== --- s.c (nonexistent) +++ s.c (revision 154) @@ -0,0 +1,24 @@ +struct foo +{ + int a, b, c, d; + double doubl; +} s1, s2; + +struct foo +structret (s1, i1, i2, s2) + struct foo s1, s2; + int i1, i2; +{ + if (i1 != i2) + { + if (i1 < i2) + return s1; + else + return s2; + } + s2.a = 11; + s2.b = 22; + s2.c = s1.c; + s2.d = s1.d; + return s2; +}

s.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: abs.c =================================================================== --- abs.c (nonexistent) +++ abs.c (revision 154) @@ -0,0 +1,9 @@ +foo (a) +{ + return __builtin_abs (a); +} + +main () +{ + printf ("%d %d\n", foo (0x80000000), foo (12)); +}

abs.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: llbug.c =================================================================== --- llbug.c (nonexistent) +++ llbug.c (revision 154) @@ -0,0 +1,13 @@ +union foo +{ + long long d; +}; + +int +bar (long long d) +{ + union foo u; + + u.d = d; + return (int) &u; +}

llbug.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: udconvert.c =================================================================== --- udconvert.c (nonexistent) +++ udconvert.c (revision 154) @@ -0,0 +1,30 @@ +double +unsigned_to_double1 (u) + unsigned u; +{ + double d; + d = (int) u; /* convert as from a *signed* integer */ + return ((int) u < 0) + ? d + 4294967296.0 + : d; +} + +/* Alternatively */ + +double +unsigned_to_double2 (u) + unsigned u; +{ + double d; + u -= 2147483648; /* complement sign bit */ + d = (int) u; /* convert as from a *signed* integer */ + return d + 2147483648.0; +} + +unsigned +double_to_unsigned (d) + double d; +{ + d += 2147483648.0; + return ((int) d) - 2147483648; +}

udconvert.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: consec.c =================================================================== --- consec.c (nonexistent) +++ consec.c (revision 154) @@ -0,0 +1,17 @@ +int glob; + +conseq (a, b, c, d) + int *a, *b; +{ + a[2] = d; + a[1] = c; + sequence (a, b, c, d); + sequence (d, c, b, a); + b[0] = 0; + b[1] = 123; + a[0] = 321; + a[1] = 0; + sequence (111, 0, 0, 222, 0, 333); + ((int *)glob)[2] = c; + ((int *)glob)[3] = d; +}

consec.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pyr.c =================================================================== --- pyr.c (nonexistent) +++ pyr.c (revision 154) @@ -0,0 +1,11 @@ +foo (char *a) +{ + char b; + int c; + b = *a; + c = b; + if (c < 0) + return 1; + a[1] = b; + +}

pyr.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bcopy.c =================================================================== --- bcopy.c (nonexistent) +++ bcopy.c (revision 154) @@ -0,0 +1,68 @@ +void +bcopy1 (s, d, c) + long long *s; + long long *d; + int c; +{ + int i; + c = c / 8; + for (i = 0; i < c; i++) + d[i] = s[i]; +} + +void +bcopy2 (s, d, c) + long *s; + long *d; + int c; +{ + int i; + c = c / 4; + for (i = 0; i < c; i++) + d[i] = s[i]; +} + + +void +bcopy3 (s, d, c) + char *s; + char *d; + int c; +{ + long long z0, z1; + int r = d - s; + + int i; + + c /= 16; + + z0 = *((long long *) s); + s += 8; + z1 = *((long long *) s); + s += 8; + for (i = 0; i < c; i++) + { + *(long long *)(s + r) = z0; + z0 = *((long long *) s); + s += 8; + *(long long *)(s + r) = z1; + z1 = *((long long *) s); + s += 8; + } +} + +#if defined(STACK_SIZE) && STACK_SIZE < 16384 +#define BYTES STACK_SIZE +#else +#define BYTES 16384 +#endif + +main () +{ + long long s[BYTES / 8]; + long long d[BYTES / 8]; + int i; + + for (i = 1; i < 67108864 / BYTES; i++) + bcopy (s, d, BYTES); +}

bcopy.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG16.c =================================================================== --- BUG16.c (nonexistent) +++ BUG16.c (revision 154) @@ -0,0 +1,6 @@ +setgetlen (a) + int *a; +{ + while (*a++ & 0x80000000) + ; +}

BUG16.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sne.c =================================================================== --- sne.c (nonexistent) +++ sne.c (revision 154) @@ -0,0 +1,4 @@ +foo (double a) +{ + return (a != 0); +}

sne.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xopt.c =================================================================== --- xopt.c (nonexistent) +++ xopt.c (revision 154) @@ -0,0 +1,35 @@ +proc1 (a) + unsigned a; +{ + return (a >> 20) & 0x010fffff; +} + +proc2 (a) + unsigned a; +{ + return (a << 17) & 0xfffff001; +} + +proc3 (a) + unsigned a; +{ + return (a & 0xff00000a) >> 25; +} + +proc4 (a) + unsigned a; +{ + return (a & 0x100000ff) << 25; +} + +proc5 (a) + unsigned a; +{ + return (unsigned char) (a >> 24); +} + +proc6 (a) + unsigned a; +{ + return ((unsigned char) a) << 30; +}

xopt.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: udivmod4.c =================================================================== --- udivmod4.c (nonexistent) +++ udivmod4.c (revision 154) @@ -0,0 +1,56 @@ +long long +xlrandom () +{ + long long x; + unsigned a; + int bits = 64; + unsigned b; + + do + { + a = random (); + b = (a & 15) + 1; + x <<= b; /* shift up 1-16 steps */ + a = (a >> 18) & 1; + if (a) + x |= (unsigned) (1 << b) - 1; + bits -= b; + } + while (bits >= 0); + return x; +} + + +unsigned long long __udivmoddi4(); + +main () +{ + int i; + unsigned long long n, d, q, r, rr; + + for (i = 0; ;i++) + { + n = xlrandom (); + d = xlrandom (); + if (d == 0) + continue; + + q = __udivmoddi4 (n, d, &r); + + if (i % 1000000 == 0) + printf ("Testing udivmoddi4: %d iterations made\n", i); + + rr = n - q * d; + if (rr != r || r >= d) + { + printf ("Testing udivmoddi4: failure after %d iterations\n", i); + printf ("n=%lX%08lX\n", (unsigned) (n >> 32), (unsigned) n); + printf ("d=%lX%08lX\n", (unsigned) (d >> 32), (unsigned) d); + printf ("q=%lX%08lX\n", (unsigned) (q >> 32), (unsigned) q); + printf ("r=%lX%08lX\n", (unsigned) (r >> 32), (unsigned) r); + printf ("rr=%lX%08lX\n", (unsigned) (rr >> 32), (unsigned) rr); + abort (); + } + } + +}

udivmod4.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pyr2.c =================================================================== --- pyr2.c (nonexistent) +++ pyr2.c (revision 154) @@ -0,0 +1,4 @@ +foo (a) +{ + return ((int *)0)[a]; +}

pyr2.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ww.c =================================================================== --- ww.c (nonexistent) +++ ww.c (revision 154) @@ -0,0 +1,7 @@ +foo (p) + short *p; +{ + static int *foo; + *p = 1234; + *foo = 1234; +}

ww.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: UQIcmp.c =================================================================== --- UQIcmp.c (nonexistent) +++ UQIcmp.c (revision 154) @@ -0,0 +1,280 @@ +#define type unsigned char + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} +

UQIcmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dic.c =================================================================== --- dic.c (nonexistent) +++ dic.c (revision 154) @@ -0,0 +1,5 @@ +unsigned long long +main () +{ + return (unsigned long long) 7816234 << 671111; +}

dic.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xneg.c =================================================================== --- xneg.c (nonexistent) +++ xneg.c (revision 154) @@ -0,0 +1,5 @@ +foo (a) + double a; +{ + return -a; +}

xneg.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: signext2.c =================================================================== --- signext2.c (nonexistent) +++ signext2.c (revision 154) @@ -0,0 +1,11 @@ +long long +foo (a) + int a; +{ + return a; +} + +main () +{ + printf ("%d\n", (int) (foo (-1) >> 32)); +}

signext2.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: fnul.c =================================================================== --- fnul.c (nonexistent) +++ fnul.c (revision 154) @@ -0,0 +1,23 @@ +main () +{ + int i; + int f; + + for (i = 0;; i--) + { + f = 0; + + if ((i & (i - 1)) == 0) + { + printf ("d"); + f = 1; + } + if ((i & -i) == i) + { + printf ("t"); + f = 1; + } + if (f) + printf ("%d\n", i); + } +}

fnul.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: rmsc.c =================================================================== --- rmsc.c (nonexistent) +++ rmsc.c (revision 154) @@ -0,0 +1,46 @@ + +cc1 (x, y) + int x, y; +{ + int z; + z = x - y; + if (x >= y) + return z + 1; + else + return z + 0; +} + +cc2 (x, y) + int x, y; +{ + int z; + + z = x - y; + if (z >= 0) + return z + 1; + else + return z + 0; +} + +cc3 (x, y) + unsigned x, y; +{ + unsigned z; + z = x - y; + if (x >= y) + return z + 1; + else + return z + 0; +} + +cc4 (x, y) + unsigned x, y; +{ + unsigned z; + + z = x - y; + if (z >= 0) + return z + 1; + else + return z + 0; +}

rmsc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: fq.c =================================================================== --- fq.c (nonexistent) +++ fq.c (revision 154) @@ -0,0 +1,25 @@ +expand_to_ascii (int *i, int *o) +{ + unsigned x, y, out; + unsigned x1; + + /* Big endian code. */ + + x = *i++; + + y = x >> (32 - 13); + out = (y / 91); + out = (out << 8) | (y % 91); + + x <<= 13; + y = x >> (32 - 13); + out = (out << 8) | (y / 91); + out = (out << 8) | (y % 91); + + *o++ = out + 0x20202020; + + /* 6 bits left in x. */ + + x1 = *i++; + x = (x << 26) | (x1 >> 6); +}

fq.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xpp.c =================================================================== --- xpp.c (nonexistent) +++ xpp.c (revision 154) @@ -0,0 +1,12 @@ +foo (a) +{ + a++; + if (a < 10) + return 1; + return a; +} + +main () +{ + printf ("%d\n", foo ((1 << 31) - 1)); +}

xpp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: f2.c =================================================================== --- f2.c (nonexistent) +++ f2.c (revision 154) @@ -0,0 +1,4 @@ +foo (double *p) +{ + p[0] = p[1]; +}

f2.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: poor.c =================================================================== --- poor.c (nonexistent) +++ poor.c (revision 154) @@ -0,0 +1,34 @@ +typedef struct +{ + char c[510]; +} s510; + +typedef struct +{ + char c[511]; +} s511; + +s510 G510, s1; +s511 G511; +int I, J; +double D; + +void main(void); +void f0(double D, ...); +s510 f1(double D, ...); +void f2a(s510 S); +void f2b(s511 S); + + +void main(void) +{ + + f0(D, I, J); + + s1 = f1(D, I, D); + + f2a(G510); + + f2b(G511); + +}

poor.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: aa.c =================================================================== --- aa.c (nonexistent) +++ aa.c (revision 154) @@ -0,0 +1,8 @@ +#define w 20 +#define c 1 + +foo (a) + unsigned a; +{ + return ((a & ((1 << w) - 1)) << c) > 0; +}

aa.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: parms.c =================================================================== --- parms.c (nonexistent) +++ parms.c (revision 154) @@ -0,0 +1,7 @@ +#define alloca __builtin_alloca + +x (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, x, y) +{ + foo (alloca (8)); + return a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+x+y; +}

parms.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: d.c =================================================================== --- d.c (nonexistent) +++ d.c (revision 154) @@ -0,0 +1,19 @@ +long long unsigned +str2llu (str) + char *str; +{ + long long unsigned acc; + long long b = 10; + char d; + acc = *str++ - '0'; + for (;;) + { + d = *str++; + if (d == '\0') + break; + d -= '0'; + acc = acc * 10 + d; + } + + return acc; +}

d.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG25.c =================================================================== --- BUG25.c (nonexistent) +++ BUG25.c (revision 154) @@ -0,0 +1,5 @@ + +foo (a) +{ + __builtin_ffs (a); +}

BUG25.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bbb.c =================================================================== --- bbb.c (nonexistent) +++ bbb.c (revision 154) @@ -0,0 +1,12 @@ +struct looksets + { + int lset[10]; + }; + +struct looksets lkst[]; + +flset( p ) +struct looksets *p; +{ + p-- > lkst; +}

bbb.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: charmtst.c =================================================================== --- charmtst.c (nonexistent) +++ charmtst.c (revision 154) @@ -0,0 +1,15 @@ +c_move_tst (char b) +{ + char a; + + a = b; + b = 'b'; + foo (a); + foo (b); + foo (a); + bar (a, b); + b = a; + if (b == 0) + a++; + return a + b; +}

charmtst.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sim.c =================================================================== --- sim.c (nonexistent) +++ sim.c (revision 154) @@ -0,0 +1,7 @@ +main () +{ + int i; + + for (i = 1; i < 10000; i++) + ; +}

sim.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: l.c =================================================================== --- l.c (nonexistent) +++ l.c (revision 154) @@ -0,0 +1,4 @@ +main (a) +{ + return - 256 + a; +}

l.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: t.c =================================================================== --- t.c (nonexistent) +++ t.c (revision 154) @@ -0,0 +1,18 @@ +#define B 95 + +foo (a, b, p) + unsigned a, b; + int *p; +{ + p[1] = a % B; + p[0] = a / B; +} + +bar (a, b, p) + unsigned a, b; + int *p; +{ + p[0] = a / B; + p[1] = a % B; +} +

t.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bt386.c =================================================================== --- bt386.c (nonexistent) +++ bt386.c (revision 154) @@ -0,0 +1,18 @@ +foo (a, b) +{ + return (a & (1 << b)) != 0; +} + +bar (a, b) +{ + a ^= (1 << b); + return a != 0; +} + +main () +{ + int i; + for (i = 0; i < 32; i++) + printf ("%d ", foo (0x8000000f, i)); + puts (""); +}

bt386.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: buns.c =================================================================== --- buns.c (nonexistent) +++ buns.c (revision 154) @@ -0,0 +1,12 @@ +foo (a) +{ + int bar = 0; + + return (unsigned) (a - 1) <= (unsigned) bar; +} + +main () +{ + if (foo (-1)) + puts ("The largest possible unsigned <= 0 on this machine..."); +}

buns.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sym.c =================================================================== --- sym.c (nonexistent) +++ sym.c (revision 154) @@ -0,0 +1,4 @@ +foo () +{ + return (int) &foo; +}

sym.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: blk.c =================================================================== --- blk.c (nonexistent) +++ blk.c (revision 154) @@ -0,0 +1,18 @@ +struct +{ + double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t; +} foo, bar; + +foobar () +{ + foo = bar; + xxx (&foo, &bar); +} + +main () +{ + bar.g = 1.0; + foo.g = 2.0; + foobar (); + printf ("%lf\n", foo.g); +}

blk.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xor.c =================================================================== --- xor.c (nonexistent) +++ xor.c (revision 154) @@ -0,0 +1,4 @@ +foo (a, b) +{ + return ~(a ^ ~123); +}

xor.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: call.c =================================================================== --- call.c (nonexistent) +++ call.c (revision 154) @@ -0,0 +1,7 @@ +int foo () {} + +main (a, b) +{ + foo (foo (a, b), foo (b, a)); + return 0; +}

call.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: BUG17.c =================================================================== --- BUG17.c (nonexistent) +++ BUG17.c (revision 154) @@ -0,0 +1,8 @@ +double d; + +main() +{ + int i; + + i = (int) d; +}

BUG17.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: acc.c =================================================================== --- acc.c (nonexistent) +++ acc.c (revision 154) @@ -0,0 +1,8 @@ +foo (a) +{ + int b = a + 1; + int c = (short) a; + if (b) + return b; + return 1; +}

acc.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bad.c =================================================================== --- bad.c (nonexistent) +++ bad.c (revision 154) @@ -0,0 +1,26 @@ +typedef union longlong +{ + struct {unsigned short h0, h1, h2, h3;} h; + struct {signed long low, high;} si; + struct {unsigned long low, high;} ui; + signed long long sll; + unsigned long long ull; +} long_long; + + +long long +__negdi2 (u) + long long u; +{ + long_long uu; + + uu.sll = u; + + uu.si.low = -uu.si.low; + if (uu.si.low == 0) + uu.si.high = -uu.si.high; + else + uu.si.high = ~uu.si.high; + + return uu.sll; +}

bad.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: mword.c =================================================================== --- mword.c (nonexistent) +++ mword.c (revision 154) @@ -0,0 +1,29 @@ +int +foo (a, b) +int *a, *b; +{ + int x, y; + x++; + *a = *b; + y = *b; + + if ((int) x) + return 1; + else + return y; +} + +foo1 (p) + int *p; +{ + p[0] = p[1]; + return p[0]; +} + +foo2 (p, x) + int *p; +{ + p[0] = x; + return p[0]; +} +

mword.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dblbug.c =================================================================== --- dblbug.c (nonexistent) +++ dblbug.c (revision 154) @@ -0,0 +1,21 @@ +union real_extract +{ + double d; + int i[sizeof (double ) / sizeof (int)]; +}; + +typedef struct +{ + int zzzz; +} *rtx; + +rtx +immed_real_const_1 (d) + double d; +{ + union real_extract u; + register rtx r; + + u.d = d; + foo (&(r->zzzz), &u); +}

dblbug.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dm.c =================================================================== --- dm.c (nonexistent) +++ dm.c (revision 154) @@ -0,0 +1,24 @@ +struct dm +{ + unsigned q; + unsigned r; +}; + +struct dm +dm (a, b) + unsigned a, b; +{ + struct dm qr; + + qr.q = a / b; + qr.r = a % b; + return qr; +} + +main () +{ + struct dm qr; + + qr = dm (100, 30); + printf ("%u, %u\n", qr.q, qr.r); +}

dm.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xcsebug.c =================================================================== --- xcsebug.c (nonexistent) +++ xcsebug.c (revision 154) @@ -0,0 +1,14 @@ +int g1; +int g2; + +foo () +{ + int i = 1; + int x; + + x = g1; + (*(&g1 + i - 1)) = x + 1; + x = g1; + (*(&g1 + i - 1)) = x + 1; + g1++; +}

xcsebug.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: stuct.c =================================================================== --- stuct.c (nonexistent) +++ stuct.c (revision 154) @@ -0,0 +1,22 @@ +#ifdef STACK_SIZE +#define SIZE STACK_SIZE / 8 +#else +#define SIZE 10000000 +#endif + +struct foo +{ + int a, b, c; + int arr[SIZE]; +}; + +struct foo s, ss; + +main () +{ + + s.b = 2; + s.c = 3; + ss.b = 2; + ss.c = 3; +}

stuct.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: b1.c =================================================================== --- b1.c (nonexistent) +++ b1.c (revision 154) @@ -0,0 +1,11 @@ +foo (long long x) +{ + if (x--) + return 255; + return 0; +} + +main () +{ + printf ("%d\n", foo (0)); +}

b1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: log2.c =================================================================== --- log2.c (nonexistent) +++ log2.c (revision 154) @@ -0,0 +1,6 @@ +log2 (a, b) +{ + int c; + c = ~(~a & ~b); + return c; +}

log2.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: band.c =================================================================== --- band.c (nonexistent) +++ band.c (revision 154) @@ -0,0 +1,16 @@ +foo (a) +{ + return (a & (1 << 31)) != 0; +} + +main () +{ + if (foo (0)) + puts ("foo"); + else + puts ("bar"); + if (foo (~0)) + puts ("foo"); + else + puts ("bar"); +}

band.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sparcbug.c =================================================================== --- sparcbug.c (nonexistent) +++ sparcbug.c (revision 154) @@ -0,0 +1,5 @@ +foo (a) +{ + int b = a; + return b + 8762345; +}

sparcbug.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: bx.c =================================================================== --- bx.c (nonexistent) +++ bx.c (revision 154) @@ -0,0 +1,12 @@ +unsigned +good (unsigned src, unsigned o5, unsigned w5) +{ + return src & ~((w5 == 0) ? (~0 << o5) : (1 << o5)); +} + +unsigned +bad (unsigned src, unsigned o5, unsigned w5) +{ + return src & ((w5 == 0) ? ~(~0 << o5) : ~(1 << o5)); +} +

bx.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: m68.c =================================================================== --- m68.c (nonexistent) +++ m68.c (revision 154) @@ -0,0 +1,14 @@ +foo (a) +{ + return a | 12345; +} + +bar (a) +{ + return a & (0xffff0000 | 12345); +} + +foobar (a) +{ + return a - 128; +}

m68.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cmp.c =================================================================== --- cmp.c (nonexistent) +++ cmp.c (revision 154) @@ -0,0 +1,11 @@ +struct fooalign {char x; double d;}; +union fooround {long x; double d;}; + +int +foo () +{ + int extra = 4; + if (extra < sizeof (union fooround)) + extra = sizeof (union fooround); + return extra; +}

cmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pret-arg.c =================================================================== --- pret-arg.c (nonexistent) +++ pret-arg.c (revision 154) @@ -0,0 +1,5 @@ +foo (a, b, c, d, e, f, g, h, i, j, xx) + double xx; +{ + return xx + 1.2345; +}

pret-arg.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: r1.c =================================================================== --- r1.c (nonexistent) +++ r1.c (revision 154) @@ -0,0 +1,29 @@ +void assert (a) {if (a != 1) abort ();} + +int h1 (int *p) {return *p & 255;} + +void p1 () {int a = 0x01020304; assert (h1 (&a) == 0x04);} + + +int h2 (a) {return a > 0;} + +p2 () {assert (h2 (1));} + +h3 (int *p) +{ + *p |= 255; +} + +p3 () +{ + int *p; + h3 (p); +} + +main () +{ + p1 (); + p2 (); + p3 (); + puts ("Compiler test passed."); +}

r1.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: foo.c =================================================================== --- foo.c (nonexistent) +++ foo.c (revision 154) @@ -0,0 +1,8 @@ +int * +main (s1, s2) + int *s1; int *s2; +{ + while ((*s1++ = *s2++) != '\0') + ; + return s1 - 1; +}

foo.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: test-flow.c =================================================================== --- test-flow.c (nonexistent) +++ test-flow.c (revision 154) @@ -0,0 +1,12 @@ +foo (a, b, c, d) +{ + if (a < 0) + { + b = c; + } + else + { + b = d; + } + return b + 75; +}

test-flow.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: e.c =================================================================== --- e.c (nonexistent) +++ e.c (revision 154) @@ -0,0 +1,10 @@ +foo (short a, int *p, short *s) +{ + int i; + for (i = 10; i >= 0; i--) + { + a = (short) bar (); + p[i] = a; + s[i] = a; + } +}

e.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: sar.c =================================================================== --- sar.c (nonexistent) +++ sar.c (revision 154) @@ -0,0 +1,10 @@ +struct foo +{ + char a; +} foo[100]; + +main () +{ + foo[1].a = '1'; + foo[2].a = '2'; +}

sar.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: icmp.c =================================================================== --- icmp.c (nonexistent) +++ icmp.c (revision 154) @@ -0,0 +1,10 @@ +foo (a, b) +{ + b++; + if (a <= b) + if ((int) a < (int) b) + b--; + else + b++; + return b; +}

icmp.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ddd.c =================================================================== --- ddd.c (nonexistent) +++ ddd.c (revision 154) @@ -0,0 +1,7 @@ +int foo; +int bar; + +main () +{ + return foo + bar; +}

ddd.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: xzz.c =================================================================== --- xzz.c (nonexistent) +++ xzz.c (revision 154) @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a >> (char) b; +}

xzz.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: stru.c =================================================================== --- stru.c (nonexistent) +++ stru.c (revision 154) @@ -0,0 +1,9 @@ +struct foo +{ + int a, b, c; +}; + +foo (struct foo *a) +{ + a[0] = a[1]; +}

stru.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property