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