x86.c

   1 /* architecture-dependent code generation for x86 */
   2 #include <stdlib.h>
   3 #include "ncc.h"
   4
   5 /* x86-64 registers, without r8-r15 */
   6 #define R_RAX           0x00
   7 #define R_RCX           0x01
   8 #define R_RDX           0x02
   9 #define R_RBX           0x03
  10 #define R_RSP           0x04
  11 #define R_RBP           0x05
  12 #define R_RSI           0x06
  13 #define R_RDI           0x07
  14
  15 #define REG_RET         R_RAX
  16 #define R_BYTE          0x0007
  17
  18 /* x86 opcodes */
  19 #define I_MOV           0x89
  20 #define I_MOVI          0xc7
  21 #define I_MOVIR         0xb8
  22 #define I_MOVR          0x8b
  23 #define I_MOVSXD        0x63
  24 #define I_SHX           0xd3
  25 #define I_CMP           0x3b
  26 #define I_TST           0x85
  27 #define I_LEA           0x8d
  28 #define I_NOT           0xf7
  29 #define I_CALL          0xff
  30 #define I_MUL           0xf7
  31 #define I_XOR           0x33
  32 #define I_CQO           0x99
  33 #define I_PUSH          0x50
  34 #define I_POP           0x58
  35
  36 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
  37 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
  38
  39 int tmpregs[] = {0, 1, 2, 6, 7, 3};
  40 int argregs[] = {0};
  41
  42 #define OP2(o2, o1)             (0x010000 | ((o2) << 8) | (o1))
  43 #define O2(op)                  (((op) >> 8) & 0xff)
  44 #define O1(op)                  ((op) & 0xff)
  45 #define MODRM(m, r1, r2)        ((m) << 6 | (r1) << 3 | (r2))
  46
  47 static struct mem cs;           /* generated code */
  48
  49 /* code generation functions */
  50 static void os(void *s, int n)
  51 {
  52         mem_put(&cs, s, n);
  53 }
  54
  55 static char *ointbuf(long n, int l)
  56 {
  57         static char buf[16];
  58         int i;
  59         for (i = 0; i < l; i++) {
  60                 buf[i] = n & 0xff;
  61                 n >>= 8;
  62         }
  63         return buf;
  64 }
  65
  66 static void oi(long n, int l)
  67 {
  68         mem_put(&cs, ointbuf(n, l), l);
  69 }
  70
  71 static void oi_at(long pos, long n, int l)
  72 {
  73         mem_cpy(&cs, pos, ointbuf(n, l), l);
  74 }
  75
  76 static long opos(void)
  77 {
  78         return mem_len(&cs);
  79 }
  80
  81 static void op_x(int op, int r1, int r2, int bt)
  82 {
  83         int sz = T_SZ(bt);
  84         if (sz == 2)
  85                 oi(0x66, 1);
  86         if (op & 0x10000)
  87                 oi(O2(op), 1);
  88         oi(sz == 1 ? O1(op) & ~0x1 : O1(op), 1);
  89 }
  90
  91 #define op_mr           op_rm
  92
  93 /* op_*(): r=reg, m=mem, i=imm, s=sym */
  94 static void op_rm(int op, int src, int base, int off, int bt)
  95 {
  96         int dis = off == (char) off ? 1 : 4;
  97         int mod = dis == 4 ? 2 : 1;
  98         if (!off && (base & 7) != R_RBP)
  99                 mod = 0;
 100         op_x(op, src, base, bt);
 101         oi(MODRM(mod, src & 0x07, base & 0x07), 1);
 102         if ((base & 7) == R_RSP)
 103                 oi(0x24, 1);
 104         if (mod)
 105                 oi(off, dis);
 106 }
 107
 108 static void op_rr(int op, int src, int dst, int bt)
 109 {
 110         op_x(op, src, dst, bt);
 111         oi(MODRM(3, src & 0x07, dst & 0x07), 1);
 112 }
 113
 114 #define movrx_bt(bt)            (LONGSZ)
 115
 116 static int movrx_op(int bt, int mov)
 117 {
 118         int sz = T_SZ(bt);
 119         if (sz == 2)
 120                 return OP2(0x0f, bt & T_MSIGN ? 0xbf : 0xb7);
 121         if (sz == 1)
 122                 return OP2(0x0f, bt & T_MSIGN ? 0xbe : 0xb6);
 123         return mov;
 124 }
 125
 126 static void mov_r2r(int rd, int r1, unsigned bt)
 127 {
 128         if (rd != r1 || T_SZ(bt) != LONGSZ)
 129                 op_rr(movrx_op(bt, I_MOVR), rd, r1, movrx_bt(bt));
 130 }
 131
 132 static void i_mov(int rd, int rn)
 133 {
 134         op_rr(movrx_op(LONGSZ, I_MOVR), rd, rn, movrx_bt(LONGSZ));
 135 }
 136
 137 static void i_add(int op, int rd, int r1, int r2)
 138 {
 139         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 140         static int rx[] = {0003, 0053, 0043, 0013, 0063};
 141         op_rr(rx[op & 0x0f], rd, r2, LONGSZ);
 142 }
 143
 144 static void i_add_imm(int op, int rd, int rn, long n)
 145 {
 146         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 147         static int rx[] = {0xc0, 0xe8, 0xe0, 0xc8, 0xf0};
 148         unsigned char s[4] = {0x83, rx[op & 0x0f] | rd, n & 0xff};
 149         os((void *) s, 3);
 150 }
 151
 152 static void i_num(int rd, long n)
 153 {
 154         if (!n) {
 155                 op_rr(I_XOR, rd, rd, 4);
 156                 return;
 157         } else {
 158                 op_x(I_MOVIR + (rd & 7), 0, rd, LONGSZ);
 159                 oi(n, LONGSZ);
 160         }
 161 }
 162
 163 static void i_mul(int rd, int r1, int r2)
 164 {
 165         if (r2 != R_RDX)
 166                 i_num(R_RDX, 0);
 167         op_rr(I_MUL, 4, r2, LONGSZ);
 168 }
 169
 170 static void i_div(int op, int rd, int r1, int r2)
 171 {
 172         long bt = O_T(op);
 173         if (r2 != R_RDX) {
 174                 if (bt & T_MSIGN)
 175                         op_x(I_CQO, R_RAX, R_RDX, LONGSZ);
 176                 else
 177                         i_num(R_RDX, 0);
 178         }
 179         op_rr(I_MUL, bt & T_MSIGN ? 7 : 6, r2, LONGSZ);
 180 }
 181
 182 static void i_tst(int rn, int rm)
 183 {
 184         op_rr(I_TST, rn, rm, LONGSZ);
 185 }
 186
 187 static void i_cmp(int rn, int rm)
 188 {
 189         op_rr(I_CMP, rn, rm, LONGSZ);
 190 }
 191
 192 static void i_cmp_imm(int rn, long n)
 193 {
 194         unsigned char s[4] = {0x83, 0xf8 | rn, n & 0xff};
 195         os(s, 3);
 196 }
 197
 198 static void i_shl(int op, int rd, int r1, int rs)
 199 {
 200         long bt = O_T(op);
 201         int sm = 4;
 202         if ((op & 0x0f) == 1)
 203                 sm = bt & T_MSIGN ? 7 : 5;
 204         op_rr(I_SHX, sm, rd, LONGSZ);
 205 }
 206
 207 static void i_shl_imm(int op, int rd, int rn, long n)
 208 {
 209         long bt = O_T(op);
 210         int sm = (op & 0x1) ? (bt & T_MSIGN ? 0xf8 : 0xe8) : 0xe0;
 211         char s[4] = {0xc1, sm | rn, n & 0xff};
 212         os(s, 3);
 213 }
 214
 215 static void i_neg(int rd)
 216 {
 217         op_rr(I_NOT, 3, rd, LONGSZ);
 218 }
 219
 220 static void i_not(int rd)
 221 {
 222         op_rr(I_NOT, 2, rd, LONGSZ);
 223 }
 224
 225 static int i_cond(long op)
 226 {
 227         /* lt, ge, eq, ne, le, gt */
 228         static int ucond[] = {0x92, 0x93, 0x94, 0x95, 0x96, 0x97};
 229         static int scond[] = {0x9c, 0x9d, 0x94, 0x95, 0x9e, 0x9f};
 230         long bt = O_T(op);
 231         return bt & T_MSIGN ? scond[op & 0x0f] : ucond[op & 0x0f];
 232 }
 233
 234 static void i_set(long op, int rd)
 235 {
 236         char set[] = "\x0f\x00\xc0";
 237         set[1] = i_cond(op);
 238         os(set, 3);                     /* setl al */
 239         os("\x0f\xb6\xc0", 3);          /* movzx rax, al */
 240 }
 241
 242 static void i_lnot(int rd)
 243 {
 244         char cmp[] = "\x83\xf8\x00";
 245         cmp[1] |= rd;
 246         os(cmp, 3);             /* cmp rax, 0 */
 247         i_set(O_EQ, rd);
 248 }
 249
 250 static void jx(int x, int nbytes)
 251 {
 252         char op[2] = {0x0f};
 253         if (nbytes == 1) {
 254                 oi(0x70 | (x & 0x0f), 1);       /* jx $addr */
 255         } else {
 256                 op[1] = x;
 257                 os(op, 2);                      /* jx $addr */
 258         }
 259 }
 260
 261 static long i_jmp(long op, long rn, long rm, int nbytes)
 262 {
 263         long ret;
 264         if (nbytes > 1)
 265                 nbytes = 4;
 266         if (op & (O_JZ | O_JCC)) {
 267                 if (op & O_JZ) {
 268                         i_tst(rn, rn);
 269                         jx(O_C(op) == O_JZ ? 0x84 : 0x85, nbytes);
 270                 } else {
 271                         if (op & O_NUM)
 272                                 i_cmp_imm(rn, rm);
 273                         else
 274                                 i_cmp(rn, rm);
 275                         jx(i_cond(op) & ~0x10, nbytes);
 276                 }
 277         } else {
 278                 os(nbytes == 1 ? "\xeb" : "\xe9", 1);   /* jmp $addr */
 279         }
 280         ret = opos();
 281         oi(0, nbytes);
 282         return ret;
 283 }
 284
 285 static void i_zx(int rd, int r1, int bits)
 286 {
 287         if (bits & 0x07) {
 288                 i_shl_imm(O_SHL, rd, rd, LONGSZ * 8 - bits);
 289                 i_shl_imm(O_SHR, rd, rd, LONGSZ * 8 - bits);
 290         } else {
 291                 mov_r2r(rd, r1, bits >> 3);
 292         }
 293 }
 294
 295 static void i_sx(int rd, int r1, int bits)
 296 {
 297         mov_r2r(rd, r1, T_MSIGN | (bits >> 3));
 298 }
 299
 300 static void i_cast(int rd, int rn, int bt)
 301 {
 302         if (T_SZ(bt) == 8) {
 303                 if (rd != rn)
 304                         i_mov(rd, rn);
 305         } else {
 306                 if (bt & T_MSIGN)
 307                         i_sx(rd, rn, T_SZ(bt) * 8);
 308                 else
 309                         i_zx(rd, rn, T_SZ(bt) * 8);
 310         }
 311 }
 312
 313 static void i_add_anyimm(int rd, int rn, long n)
 314 {
 315         op_rm(I_LEA, rd, rn, n, LONGSZ);
 316 }
 317
 318 static long *rel_sym;           /* relocation symbols */
 319 static long *rel_flg;           /* relocation flags */
 320 static long *rel_off;           /* relocation offsets */
 321 static long rel_n, rel_sz;      /* relocation count */
 322
 323 static long lab_sz;             /* label count */
 324 static long *lab_loc;           /* label offsets in cs */
 325 static long jmp_n, jmp_sz;      /* jump count */
 326 static long *jmp_off;           /* jump offsets */
 327 static long *jmp_dst;           /* jump destinations */
 328 static long jmp_ret;            /* the position of the last return jmp */
 329
 330 static void lab_add(long id)
 331 {
 332         while (id >= lab_sz) {
 333                 int lab_n = lab_sz;
 334                 lab_sz = MAX(128, lab_sz * 2);
 335                 lab_loc = mextend(lab_loc, lab_n, lab_sz, sizeof(*lab_loc));
 336         }
 337         lab_loc[id] = opos();
 338 }
 339
 340 static void jmp_add(long off, long dst)
 341 {
 342         if (jmp_n == jmp_sz) {
 343                 jmp_sz = MAX(128, jmp_sz * 2);
 344                 jmp_off = mextend(jmp_off, jmp_n, jmp_sz, sizeof(*jmp_off));
 345                 jmp_dst = mextend(jmp_dst, jmp_n, jmp_sz, sizeof(*jmp_dst));
 346         }
 347         jmp_off[jmp_n] = off;
 348         jmp_dst[jmp_n] = dst;
 349         jmp_n++;
 350 }
 351
 352 void i_label(long id)
 353 {
 354         lab_add(id + 1);
 355 }
 356
 357 static void i_rel(long sym, long flg, long off)
 358 {
 359         if (rel_n == rel_sz) {
 360                 rel_sz = MAX(128, rel_sz * 2);
 361                 rel_sym = mextend(rel_sym, rel_n, rel_sz, sizeof(*rel_sym));
 362                 rel_flg = mextend(rel_flg, rel_n, rel_sz, sizeof(*rel_flg));
 363                 rel_off = mextend(rel_off, rel_n, rel_sz, sizeof(*rel_off));
 364         }
 365         rel_sym[rel_n] = sym;
 366         rel_flg[rel_n] = flg;
 367         rel_off[rel_n] = off;
 368         rel_n++;
 369 }
 370
 371 static void i_sym(int rd, int sym, int off)
 372 {
 373         op_x(I_MOVIR + (rd & 7), 0, rd, LONGSZ);
 374         i_rel(sym, OUT_CS, opos());
 375         oi(off, LONGSZ);
 376 }
 377
 378 static void i_saveregs(long sregs, long sregs_pos, int st)
 379 {
 380         int nsregs = 0;
 381         int i;
 382         for (i = 0; i < N_TMPS; i++)
 383                 if ((1 << tmpregs[i]) & sregs)
 384                         op_rm(st ? I_MOV : I_MOVR, tmpregs[i], REG_FP,
 385                                 sregs_pos + nsregs++ * ULNG, ULNG);
 386 }
 387
 388 void i_wrap(int argc, long sargs, long spsub, int initfp, long sregs, long sregs_pos)
 389 {
 390         long body_n;
 391         void *body;
 392         long diff;              /* prologue length */
 393         int i;
 394         /* removing the last jmp to the epilogue */
 395         if (jmp_ret + 5 == opos()) {
 396                 mem_cut(&cs, jmp_ret);
 397                 jmp_n--;
 398         }
 399         lab_add(0);                             /* the return label */
 400         body_n = mem_len(&cs);
 401         body = mem_get(&cs);
 402         /* generating function prologue */
 403         if (initfp) {
 404                 os("\x55", 1);                  /* push rbp */
 405                 os("\x89\xe5", 2);              /* mov rbp, rsp */
 406         }
 407         if (spsub) {
 408                 os("\x81\xec", 2);
 409                 spsub = ALIGN(spsub, 8);
 410                 oi(spsub, 4);
 411         }
 412         i_saveregs(sregs, sregs_pos, 1);        /* saving registers */
 413         diff = mem_len(&cs);
 414         mem_put(&cs, body, body_n);
 415         free(body);
 416         /* generating function epilogue */
 417         i_saveregs(sregs, sregs_pos, 0);        /* restoring saved registers */
 418         if (initfp)
 419                 os("\xc9", 1);                  /* leave */
 420         os("\xc3", 1);                          /* ret */
 421         /* adjusting code offsets */
 422         for (i = 0; i < rel_n; i++)
 423                 rel_off[i] += diff;
 424         for (i = 0; i < jmp_n; i++)
 425                 jmp_off[i] += diff;
 426         for (i = 0; i < lab_sz; i++)
 427                 lab_loc[i] += diff;
 428 }
 429
 430 void i_code(char **c, long *c_len, long **rsym, long **rflg, long **roff, long *rcnt)
 431 {
 432         int i;
 433         for (i = 0; i < jmp_n; i++)     /* filling jmp destinations */
 434                 oi_at(jmp_off[i], lab_loc[jmp_dst[i]] - jmp_off[i] - 4, 4);
 435         *c_len = mem_len(&cs);
 436         *c = mem_get(&cs);
 437         *rsym = rel_sym;
 438         *rflg = rel_flg;
 439         *roff = rel_off;
 440         *rcnt = rel_n;
 441         rel_sym = NULL;
 442         rel_flg = NULL;
 443         rel_off = NULL;
 444         rel_n = 0;
 445         rel_sz = 0;
 446         jmp_n = 0;
 447 }
 448
 449 void i_done(void)
 450 {
 451         free(jmp_off);
 452         free(jmp_dst);
 453         free(lab_loc);
 454 }
 455
 456 long i_reg(long op, long *rd, long *r1, long *r2, long *r3, long *tmp)
 457 {
 458         long oc = O_C(op);
 459         long bt = O_T(op);
 460         *rd = 0;
 461         *r1 = 0;
 462         *r2 = 0;
 463         *r3 = 0;
 464         *tmp = 0;
 465         if (oc & O_MOV) {
 466                 *rd = R_TMPS;
 467                 if (oc & (O_NUM | O_SYM))
 468                         *r1 = oc & (O_NUM | O_SYM) ? LONGSZ * 8 : R_TMPS;
 469                 else
 470                         *r1 = T_SZ(bt) == 1 ? R_BYTE : R_TMPS;
 471                 return 0;
 472         }
 473         if (oc & O_ADD) {
 474                 *r1 = R_TMPS;
 475                 *r2 = oc & O_NUM ? (oc == O_ADD ? 32 : 8) : R_TMPS;
 476                 return 0;
 477         }
 478         if (oc & O_SHL) {
 479                 if (oc & O_NUM) {
 480                         *r1 = R_TMPS;
 481                         *r2 = 8;
 482                 } else {
 483                         *r2 = 1 << R_RCX;
 484                         *r1 = R_TMPS & ~*r2;
 485                 }
 486                 return 0;
 487         }
 488         if (oc & O_MUL) {
 489                 if (oc & O_NUM)
 490                         return 1;
 491                 *rd = oc == O_MOD ? (1 << R_RDX) : (1 << R_RAX);
 492                 *r1 = (1 << R_RAX);
 493                 *r2 = R_TMPS & ~*rd & ~*r1;
 494                 if (oc == O_DIV)
 495                         *r2 &= ~(1 << R_RDX);
 496                 *tmp = (1 << R_RDX) | (1 << R_RAX);
 497                 return 0;
 498         }
 499         if (oc & O_CMP) {
 500                 *rd = 1 << R_RAX;
 501                 *r1 = R_TMPS;
 502                 *r2 = oc & O_NUM ? 8 : R_TMPS;
 503                 return 0;
 504         }
 505         if (oc & O_UOP) {
 506                 if (oc == O_LNOT)
 507                         *r1 = 1 << R_RAX;
 508                 else
 509                         *r1 = R_TMPS;
 510                 return 0;
 511         }
 512         if (oc == O_MSET) {
 513                 *r1 = 1 << R_RDI;
 514                 *r2 = 1 << R_RAX;
 515                 *r3 = 1 << R_RCX;
 516                 *tmp = (1 << R_RDI) | (1 << R_RCX);
 517                 return 0;
 518         }
 519         if (oc == O_MCPY) {
 520                 *r1 = 1 << R_RDI;
 521                 *r2 = 1 << R_RSI;
 522                 *r3 = 1 << R_RCX;
 523                 *tmp = (1 << R_RDI) | (1 << R_RSI) | (1 << R_RCX);
 524                 return 0;
 525         }
 526         if (oc == O_RET) {
 527                 *r1 = (1 << REG_RET);
 528                 return 0;
 529         }
 530         if (oc & O_CALL) {
 531                 *rd = (1 << REG_RET);
 532                 *r1 = oc & O_SYM ? 0 : R_TMPS;
 533                 *tmp = R_TMPS & ~R_PERM;
 534                 return 0;
 535         }
 536         if (oc & O_LD) {
 537                 *rd = T_SZ(bt) == 1 ? R_BYTE : R_TMPS;
 538                 *r1 = R_TMPS;
 539                 *r2 = oc & O_NUM ? 0 : R_TMPS;
 540                 return 0;
 541         }
 542         if (oc & O_ST) {
 543                 *r1 = T_SZ(bt) == 1 ? R_BYTE : R_TMPS;
 544                 *r2 = R_TMPS;
 545                 *r3 = oc & O_NUM ? 0 : R_TMPS;
 546                 return 0;
 547         }
 548         if (oc & O_JZ) {
 549                 *r1 = R_TMPS;
 550                 return 0;
 551         }
 552         if (oc & O_JCC) {
 553                 *r1 = R_TMPS;
 554                 *r2 = oc & O_NUM ? 8 : R_TMPS;
 555                 return 0;
 556         }
 557         if (oc == O_JMP)
 558                 return 0;
 559         return 1;
 560 }
 561
 562 int i_imm(long lim, long n)
 563 {
 564         long max = (1 << (lim - 1)) - 1;
 565         return n <= max && n + 1 >= -max;
 566 }
 567
 568 long i_ins(long op, long rd, long r1, long r2, long r3)
 569 {
 570         long oc = O_C(op);
 571         long bt = O_T(op);
 572         if (oc & O_ADD) {
 573                 if (oc & O_NUM) {
 574                         if (rd == r1 && r2 <= 127 && r2 >= -128)
 575                                 i_add_imm(op, r1, r1, r2);
 576                         else
 577                                 i_add_anyimm(rd, r1, r2);
 578                 } else {
 579                         i_add(op, r1, r1, r2);
 580                 }
 581         }
 582         if (oc & O_SHL) {
 583                 if (oc & O_NUM)
 584                         i_shl_imm(op, r1, r1, r2);
 585                 else
 586                         i_shl(op, r1, r1, r2);
 587         }
 588         if (oc & O_MUL) {
 589                 if (oc == O_MUL)
 590                         i_mul(R_RAX, r1, r2);
 591                 if (oc == O_DIV)
 592                         i_div(op, R_RAX, r1, r2);
 593                 if (oc == O_MOD)
 594                         i_div(op, R_RDX, r1, r2);
 595                 return 0;
 596         }
 597         if (oc & O_CMP) {
 598                 if (oc & O_NUM)
 599                         i_cmp_imm(r1, r2);
 600                 else
 601                         i_cmp(r1, r2);
 602                 i_set(op, rd);
 603                 return 0;
 604         }
 605         if (oc & O_UOP) {       /* uop */
 606                 if (oc == O_NEG)
 607                         i_neg(r1);
 608                 if (oc == O_NOT)
 609                         i_not(r1);
 610                 if (oc == O_LNOT)
 611                         i_lnot(r1);
 612                 return 0;
 613         }
 614         if (oc == O_CALL) {
 615                 op_rr(I_CALL, 2, r1, LONGSZ);
 616                 return 0;
 617         }
 618         if (oc == (O_CALL | O_SYM)) {
 619                 os("\xe8", 1);          /* call $x */
 620                 i_rel(r1, OUT_CS | OUT_RLREL, opos());
 621                 oi(-4, 4);
 622                 return 0;
 623         }
 624         if (oc == (O_MOV | O_SYM)) {
 625                 i_sym(rd, r1, r2);
 626                 return 0;
 627         }
 628         if (oc == (O_MOV | O_NUM)) {
 629                 i_num(rd, r1);
 630                 return 0;
 631         }
 632         if (oc == O_MSET) {
 633                 os("\xfc\xf3\xaa", 3);          /* cld; rep stosb */
 634                 return 0;
 635         }
 636         if (oc == O_MCPY) {
 637                 os("\xfc\xf3\xa4", 3);          /* cld; rep movs */
 638                 return 0;
 639         }
 640         if (oc == O_RET) {
 641                 jmp_ret = opos();
 642                 jmp_add(i_jmp(O_JMP, 0, 0, 4), 0);
 643                 return 0;
 644         }
 645         if (oc == (O_LD | O_NUM)) {
 646                 op_rm(movrx_op(bt, I_MOVR), rd, r1, r2, movrx_bt(bt));
 647                 return 0;
 648         }
 649         if (oc == (O_ST | O_NUM)) {
 650                 op_rm(I_MOV, r1, r2, r3, bt);
 651                 return 0;
 652         }
 653         if (oc == O_MOV) {
 654                 i_cast(rd, r1, bt);
 655                 return 0;
 656         }
 657         if (oc & O_JXX) {
 658                 jmp_add(i_jmp(op, r1, r2, 4), r3 + 1);
 659                 return 0;
 660         }
 661         return 1;
 662 }