arm.c

   1 #include <string.h>
   2 #include "tok.h"
   3 #include "gen.h"
   4 #include "out.h"
   5
   6 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
   7 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
   8 #define oi4(i)                  oi((i), 4)
   9
  10 #define REG_DP          10      /* data pointer register */
  11 #define REG_TMP         12      /* temporary register */
  12 #define REG_LR          14      /* link register */
  13 #define REG_PC          15      /* program counter */
  14
  15 #define I_AND           0x00
  16 #define I_EOR           0x01
  17 #define I_SUB           0x02
  18 #define I_RSB           0x03
  19 #define I_ADD           0x04
  20 #define I_TST           0x08
  21 #define I_CMP           0x0a
  22 #define I_ORR           0x0c
  23 #define I_MOV           0x0d
  24 #define I_MVN           0x0f
  25
  26 int tmpregs[] = {4, 5, 6, 7, 8, 9, 3, 2, 1, 0};
  27 int argregs[] = {0, 1, 2, 3};
  28
  29 /* compiled division functions; div.s contains the source */
  30 static int udivdi3[] = {
  31         0xe3a02000, 0xe3a03000, 0xe1110001, 0x0a00000a,
  32         0xe1b0c211, 0xe2822001, 0x5afffffc, 0xe3a0c001,
  33         0xe2522001, 0x4a000004, 0xe1500211, 0x3afffffb,
  34         0xe0400211, 0xe083321c, 0xeafffff8, 0xe1a01000,
  35         0xe1a00003, 0xe1a0f00e,
  36 };
  37 static int umoddi3[] = {
  38         0xe92d4000, 0xebffffeb, 0xe1a00001, 0xe8bd8000,
  39 };
  40 static int divdi3[] = {
  41         0xe92d4030, 0xe1a04000, 0xe1a05001, 0xe1100000,
  42         0x42600000, 0xe1110001, 0x42611000, 0xebffffe1,
  43         0xe1340005, 0x42600000, 0xe1140004, 0x42611000,
  44         0xe8bd8030,
  45 };
  46 static int moddi3[] = {
  47         0xe92d4000, 0xebfffff0, 0xe1a00001, 0xe8bd8000,
  48 };
  49
  50 /* output div/mod functions */
  51 static int putdiv = 0;
  52
  53 static void insert_spsub(void);
  54
  55 static void i_div(char *func)
  56 {
  57         putdiv = 1;
  58         insert_spsub();
  59         i_call(func, 0);
  60 }
  61
  62 void i_done(void)
  63 {
  64         if (putdiv) {
  65                 out_sym("__udivdi3", OUT_CS, cslen, 0);
  66                 os(udivdi3, sizeof(udivdi3));
  67                 out_sym("__umoddi3", OUT_CS, cslen, 0);
  68                 os(umoddi3, sizeof(umoddi3));
  69                 out_sym("__divdi3", OUT_CS, cslen, 0);
  70                 os(divdi3, sizeof(divdi3));
  71                 out_sym("__moddi3", OUT_CS, cslen, 0);
  72                 os(moddi3, sizeof(moddi3));
  73         }
  74 }
  75
  76 /* for optimizing cmp + bcc */
  77 #define OPT_ISCMP()             (last_cmp + 12 == cslen && last_set + 4 == cslen)
  78 #define OPT_CCOND()             (*(unsigned int *) ((void *) cs + last_set) >> 28)
  79
  80 static long last_cmp = -1;
  81 static long last_set = -1;
  82
  83 /* data pool */
  84 static long num_offs[NNUMS];            /* data immediate value */
  85 static char num_names[NNUMS][NAMELEN];  /* relocation data symbol name */
  86 static int nums;
  87
  88 static int pool_find(char *name, int off)
  89 {
  90         int i;
  91         for (i = 0; i < nums; i++)
  92                 if (!strcmp(name, num_names[i]) && off == num_offs[i])
  93                         return i;
  94         return -1;
  95 }
  96
  97 static int pool_num(long num)
  98 {
  99         int idx = pool_find("", num);
 100         if (idx < 0) {
 101                 idx = nums++;
 102                 num_offs[idx] = num;
 103                 num_names[idx][0] = '\0';
 104         }
 105         return idx << 2;
 106 }
 107
 108 static int pool_reloc(char *name, long off)
 109 {
 110         int idx = pool_find(name, off);
 111         if (idx < 0) {
 112                 idx = nums++;
 113                 num_offs[idx] = off;
 114                 strcpy(num_names[idx], name);
 115         }
 116         return idx << 2;
 117 }
 118
 119 static void pool_write(void)
 120 {
 121         int i;
 122         for (i = 0; i < nums; i++) {
 123                 if (num_names[i] && !pass1)
 124                         out_rel(num_names[i], OUT_CS, cslen);
 125                 oi4(num_offs[i]);
 126         }
 127 }
 128
 129 /*
 130  * data processing:
 131  * +---------------------------------------+
 132  * |COND|00|I| op |S| Rn | Rd |  operand2  |
 133  * +---------------------------------------+
 134  *
 135  * S: set condition code
 136  * Rn: first operand
 137  * Rd: destination operand
 138  *
 139  * I=0 operand2=| shift  | Rm |
 140  * I=1 operand2=|rota|  imm   |
 141  */
 142 #define ADD(op, rd, rn, s, i, cond)     \
 143         (((cond) << 28) | ((i) << 25) | ((s) << 20) | \
 144                 ((op) << 21) | ((rn) << 16) | ((rd) << 12))
 145
 146 static int add_encimm(unsigned n)
 147 {
 148         int i = 0;
 149         while (i < 12 && (n >> ((4 + i) << 1)))
 150                 i++;
 151         return (n >> (i << 1)) | (((16 - i) & 0x0f) << 8);
 152 }
 153
 154 static unsigned add_decimm(int n)
 155 {
 156         int rot = (16 - ((n >> 8) & 0x0f)) & 0x0f;
 157         return (n & 0xff) << (rot << 1);
 158 }
 159
 160 static int add_rndimm(unsigned n)
 161 {
 162         int rot = (n >> 8) & 0x0f;
 163         int num = n & 0xff;
 164         if (rot == 0)
 165                 return n;
 166         if (num == 0xff) {
 167                 num = 0;
 168                 rot = (rot + 12) & 0x0f;
 169         }
 170         return ((num + 1) & 0xff) | (rot << 8);
 171 }
 172
 173 static int opcode_add(int op)
 174 {
 175         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 176         static int rx[] = {I_ADD, I_SUB, I_AND, I_ORR, I_EOR};
 177         return rx[op & 0x0f];
 178 }
 179
 180 static void i_add(int op, int rd, int rn, int rm)
 181 {
 182         oi4(ADD(opcode_add(op), rd, rn, 0, 0, 14) | rm);
 183 }
 184
 185 int i_imm(int op, long imm)
 186 {
 187         return (op & 0xf0) != 0x20 && add_decimm(add_encimm(imm)) == imm;
 188 }
 189
 190 static void i_add_imm(int op, int rd, int rn, long n)
 191 {
 192         oi4(ADD(opcode_add(op), rd, rn, 0, 1, 14) | add_encimm(n));
 193 }
 194
 195 static void i_ldr(int l, int rd, int rn, int off, int bt);
 196
 197 void i_num(int rd, long n)
 198 {
 199         int enc = add_encimm(n);
 200         if (n == add_decimm(enc)) {
 201                 oi4(ADD(I_MOV, rd, 0, 0, 1, 14) | enc);
 202                 return;
 203         }
 204         enc = add_encimm(-n - 1);
 205         if (~n == add_decimm(enc)) {
 206                 oi4(ADD(I_MVN, rd, 0, 0, 1, 14) | enc);
 207                 return;
 208         }
 209         i_ldr(1, rd, REG_DP, pool_num(n), LONGSZ);
 210 }
 211
 212 static void i_add_anyimm(int rd, int rn, long n)
 213 {
 214         int neg = n < 0;
 215         int imm = add_encimm(neg ? -n : n);
 216         if (imm == add_decimm(neg ? -n : n)) {
 217                 oi4(ADD(neg ? I_SUB : I_ADD, rd, rn, 0, 1, 14) | imm);
 218         } else {
 219                 i_num(rd, n);
 220                 i_add(O_ADD, rd, rd, rn);
 221         }
 222 }
 223
 224 /*
 225  * multiply
 226  * +----------------------------------------+
 227  * |COND|000000|A|S| Rd | Rn | Rs |1001| Rm |
 228  * +----------------------------------------+
 229  *
 230  * Rd: destination
 231  * A: accumulate
 232  * C: set condition codes
 233  *
 234  * I=0 operand2=| shift  | Rm |
 235  * I=1 operand2=|rota|  imm   |
 236  */
 237 #define MUL(rd, rn, rs)         \
 238         ((14 << 28) | ((rd) << 16) | ((0) << 12) | ((rn) << 8) | ((9) << 4) | (rm))
 239
 240 static void i_mul(int rd, int rn, int rm)
 241 {
 242         oi4(MUL(rd, rn, rm));
 243 }
 244
 245 static int opcode_set(int op)
 246 {
 247         /* lt, gt, le, ge, eq, neq */
 248         static int ucond[] = {3, 8, 9, 2, 0, 1};
 249         static int scond[] = {11, 12, 13, 10, 0, 1};
 250         return op & O_SIGNED ? scond[op & 0x0f] : ucond[op & 0x0f];
 251 }
 252
 253 static void i_tst(int rn, int rm)
 254 {
 255         oi4(ADD(I_TST, 0, rn, 1, 0, 14) | rm);
 256 }
 257
 258 static void i_cmp(int rn, int rm)
 259 {
 260         last_cmp = cslen;
 261         oi4(ADD(I_CMP, 0, rn, 1, 0, 14) | rm);
 262 }
 263
 264 static void i_cmp_imm(int rn, long n)
 265 {
 266         last_cmp = cslen;
 267         oi4(ADD(I_CMP, 0, rn, 1, 1, 14) | add_encimm(n));
 268 }
 269
 270 static void i_set(int cond, int rd)
 271 {
 272         oi4(ADD(I_MOV, rd, 0, 0, 1, 14));
 273         last_set = cslen;
 274         oi4(ADD(I_MOV, rd, 0, 0, 1, opcode_set(cond)) | 1);
 275 }
 276
 277 #define SM_LSL          0
 278 #define SM_LSR          1
 279 #define SM_ASR          2
 280
 281 static int opcode_shl(int op)
 282 {
 283         if (op & 0x0f)
 284                 return op & O_SIGNED ? SM_ASR : SM_LSR;
 285         return SM_LSL;
 286 }
 287
 288 static void i_shl(int op, int rd, int rm, int rs)
 289 {
 290         int sm = opcode_shl(op);
 291         oi4(ADD(I_MOV, rd, 0, 0, 0, 14) | (rs << 8) | (sm << 5) | (1 << 4) | rm);
 292 }
 293
 294 static void i_shl_imm(int op, int rd, int rn, long n)
 295 {
 296         int sm = opcode_shl(op);
 297         oi4(ADD(I_MOV, rd, 0, 0, 0, 14) | (n << 7) | (sm << 5) | rn);
 298 }
 299
 300 void i_mov(int rd, int rn)
 301 {
 302         oi4(ADD(I_MOV, rd, 0, 0, 0, 14) | rn);
 303 }
 304
 305 /*
 306  * single data transfer:
 307  * +------------------------------------------+
 308  * |COND|01|I|P|U|B|W|L| Rn | Rd |   offset   |
 309  * +------------------------------------------+
 310  *
 311  * I: immediate/offset
 312  * P: post/pre indexing
 313  * U: down/up
 314  * B: byte/word
 315  * W: writeback
 316  * L: store/load
 317  * Rn: base register
 318  * Rd: source/destination register
 319  *
 320  * I=0 offset=| immediate |
 321  * I=1 offset=| shift  | Rm |
 322  *
 323  * halfword and signed data transfer
 324  * +----------------------------------------------+
 325  * |COND|000|P|U|0|W|L| Rn | Rd |0000|1|S|H|1| Rm |
 326  * +----------------------------------------------+
 327  *
 328  * +----------------------------------------------+
 329  * |COND|000|P|U|1|W|L| Rn | Rd |off1|1|S|H|1|off2|
 330  * +----------------------------------------------+
 331  *
 332  * S: singed
 333  * H: halfword
 334  */
 335 #define LDR(l, rd, rn, b, u, p, w)              \
 336         ((14 << 28) | (1 << 26) | ((p) << 24) | ((b) << 22) | ((u) << 23) | \
 337         ((w) << 21) | ((l) << 20) | ((rn) << 16) | ((rd) << 12))
 338 #define LDRH(l, rd, rn, s, h, u, i)     \
 339         ((14 << 28) | (1 << 24) | ((u) << 23) | ((i) << 22) | ((l) << 20) | \
 340         ((rn) << 16) | ((rd) << 12) | ((s) << 6) | ((h) << 5) | (9 << 4))
 341
 342 static void i_ldr(int l, int rd, int rn, int off, int bt)
 343 {
 344         int b = BT_SZ(bt) == 1;
 345         int h = BT_SZ(bt) == 2;
 346         int s = l && (bt & BT_SIGNED);
 347         int half = h || (b && s);
 348         int maximm = half ? 0x100 : 0x1000;
 349         int neg = off < 0;
 350         if (neg)
 351                 off = -off;
 352         while (off >= maximm) {
 353                 int imm = add_encimm(off);
 354                 oi4(ADD(neg ? I_SUB : I_ADD, REG_TMP, rn, 0, 1, 14) | imm);
 355                 rn = REG_TMP;
 356                 off -= add_decimm(imm);
 357         }
 358         if (!half)
 359                 oi4(LDR(l, rd, rn, b, !neg, 1, 0) | off);
 360         else
 361                 oi4(LDRH(l, rd, rn, s, h, !neg, 1) |
 362                         ((off & 0xf0) << 4) | (off & 0x0f));
 363 }
 364
 365 void i_load(int rd, int rn, int off, int bt)
 366 {
 367         i_ldr(1, rd, rn, off, bt);
 368 }
 369
 370 void i_save(int rd, int rn, int off, int bt)
 371 {
 372         i_ldr(0, rd, rn, off, bt);
 373 }
 374
 375 void i_sym(int rd, char *sym, int off)
 376 {
 377         int doff = pool_reloc(sym, off);
 378         i_ldr(1, rd, REG_DP, doff, LONGSZ);
 379 }
 380
 381 static void i_neg(int rd, int r1)
 382 {
 383         oi4(ADD(I_RSB, rd, r1, 0, 1, 14));
 384 }
 385
 386 static void i_not(int rd, int r1)
 387 {
 388         oi4(ADD(I_MVN, rd, 0, 0, 0, 14) | r1);
 389 }
 390
 391 static int cond_nots[] = {1, 0, 3, 2, -1, -1, -1, -1, 9, 8, 11, 10, 13, 12, -1};
 392
 393 static void i_lnot(int rd, int r1)
 394 {
 395         if (OPT_ISCMP()) {
 396                 unsigned int *lset = (void *) cs + last_set;
 397                 int cond = cond_nots[OPT_CCOND()];
 398                 *lset = (*lset & 0x0fffffff) | (cond << 28);
 399                 return;
 400         }
 401         i_tst(r1, r1);
 402         i_set(O_EQ, rd);
 403 }
 404
 405 /* rd = rd & ((1 << bits) - 1) */
 406 static void i_zx(int rd, int r1, int bits)
 407 {
 408         if (bits <= 8) {
 409                 oi4(ADD(I_AND, rd, r1, 0, 1, 14) | add_encimm((1 << bits) - 1));
 410         } else {
 411                 i_shl_imm(O_SHL, rd, r1, 32 - bits);
 412                 i_shl_imm(O_SHR, rd, rd, 32 - bits);
 413         }
 414 }
 415
 416 static void i_sx(int rd, int r1, int bits)
 417 {
 418         i_shl_imm(O_SHL, rd, r1, 32 - bits);
 419         i_shl_imm(O_SIGNED | O_SHR, rd, rd, 32 - bits);
 420 }
 421
 422 /*
 423  * branch:
 424  * +-----------------------------------+
 425  * |COND|101|L|         offset         |
 426  * +-----------------------------------+
 427  *
 428  * L: link
 429  */
 430 #define BL(cond, l, o)  (((cond) << 28) | (5 << 25) | ((l) << 24) | \
 431                                 ((((o) - 8) >> 2) & 0x00ffffff))
 432 void i_jmp(int rn, int jc, int nbytes)
 433 {
 434         if (!nbytes)
 435                 return;
 436         if (rn < 0) {
 437                 oi4(BL(14, 0, 0));
 438                 return;
 439         }
 440         if (OPT_ISCMP()) {
 441                 int cond = OPT_CCOND();
 442                 cslen = last_cmp + 4;
 443                 last_set = -1;
 444                 oi4(BL(jc ? cond_nots[cond] : cond, 0, 0));
 445                 return;
 446         }
 447         i_tst(rn, rn);
 448         oi4(BL(jc ? 0 : 1, 0, 0));
 449 }
 450
 451 long i_fill(long src, long dst, int nbytes)
 452 {
 453         long *d = (void *) cs + src - 4;
 454         if (!nbytes)
 455                 return 0;
 456         *d = (*d & 0xff000000) | (((dst - src - 4) >> 2) & 0x00ffffff);
 457         return dst - src;
 458 }
 459
 460 void i_memcpy(int rd, int rs, int rn)
 461 {
 462         oi4(ADD(I_SUB, rn, rn, 1, 1, 14) | 1);
 463         oi4(BL(4, 0, 16));
 464         oi4(LDR(1, REG_TMP, rs, 1, 1, 0, 0) | 1);
 465         oi4(LDR(0, REG_TMP, rd, 1, 1, 0, 0) | 1);
 466         oi4(BL(14, 0, -16));
 467 }
 468
 469 void i_memset(int rd, int rs, int rn)
 470 {
 471         oi4(ADD(I_SUB, rn, rn, 1, 1, 14) | 1);
 472         oi4(BL(4, 0, 12));
 473         oi4(LDR(0, rs, rd, 1, 1, 0, 0) | 1);
 474         oi4(BL(14, 0, -12));
 475 }
 476
 477 void i_call_reg(int rd)
 478 {
 479         i_mov(REG_LR, REG_PC);
 480         i_mov(REG_PC, rd);
 481 }
 482
 483 void i_call(char *sym, int off)
 484 {
 485         if (!pass1)
 486                 out_rel(sym, OUT_CS | OUT_RLREL | OUT_RL24, cslen);
 487         oi4(BL(14, 1, off));
 488 }
 489
 490 void i_reg(int op, int *rd, int *r1, int *r2, int *tmp)
 491 {
 492         *rd = R_TMPS;
 493         *r1 = R_TMPS;
 494         *r2 = (op & O_IMM || (op & 0xf0) == 0x40) ? 0 : R_TMPS;
 495         *tmp = 0;
 496         if ((op & 0xff) == O_DIV || (op & 0xff) == O_MOD) {
 497                 *rd = 1 << REG_RET;
 498                 *r1 = 1 << argregs[0];
 499                 *r2 = 1 << argregs[1];
 500                 *tmp = R_TMPS & ~R_SAVED;
 501         }
 502 }
 503
 504 void i_op(int op, int rd, int r1, int r2)
 505 {
 506         if ((op & 0xf0) == 0x00)
 507                 i_add(op, rd, r1, r2);
 508         if ((op & 0xf0) == 0x10)
 509                 i_shl(op, rd, r1, r2);
 510         if ((op & 0xf0) == 0x20) {
 511                 if ((op & 0xff) == O_MUL)
 512                         i_mul(rd, r1, r2);
 513                 if ((op & 0xff) == O_DIV)
 514                         i_div(op & O_SIGNED ? "__divdi3" : "__udivdi3");
 515                 if ((op & 0xff) == O_MOD)
 516                         i_div(op & O_SIGNED ? "__moddi3" : "__umoddi3");
 517                 return;
 518         }
 519         if ((op & 0xf0) == 0x30) {
 520                 i_cmp(r1, r2);
 521                 i_set(op, rd);
 522                 return;
 523         }
 524         if ((op & 0xf0) == 0x40) {      /* uop */
 525                 if ((op & 0xff) == O_NEG)
 526                         i_neg(rd, r1);
 527                 if ((op & 0xff) == O_NOT)
 528                         i_not(rd, r1);
 529                 if ((op & 0xff) == O_LNOT)
 530                         i_lnot(rd, r1);
 531                 return;
 532         }
 533 }
 534
 535 void i_op_imm(int op, int rd, int r1, long n)
 536 {
 537         if ((op & 0xf0) == 0x00) {
 538                 if (i_imm(O_ADD, n))
 539                         i_add_imm(op, rd, r1, n);
 540                 else
 541                         i_add_anyimm(rd, r1, n);
 542         }
 543         if ((op & 0xf0) == 0x10)        /* shl */
 544                 i_shl_imm(op, rd, r1, n);
 545         if ((op & 0xf0) == 0x30) {      /* imm */
 546                 i_cmp_imm(r1, n);
 547                 i_set(op, rd);
 548         }
 549         if ((op & 0xf0) == 0x50) {      /* etc */
 550                 if ((op & 0xff) == O_ZX)
 551                         i_zx(rd, r1, n);
 552                 if ((op & 0xff) == O_SX)
 553                         i_sx(rd, r1, n);
 554                 if ((op & 0xff) == O_MOV)
 555                         i_mov(rd, r1);
 556         }
 557 }
 558
 559 static int func_argc;
 560 static int func_varg;
 561 static int func_spsub;
 562 static int func_sargs;
 563 static int func_sregs;
 564 static int func_initfp;
 565 static int func_initdp = 1;
 566 static int spsub_addr;
 567 static int dpadd_addr;
 568
 569 static int saved_regs(int args)
 570 {
 571         int n = 2;
 572         int i;
 573         for (i = 0; i < N_REGS; i++) {
 574                 if ((1 << i) & func_sregs)
 575                         n++;
 576                 if (args && (1 << i) & func_sargs)
 577                         n++;
 578         }
 579         return n;
 580 }
 581
 582 int i_args(void)
 583 {
 584         return saved_regs(0) * LONGSZ;
 585 }
 586
 587 int i_sp(void)
 588 {
 589         return 0;
 590 }
 591
 592 static int plain_function(void)
 593 {
 594         return !func_initfp && !func_spsub && !func_initdp && !func_varg &&
 595                 !func_sargs && !func_sregs && func_argc <= N_ARGS;
 596 }
 597
 598 static void insert_spsub(void)
 599 {
 600         if (!func_spsub) {
 601                 func_spsub = 1;
 602                 spsub_addr = cslen;
 603                 oi4(0xe24dd000);        /* sub   sp, sp, xx */
 604         }
 605 }
 606
 607 void i_prolog(int argc, int varg, int sargs, int sregs, int initfp, int spsub)
 608 {
 609         last_set = -1;
 610         nums = 0;
 611         func_argc = argc;
 612         func_varg = varg;
 613         func_sargs = sargs;
 614         func_sregs = sregs;
 615         func_initfp = initfp;
 616         func_spsub = 0;
 617         if (plain_function())
 618                 return;
 619         if (initfp)
 620                 func_sregs |= 1 << REG_FP;
 621         if (func_initdp)
 622                 func_sregs |= 1 << REG_DP;
 623         /* stack should remain 8-aligned */
 624         if (saved_regs(1) & 0x1)
 625                 func_sregs |= 8;
 626         oi4(0xe1a0c00d);                        /* mov   r12, sp */
 627         if (func_sargs)
 628                 oi4(0xe92d0000 | func_sargs);   /* stmfd sp!, {r0-r3} */
 629         oi4(0xe92d5000 | func_sregs);           /* stmfd sp!, {r0-r11, r12, lr} */
 630         if (func_initfp)
 631                 oi4(0xe1a0b00d);                /* mov   fp, sp */
 632         if (spsub)
 633                 insert_spsub();
 634         if (func_initdp) {
 635                 dpadd_addr = cslen;
 636                 oi4(0xe28fa000);                /* add   dp, pc, xx */
 637         }
 638 }
 639
 640 void i_epilog(int sp_max)
 641 {
 642         sp_max = -sp_max;
 643         if (plain_function()) {
 644                 oi4(0xe1a0f00e);                /* mov   pc, lr */
 645                 return;
 646         }
 647         if (func_initfp)
 648                 oi4(0xe89ba000 | func_sregs);/* ldmfd fp, {r4-r11, sp, pc} */
 649         if (!func_initfp)
 650                 oi4(0xe89da000 | func_sregs);/* ldmfd sp, {r4-r11, sp, pc} */
 651         if (func_initdp) {
 652                 int dpoff = cslen - dpadd_addr - 8;
 653                 dpoff = add_decimm(add_rndimm(add_encimm(dpoff)));
 654                 cslen = dpadd_addr + dpoff + 8;
 655                 /* fill data ptr addition: dp = pc + xx */
 656                 *(long *) (cs + dpadd_addr) |= add_encimm(dpoff);
 657         }
 658         if (func_initfp && func_spsub) {
 659                 sp_max = ALIGN(sp_max, 8);
 660                 sp_max = add_decimm(add_rndimm(add_encimm(sp_max)));
 661                 /* fill stack sub: sp = sp - xx */
 662                 *(long *) (cs + spsub_addr) |= add_encimm(sp_max);
 663         }
 664         pool_write();
 665 }