--- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7a/a.h Fri Mar 6 19:59:01 2026 @@ -0,0 +1,185 @@ +/* + * arm64 + */ +#include +#include +#include +#include "../7c/7.out.h" + +#ifndef EXTERN +#define EXTERN extern +#endif + +typedef vlong int64; + +typedef struct Sym Sym; +typedef struct Gen Gen; +typedef struct Io Io; +typedef struct Hist Hist; + +#define MAXALIGN 7 +#define FPCHIP 1 +#define NSYMB 8192 +#define BUFSIZ IOUNIT +#define HISTSZ 20 +#define NINCLUDE 10 +#define NHUNK 10000 +#define EOF (-1) +#define IGN (-2) +#define GETC() ((--fi.c < 0)? filbuf(): *fi.p++ & 0xff) +#define NHASH 503 +#define STRINGSZ 200 +#define NMACRO 10 + +struct Sym +{ + Sym* link; + char* macro; + long value; + ushort type; + char *name; + char sym; +}; +#define S ((Sym*)0) + +EXTERN struct +{ + char* p; + int c; +} fi; + +struct Io +{ + Io* link; + char b[BUFSIZ]; + char* p; + short c; + short f; +}; +#define I ((Io*)0) + +EXTERN struct +{ + Sym* sym; + short type; +} h[NSYM]; + +struct Gen +{ + Sym* sym; + int64 offset; + short type; + short reg; + short xreg; + short name; + short ext; + double dval; + char sval[NSNAME]; +}; + +struct Hist +{ + Hist* link; + char* name; + long line; + long offset; +}; +#define H ((Hist*)0) + +enum +{ + CLAST, + CMACARG, + CMACRO, + CPREPROC, +}; + +EXTERN char debug[256]; +EXTERN Sym* hash[NHASH]; +EXTERN char* Dlist[30]; +EXTERN int nDlist; +EXTERN Hist* ehist; +EXTERN int newflag; +EXTERN Hist* hist; +EXTERN char* hunk; +EXTERN char* include[NINCLUDE]; +EXTERN Io* iofree; +EXTERN Io* ionext; +EXTERN Io* iostack; +EXTERN long lineno; +EXTERN int nerrors; +EXTERN long nhunk; +EXTERN int ninclude; +EXTERN Gen nullgen; +EXTERN char* outfile; +EXTERN int pass; +EXTERN char* pathname; +EXTERN long pc; +EXTERN int peekc; +EXTERN int sym; +EXTERN char symb[NSYMB]; +EXTERN int thechar; +EXTERN char* thestring; +EXTERN long thunk; +EXTERN Biobuf obuf; + +void* alloc(long); +void* allocn(void*, long, long); +void errorexit(void); +void pushio(void); +void newio(void); +void newfile(char*, int); +Sym* slookup(char*); +Sym* lookup(void); +void syminit(Sym*); +long yylex(void); +int getc(void); +int getnsc(void); +void unget(int); +int escchar(int); +void cinit(void); +void pinit(char*); +void cclean(void); +void outcode(int, Gen*, int, Gen*); +void outcodec(int, int, Gen*, int, Gen*); +void outcode4(int, Gen*, int, Gen*, Gen*); +void zname(char*, int, int); +void zaddr(Gen*, int); +void ieeedtod(Ieee*, double); +int filbuf(void); +Sym* getsym(void); +void domacro(void); +void macund(void); +void macdef(void); +void macexpand(Sym*, char*); +void macinc(void); +void maclin(void); +void macprag(void); +void macif(int); +void macend(void); +void outhist(void); +void dodefine(char*); +void prfile(long); +void linehist(char*, int); +void gethunk(void); +void yyerror(char*, ...); +int yyparse(void); +void setinclude(char*); +int assemble(char*); + +/* + * system-dependent stuff from ../cc/compat.c + */ + +enum /* keep in synch with ../cc/cc.h */ +{ + Plan9 = 1<<0, + Unix = 1<<1, + Windows = 1<<2, +}; +int mywait(int*); +int mycreat(char*, int); +int systemtype(int); +int pathchar(void); +int myfork(void); +void* mysbrk(ulong); --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7a/a.y Mon Dec 2 14:06:55 2024 @@ -0,0 +1,880 @@ +%{ +#include "a.h" +%} +%union +{ + Sym *sym; + vlong lval; + double dval; + char sval[NSNAME]; + Gen gen; +} +%left '|' +%left '^' +%left '&' +%left '<' '>' +%left '+' '-' +%left '*' '/' '%' +%token LTYPE0 LTYPE1 LTYPE2 LTYPE3 LTYPE4 LTYPE5 +%token LTYPE6 LTYPE7 LTYPE8 LTYPE9 LTYPEA +%token LTYPEB LTYPEC LTYPED LTYPEE LTYPEF +%token LTYPEG LTYPEH LTYPEI LTYPEJ LTYPEK +%token LTYPEL LTYPEM LTYPEN LTYPEO LTYPEP LTYPEQ +%token LTYPER LTYPES LTYPET LTYPEU LTYPEV LTYPEW LTYPEX LTYPEY LTYPEZ +%token LMOVK LDMB LSTXR +%token LCONST LSP LSB LFP LPC +%token LR LREG LF LFREG LV LVREG LC LCREG LFCR LFCSEL +%token LCOND LS LAT LEXT LSPR LSPREG LVTYPE +%token LFCONST +%token LSCONST +%token LNAME LLAB LVAR +%type con expr pointer offset sreg spreg +%type scon indexreg vset vreglist +%type gen rel reg freg vreg shift fcon frcon extreg vlane vgen +%type imm ximm name oreg nireg ioreg imsr spr cond sysarg +%% +prog: +| prog line + +line: + LLAB ':' + { + if($1->value != pc) + yyerror("redeclaration of %s", $1->name); + $1->value = pc; + } + line +| LNAME ':' + { + $1->type = LLAB; + $1->value = pc; + } + line +| LNAME '=' expr ';' + { + $1->type = LVAR; + $1->value = $3; + } +| LVAR '=' expr ';' + { + if($1->value != $3) + yyerror("redeclaration of %s", $1->name); + $1->value = $3; + } +| ';' +| inst ';' +| error ';' + +inst: +/* + * ERET + */ + LTYPE0 comma + { + outcode($1, &nullgen, NREG, &nullgen); + } +/* + * ADD + */ +| LTYPE1 imsr ',' spreg ',' reg + { + outcode($1, &$2, $4, &$6); + } +| LTYPE1 imsr ',' spreg ',' + { + outcode($1, &$2, $4, &nullgen); + } +| LTYPE1 imsr ',' reg + { + outcode($1, &$2, NREG, &$4); + } +/* + * CLS + */ +| LTYPE2 imsr ',' reg + { + outcode($1, &$2, NREG, &$4); + } +/* + * MOV + */ +| LTYPE3 gen ',' gen + { + outcode($1, &$2, NREG, &$4); + } +/* + * MOVK + */ +| LMOVK imm ',' reg + { + outcode($1, &$2, NREG, &$4); + } +| LMOVK imm '<' '<' con ',' reg + { + Gen g; + g = nullgen; + g.type = D_CONST; + g.offset = $5; + outcode4($1, &$2, NREG, &g, &$7); + } +/* + * B/BL + */ +| LTYPE4 comma rel + { + outcode($1, &nullgen, NREG, &$3); + } +| LTYPE4 comma nireg + { + outcode($1, &nullgen, NREG, &$3); + } +/* + * BEQ + */ +| LTYPE5 comma rel + { + outcode($1, &nullgen, NREG, &$3); + } +/* + * SVC + */ +| LTYPE6 comma gen + { + outcode($1, &nullgen, NREG, &$3); + } +| LTYPE6 + { + outcode($1, &nullgen, NREG, &nullgen); + } +/* + * CMP + */ +| LTYPE7 imsr ',' spreg comma + { + outcode($1, &$2, $4, &nullgen); + } +/* + * CBZ + */ +| LTYPE8 reg ',' rel + { + outcode($1, &$2, NREG, &$4); + } +/* + * CSET + */ +| LTYPER cond ',' reg + { + outcode($1, &$2, NREG, &$4); + } +/* + * CSEL/CINC/CNEG/CINV + */ +| LTYPES cond ',' reg ',' reg ',' reg + { + outcode4($1, &$2, $6.reg, &$4, &$8); + } +| LTYPES cond ',' reg ',' reg + { + outcode($1, &$2, $4.reg, &$6); + } +/* + * TBZ + */ +| LTYPET imm ',' reg ',' rel + { + outcode($1, &$2, $4.reg, &$6); + } +/* + * CCMN + */ +| LTYPEU cond ',' imsr ',' reg ',' imm comma + { + outcode4($1, &$2, $6.reg, &$4, &$8); + } +/* + * ADR + */ +| LTYPEV rel ',' reg + { + outcode($1, &$2, NREG, &$4); + } +| LTYPEV '$' name ',' reg + { + outcode($1, &$3, NREG, &$5); + } +/* + * BFM/BFI + */ +| LTYPEY imm ',' imm ',' spreg ',' reg + { + outcode4($1, &$2, $6, &$4, &$8); + } +/* + * EXTR + */ +| LTYPEP imm ',' reg ',' spreg ',' reg + { + outcode4($1, &$2, $6, &$4, &$8); + } +/* + * RET/RETURN + */ +| LTYPEA comma + { + outcode($1, &nullgen, NREG, &nullgen); + } +| LTYPEA reg + { + outcode($1, &nullgen, NREG, &$2); + } +/* + * NOP + */ +| LTYPEQ comma + { + outcode($1, &nullgen, NREG, &nullgen); + } +| LTYPEQ reg comma + { + outcode($1, &$2, NREG, &nullgen); + } +| LTYPEQ freg comma + { + outcode($1, &$2, NREG, &nullgen); + } +| LTYPEQ ',' reg + { + outcode($1, &nullgen, NREG, &$3); + } +| LTYPEQ ',' freg + { + outcode($1, &nullgen, NREG, &$3); + } +/* + * TEXT/GLOBL + */ +| LTYPEB name ',' imm + { + outcode($1, &$2, NREG, &$4); + } +| LTYPEB name ',' con ',' imm + { + outcode($1, &$2, $4, &$6); + } +/* + * DATA + */ +| LTYPEC name '/' con ',' ximm + { + outcode($1, &$2, $4, &$6); + } +/* + * CASE + */ +| LTYPED reg ',' reg + { + outcode($1, &$2, NREG, &$4); + } +/* + * word + */ +| LTYPEH comma ximm + { + outcode($1, &nullgen, NREG, &$3); + } +/* + * floating-point + */ +| LTYPEI freg ',' freg + { + outcode($1, &$2, NREG, &$4); + } +/* + * FADDD + */ +| LTYPEK frcon ',' freg + { + outcode($1, &$2, NREG, &$4); + } +| LTYPEK frcon ',' freg ',' freg + { + outcode($1, &$2, $4.reg, &$6); + } +/* + * FCMP + */ +| LTYPEL frcon ',' freg comma + { + outcode($1, &$2, $4.reg, &nullgen); + } +/* + * FCCMP + */ +| LTYPEF cond ',' freg ',' freg ',' imm comma + { + outcode4($1, &$2, $6.reg, &$4, &$8); + } +/* + * FMULA + */ +| LTYPE9 freg ',' freg ', ' freg ',' freg comma + { + outcode4($1, &$2, $4.reg, &$6, &$8); + } +/* + * FCSEL + */ +| LFCSEL cond ',' freg ',' freg ',' freg + { + outcode4($1, &$2, $6.reg, &$4, &$8); + } +/* + * SIMD + */ +| LTYPEW vgen ',' vgen + { + outcode($1, &$2, NREG, &$4); + } +| LTYPEW vgen ',' vgen ',' vgen + { + outcode($1, &$2, $4.reg, &$6); + } +/* + * MOVP/MOVNP + */ +| LTYPEJ gen ',' sreg ',' gen + { + outcode($1, &$2, $4, &$6); + } +/* + * MADD Rn,Rm,Ra,Rd + */ +| LTYPEM reg ',' reg ',' sreg ',' reg + { + outcode4($1, &$2, $6, &$4, &$8); + } +/* + * SYS/SYSL + */ +| LTYPEN sysarg + { + outcode($1, &$2, NREG, &nullgen); + } +| LTYPEN reg ',' sysarg + { + outcode($1, &$4, $2.reg, &nullgen); + } +| LTYPEO sysarg ',' reg + { + outcode($1, &$2, NREG, &$4); + } +/* + * DMB, HINT + */ +| LDMB imm + { + outcode($1, &$2, NREG, &nullgen); + } +/* + * STXR + */ +| LSTXR reg ',' gen ',' sreg + { + outcode($1, &$2, $6, &$4); + } +/* + * END + */ +| LTYPEE comma + { + outcode($1, &nullgen, NREG, &nullgen); + } + +cond: + LCOND + { + $$ = nullgen; + $$.type = D_COND; + $$.reg = $1; + } + +comma: +| ',' comma + +sysarg: + con ',' con ',' con ',' con + { + $$ = nullgen; + $$.type = D_CONST; + $$.offset = SYSARG4($1, $3, $5, $7); + } +| imm + +rel: + con '(' LPC ')' + { + $$ = nullgen; + $$.type = D_BRANCH; + $$.offset = $1 + pc; + } +| LNAME offset + { + $$ = nullgen; + if(pass == 2) + yyerror("undefined label: %s", $1->name); + $$.type = D_BRANCH; + $$.sym = $1; + $$.offset = $2; + } +| LLAB offset + { + $$ = nullgen; + $$.type = D_BRANCH; + $$.sym = $1; + $$.offset = $1->value + $2; + } + +ximm: '$' con + { + $$ = nullgen; + $$.type = D_CONST; + $$.offset = $2; + } +| '$' oreg + { + $$ = $2; + $$.type = D_CONST; + } +| '$' '*' '$' oreg + { + $$ = $4; + $$.type = D_OCONST; + } +| '$' LSCONST + { + $$ = nullgen; + $$.type = D_SCONST; + memmove($$.sval, $2, sizeof($$.sval)); + } +| fcon + +fcon: + '$' LFCONST + { + $$ = nullgen; + $$.type = D_FCONST; + $$.dval = $2; + } +| '$' '-' LFCONST + { + $$ = nullgen; + $$.type = D_FCONST; + $$.dval = -$3; + } + +gen: + reg +| ximm +| LFCR + { + $$ = nullgen; + $$.type = D_SPR; + $$.offset = $1; + } +| con + { + $$ = nullgen; + $$.type = D_OREG; + $$.offset = $1; + } +| oreg +| freg +| vreg +| spr + +nireg: + '(' sreg ')' + { + $$ = nullgen; + $$.type = D_OREG; + $$.reg = $2; + $$.offset = 0; + } +| name + { + $$ = $1; + if($1.name != D_EXTERN && $1.name != D_STATIC) { + } + } + +oreg: + name +| name '(' sreg ')' + { + $$ = $1; + $$.type = D_OREG; + $$.reg = $3; + } +| ioreg + +ioreg: + '(' sreg ')' + { + $$ = nullgen; + $$.type = D_OREG; + $$.reg = $2; + $$.offset = 0; + } +| con '(' sreg ')' + { + $$ = nullgen; + $$.type = D_OREG; + $$.reg = $3; + $$.offset = $1; + } +| con '(' sreg ')' '!' + { + $$ = nullgen; + $$.type = D_XPRE; + $$.reg = $3; + $$.offset = $1; + } +| '(' sreg ')' con '!' + { + $$ = nullgen; + $$.type = D_XPOST; + $$.reg = $2; + $$.offset = $4; + } +| '(' sreg ')' '(' indexreg ')' + { + $$ = nullgen; + $$.type = D_ROFF; + $$.reg = $2; + $$.xreg = $5 & 0x1f; + $$.offset = $5; + } +| '(' sreg ')' '[' indexreg ']' + { + $$ = nullgen; + $$.type = D_ROFF; + $$.reg = $2; + $$.xreg = $5 & 0x1f; + $$.offset = $5 | (1<<16); + } + +imsr: + imm +| shift +| extreg + +imm: '$' con + { + $$ = nullgen; + $$.type = D_CONST; + $$.offset = $2; + } + +reg: + sreg + { + $$ = nullgen; + $$.type = D_REG; + $$.reg = $1; + } +| LSP + { + $$ = nullgen; + $$.type = D_SP; + $$.reg = REGSP; + } + +shift: + sreg '<' '<' scon + { + $$ = nullgen; + $$.type = D_SHIFT; + $$.offset = ($1 << 16) | ($4 << 10) | (0 << 22); + } +| sreg '>' '>' scon + { + $$ = nullgen; + $$.type = D_SHIFT; + $$.offset = (($1&0x1F) << 16) | ($4 << 10) | (1 << 22); + } +| sreg '-' '>' scon + { + $$ = nullgen; + $$.type = D_SHIFT; + $$.offset = ($1 << 16) | ($4 << 10) | (2 << 22); + } +| sreg LAT '>' scon + { + $$ = nullgen; + $$.type = D_SHIFT; + $$.offset = ($1 << 16) | ($4 << 10) | (3 << 22); + } + +extreg: + sreg + { + $$ = nullgen; + $$.type = D_REG; + $$.reg = $1; + } +| sreg LEXT + { + $$ = nullgen; + $$.type = D_EXTREG; + $$.reg = $1; + $$.offset = ($1 << 16) | ($2 << 13); + } +| sreg LEXT '<' '<' con + { + if($5 < 0 || $5 > 4) + yyerror("shift value out of range"); + $$ = nullgen; + $$.type = D_EXTREG; + $$.reg = $1; + $$.offset = ($1 << 16) | ($2 << 13) | ($5 << 10); + } + +indexreg: + sreg + { + $$ = (3 << 8) | $1; + } +| sreg LEXT + { + $$ = ($2 << 8) | $1; + } + +scon: + con + { + if($$ < 0 || $$ >= 64) + yyerror("shift value out of range"); + $$ = $1&0x3F; + } + +sreg: + LREG +| LR '(' expr ')' + { + if($3 < 0 || $3 >= NREG) + print("register value out of range\n"); + $$ = $3; + } + +spreg: + sreg +| LSP + { + $$ = REGSP; + } + +spr: + LSPREG + { + $$ = nullgen; + $$.type = D_SPR; + $$.offset = $1; + } +| LSPR '(' con ')' + { + $$ = nullgen; + $$.type = $1; + $$.offset = $3; + } + +frcon: + freg +| fcon + +freg: + LFREG + { + $$ = nullgen; + $$.type = D_FREG; + $$.reg = $1; + } +| LF '(' con ')' + { + $$ = nullgen; + $$.type = D_FREG; + $$.reg = $3; + } + +vgen: + oreg +| vreg +| vlane +| vset + { + $$ = nullgen; + $$.type = D_VSET; + $$.offset = $1; + } + +vlane: + vreg '[' con ']' + { + $$.type = D_VLANE; + $$.offset = $3; + } +| vset '[' con ']' + { + $$.type = D_VLANE; + $$.offset = $3; + } + +vset: + '{' vreglist '}' + { + $$ = $2; + } + +vreglist: + vreg + { + $$ = 1 << $1.reg; + } +| vreg '-' vreg + { + int i; + $$=0; + for(i=$1.reg; i<=$3.reg; i++) + $$ |= 1<' offset '(' LSB ')' + { + $$ = nullgen; + $$.type = D_OREG; + $$.name = D_STATIC; + $$.sym = $1; + $$.offset = $4; + } + +offset: + { + $$ = 0; + } +| '+' con + { + $$ = $2; + } +| '-' con + { + $$ = -$2; + } + +pointer: + LSB +| LSP +| LFP + +con: + LCONST +| LVAR + { + $$ = $1->value; + } +| '-' con + { + $$ = -$2; + } +| '+' con + { + $$ = $2; + } +| '~' con + { + $$ = ~$2; + } +| '(' expr ')' + { + $$ = $2; + } + +expr: + con +| expr '+' expr + { + $$ = $1 + $3; + } +| expr '-' expr + { + $$ = $1 - $3; + } +| expr '*' expr + { + $$ = $1 * $3; + } +| expr '/' expr + { + $$ = $1 / $3; + } +| expr '%' expr + { + $$ = $1 % $3; + } +| expr '<' '<' expr + { + $$ = $1 << $4; + } +| expr '>' '>' expr + { + $$ = $1 >> $4; + } +| expr '&' expr + { + $$ = $1 & $3; + } +| expr '^' expr + { + $$ = $1 ^ $3; + } +| expr '|' expr + { + $$ = $1 | $3; + } --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7a/lex.c Tue Dec 30 17:28:54 2025 @@ -0,0 +1,1018 @@ +#define EXTERN +#include "a.h" +#include "y.tab.h" +#include + +void +main(int argc, char *argv[]) +{ + char *p; + int nout, nproc, status, i, c; + + thechar = '7'; + thestring = "arm64"; + memset(debug, 0, sizeof(debug)); + cinit(); + outfile = 0; + include[ninclude++] = "."; + ARGBEGIN { + default: + c = ARGC(); + if(c >= 0 || c < sizeof(debug)) + debug[c] = 1; + break; + + case 'o': + outfile = ARGF(); + break; + + case 'D': + p = ARGF(); + if(p) + Dlist[nDlist++] = p; + break; + + case 'I': + p = ARGF(); + setinclude(p); + break; + } ARGEND + if(*argv == 0) { + print("usage: %Ca [-options] file.s\n", thechar); + errorexit(); + } + if(argc > 1 && systemtype(Windows)){ + print("can't assemble multiple files on windows\n"); + errorexit(); + } + if(argc > 1 && !systemtype(Windows)) { + nproc = 1; + if(p = getenv("NPROC")) + nproc = atol(p); /* */ + c = 0; + nout = 0; + for(;;) { + while(nout < nproc && argc > 0) { + i = myfork(); + if(i < 0) { + i = mywait(&status); + if(i < 0) + errorexit(); + if(status) + c++; + nout--; + continue; + } + if(i == 0) { + print("%s:\n", *argv); + if(assemble(*argv)) + errorexit(); + exits(0); + } + nout++; + argc--; + argv++; + } + i = mywait(&status); + if(i < 0) { + if(c) + errorexit(); + exits(0); + } + if(status) + c++; + nout--; + } + } + if(assemble(argv[0])) + errorexit(); + exits(0); +} + +int +assemble(char *file) +{ + char *ofile, *p; + int i, of; + + ofile = strdup(file); + p = utfrrune(ofile, pathchar()); + if(p) { + include[0] = ofile; + *p++ = 0; + } else + p = ofile; + if(outfile == 0) { + if(p){ + outfile = p; + p = utfrrune(outfile, '.'); + if(p) + if(p[1] == 's' && p[2] == 0) + p[0] = 0; + outfile = smprint("%s.%C", outfile, thechar); + } else + outfile = "/dev/null"; + } + p = getenv("INCLUDE"); + if(p) { + setinclude(p); + } else { + if(systemtype(Plan9)) + setinclude(smprint("/%s/include", thestring)); + } + + of = mycreat(outfile, 0664); + if(of < 0) { + yyerror("%Ca: cannot create %s", thechar, outfile); + errorexit(); + } + Binit(&obuf, of, OWRITE); + + pass = 1; + pinit(file); + for(i=0; ivalue != 0) + yyerror("internal: duplicate %s", s->name); + s->type = itab[i].type; + s->value = itab[i].value; + } + + pathname = allocn(pathname, 0, 100); + if(getwd(pathname, 99) == 0) { + pathname = allocn(pathname, 100, 900); + if(getwd(pathname, 999) == 0) + strcpy(pathname, "/???"); + } +} + +void +syminit(Sym *s) +{ + + s->type = LNAME; + s->value = 0; +} + +void +cclean(void) +{ + + outcode(AEND, &nullgen, NREG, &nullgen); + Bflush(&obuf); +} + +void +zname(char *n, int t, int s) +{ + + Bputc(&obuf, ANAME); + Bputc(&obuf, ANAME>>8); + Bputc(&obuf, t); /* type */ + Bputc(&obuf, s); /* sym */ + while(*n) { + Bputc(&obuf, *n); + n++; + } + Bputc(&obuf, 0); +} + +void +zaddr(Gen *a, int s) +{ + long l; + int i; + char *n; + Ieee e; + + if(a->type == D_CONST){ + l = a->offset; + if((vlong)l != a->offset) + a->type = D_DCONST; + } + Bputc(&obuf, a->type); + Bputc(&obuf, a->reg); + Bputc(&obuf, s); + Bputc(&obuf, a->name); + switch(a->type) { + default: + print("unknown type %d\n", a->type); + exits("arg"); + + case D_NONE: + case D_REG: + case D_SP: + case D_FREG: + case D_VREG: + case D_COND: + break; + + case D_DCONST: + l = a->offset; + Bputc(&obuf, l); + Bputc(&obuf, l>>8); + Bputc(&obuf, l>>16); + Bputc(&obuf, l>>24); + l = a->offset>>32; + Bputc(&obuf, l); + Bputc(&obuf, l>>8); + Bputc(&obuf, l>>16); + Bputc(&obuf, l>>24); + break; + + case D_OREG: + case D_XPRE: + case D_XPOST: + case D_CONST: + case D_BRANCH: + case D_SHIFT: + case D_EXTREG: + case D_ROFF: + case D_SPR: + l = a->offset; + Bputc(&obuf, l); + Bputc(&obuf, l>>8); + Bputc(&obuf, l>>16); + Bputc(&obuf, l>>24); + break; + + case D_SCONST: + n = a->sval; + for(i=0; idval); + Bputc(&obuf, e.l); + Bputc(&obuf, e.l>>8); + Bputc(&obuf, e.l>>16); + Bputc(&obuf, e.l>>24); + Bputc(&obuf, e.h); + Bputc(&obuf, e.h>>8); + Bputc(&obuf, e.h>>16); + Bputc(&obuf, e.h>>24); + break; + } +} + +static int +outsim(Gen *g) +{ + Sym *s; + int sno, t; + + s = g->sym; + if(s == S) + return 0; + sno = s->sym; + if(sno < 0 || sno >= NSYM) + sno = 0; + t = g->name; + if(h[sno].type == t && h[sno].sym == s) + return sno; + zname(s->name, t, sym); + s->sym = sym; + h[sym].sym = s; + h[sym].type = t; + sno = sym; + sym++; + if(sym >= NSYM) + sym = 1; + return sno; +} + +void +outcode(int a, Gen *g1, int reg, Gen *g2) +{ + int sf, st; + + if(a != AGLOBL && a != ADATA) + pc++; + if(pass == 1) + return; + do{ + sf = outsim(g1); + st = outsim(g2); + } while(sf != 0 && st == sf); + Bputc(&obuf, a); + Bputc(&obuf, a>>8); + Bputc(&obuf, reg); + Bputc(&obuf, lineno); + Bputc(&obuf, lineno>>8); + Bputc(&obuf, lineno>>16); + Bputc(&obuf, lineno>>24); + zaddr(g1, sf); + zaddr(g2, st); +} + +void +outcode4(int a, Gen *g1, int reg, Gen *g2, Gen *g3) +{ + int s1, s2, s3, flag; + + if(a != AGLOBL && a != ADATA) + pc++; + if(pass == 1) + return; + do{ + s1 = outsim(g1); + s2 = outsim(g2); + s3 = outsim(g3); + } while(s1 && (s2 && s1 == s2 || s3 && s1 == s3) || s2 && (s3 && s2 == s3)); + flag = 0; + if(g2->type != D_NONE) + flag = 0x40; /* flags extra operand */ + Bputc(&obuf, a); + Bputc(&obuf, a>>8); + Bputc(&obuf, reg | flag); + Bputc(&obuf, lineno); + Bputc(&obuf, lineno>>8); + Bputc(&obuf, lineno>>16); + Bputc(&obuf, lineno>>24); + zaddr(g1, s1); + if(flag) + zaddr(g2, s2); + zaddr(g3, s3); +} + +void +outhist(void) +{ + Gen g; + Hist *h; + char *p, *q, *op, c; + int n; + + g = nullgen; + c = pathchar(); + for(h = hist; h != H; h = h->link) { + p = h->name; + op = 0; + /* on windows skip drive specifier in pathname */ + if(systemtype(Windows) && p && p[1] == ':'){ + p += 2; + c = *p; + } + if(p && p[0] != c && h->offset == 0 && pathname){ + /* on windows skip drive specifier in pathname */ + if(systemtype(Windows) && pathname[1] == ':') { + op = p; + p = pathname+2; + c = *p; + } else if(pathname[0] == c){ + op = p; + p = pathname; + } + } + while(p) { + q = strchr(p, c); + if(q) { + n = q-p; + if(n == 0){ + n = 1; /* leading "/" */ + *p = '/'; /* don't emit "\" on windows */ + } + q++; + } else { + n = strlen(p); + q = 0; + } + if(n) { + Bputc(&obuf, ANAME); + Bputc(&obuf, ANAME>>8); + Bputc(&obuf, D_FILE); /* type */ + Bputc(&obuf, 1); /* sym */ + Bputc(&obuf, '<'); + Bwrite(&obuf, p, n); + Bputc(&obuf, 0); + } + p = q; + if(p == 0 && op) { + p = op; + op = 0; + } + } + g.offset = h->offset; + + Bputc(&obuf, AHISTORY); + Bputc(&obuf, AHISTORY>>8); + Bputc(&obuf, 0); + Bputc(&obuf, h->line); + Bputc(&obuf, h->line>>8); + Bputc(&obuf, h->line>>16); + Bputc(&obuf, h->line>>24); + zaddr(&nullgen, 0); + zaddr(&g, 0); + } +} + +#include "../cc/lexbody" +#include "../cc/macbody" +#include "../cc/compat" --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7a/mkfile Fri Mar 6 19:46:12 2026 @@ -0,0 +1,21 @@ +type == T) + return; + if(typesu[n->type->etype]) { + sugen(n, nn, n->type->width); + return; + } + l = n->left; + r = n->right; + o = n->op; + if(n->addable >= INDEXED) { + if(nn == Z) { + switch(o) { + default: + nullwarn(Z, Z); + break; + case OINDEX: + nullwarn(l, r); + break; + } + return; + } + gmove(n, nn); + return; + } + curs = cursafe; + + if(n->complex >= FNX) + if(l->complex >= FNX) + if(r != Z && r->complex >= FNX) + switch(o) { + default: + if(cond(o) && typesu[l->type->etype]) + break; + + regret(&nod, r); + cgen(r, &nod); + + regsalloc(&nod1, r); + gopcode(OAS, &nod, Z, &nod1); + + regfree(&nod); + nod = *n; + nod.right = &nod1; + cgen(&nod, nn); + return; + + case OFUNC: + case OCOMMA: + case OANDAND: + case OOROR: + case OCOND: + case ODOT: + break; + } + + switch(o) { + default: + diag(n, "unknown op in cgen: %O", o); + break; + + case ONEG: + case OCOM: + if(nn == Z) { + nullwarn(l, Z); + break; + } + regalloc(&nod, l, nn); + cgen(l, &nod); + gopcode(o, &nod, Z, &nod); + gmove(&nod, nn); + regfree(&nod); + break; + + case OAS: + if(l->op == OBIT) + goto bitas; + if(l->addable >= INDEXED && l->complex < FNX) { + if(nn != Z || r->addable < INDEXED) { /* || hardconst(r) */ + if(r->complex >= FNX && nn == Z) + regret(&nod, r); + else + regalloc(&nod, r, nn); + cgen(r, &nod); + gmove(&nod, l); + if(nn != Z) + gmove(&nod, nn); + regfree(&nod); + } else + gmove(r, l); + break; + } + if(l->complex >= r->complex) { + /* TO DO: see 6c for OINDEX && immconst(r) */ + reglcgen(&nod1, l, Z); + if(r->addable >= INDEXED) { /* && !hardconst(r) */ + gmove(r, &nod1); + if(nn != Z) + gmove(r, nn); + regfree(&nod1); + break; + } + regalloc(&nod, r, nn); + cgen(r, &nod); + } else { + regalloc(&nod, r, nn); + cgen(r, &nod); + reglcgen(&nod1, l, Z); + } + gmove(&nod, &nod1); + if(nn != Z) + gmove(&nod, nn); + regfree(&nod); + regfree(&nod1); + break; + + bitas: + n = l->left; + regalloc(&nod, r, nn); + if(l->complex >= r->complex) { + reglcgen(&nod1, n, Z); + cgen(r, &nod); + } else { + cgen(r, &nod); + reglcgen(&nod1, n, Z); + } + regalloc(&nod2, n, Z); + gopcode(OAS, &nod1, Z, &nod2); + bitstore(l, &nod, &nod1, &nod2, nn); + break; + + case OBIT: + if(nn == Z) { + nullwarn(l, Z); + break; + } + bitload(n, &nod, Z, Z, nn); + gopcode(OAS, &nod, Z, nn); + regfree(&nod); + break; + + case ODIV: + case OMOD: + if(nn != Z) + if((t = vlog(r)) >= 0) { + /* signed div/mod by constant power of 2 */ + cgen(l, nn); + gopcode(OGE, nodconst(0), nn, Z); + p1 = p; + if(o == ODIV) { + gopcode(OADD, nodconst((1<op == OCONST && r->vconst == -1){ + cgen(l, nn); + gopcode(OCOM, nn, Z, nn); + break; + } +#endif + + case OSUB: + case OADD: + case OAND: + case OOR: + //case OROL: + case OLSHR: + case OASHL: + case OASHR: + /* + * immediate operands + */ + if(nn != Z) + if(r->op == OCONST) + if(!typefd[n->type->etype]) { + cgen(l, nn); + if(r->vconst == 0) + if(o != OAND) + break; + if(nn != Z) + gopcode(o, r, Z, nn); + break; + } + + case OLMUL: + case OLDIV: + case OLMOD: + case OMUL: + muldiv: + if(nn == Z) { + nullwarn(l, r); + break; + } + if(o == OMUL || o == OLMUL) { + if(mulcon(n, nn)) + break; + } + if(l->complex >= r->complex) { + regalloc(&nod, l, nn); + cgen(l, &nod); + regalloc(&nod1, l, Z); /* note: l used for type, so shifts work! */ + cgen(r, &nod1); + gopcode(o, &nod1, Z, &nod); + } else { + regalloc(&nod, l, nn); /* note: l used for type, so shifts work! */ + cgen(r, &nod); + regalloc(&nod1, l, Z); + cgen(l, &nod1); + gopcode(o, &nod, &nod1, &nod); + } + gopcode(OAS, &nod, Z, nn); + regfree(&nod); + regfree(&nod1); + break; + + case OASLSHR: + case OASASHL: + case OASASHR: + case OASAND: + case OASADD: + case OASSUB: + case OASXOR: + case OASOR: + if(l->op == OBIT) + goto asbitop; + if(r->op == OCONST) + if(!typefd[r->type->etype]) + if(!typefd[n->type->etype]) { + if(l->addable < INDEXED) + reglcgen(&nod2, l, Z); + else + nod2 = *l; + regalloc(&nod, l, nn); /* note: l used for type, so shifts work! */ + gopcode(OAS, &nod2, Z, &nod); + gopcode(o, r, Z, &nod); + gopcode(OAS, &nod, Z, &nod2); + if(nn != Z) + gmove(&nod, nn); + regfree(&nod); + if(l->addable < INDEXED) + regfree(&nod2); + break; + } + + case OASLMUL: + case OASLDIV: + case OASLMOD: + case OASMUL: + case OASDIV: + case OASMOD: + if(l->op == OBIT) + goto asbitop; + if(l->complex >= r->complex) { + if(l->addable < INDEXED) + reglcgen(&nod2, l, Z); + else + nod2 = *l; + regalloc(&nod1, r, Z); + cgen(r, &nod1); + } else { + regalloc(&nod1, r, Z); + cgen(r, &nod1); + if(l->addable < INDEXED) + reglcgen(&nod2, l, Z); + else + nod2 = *l; + } + if(nod1.type->etype == nod2.type->etype || !typefd[nod1.type->etype]) + regalloc(&nod, &nod2, nn); + else + regalloc(&nod, &nod1, Z); + gopcode(OAS, &nod2, Z, &nod); + if(nod1.type->etype != nod.type->etype){ + regalloc(&nod3, &nod, Z); + gmove(&nod1, &nod3); + regfree(&nod1); + nod1 = nod3; + } + gopcode(o, &nod1, &nod, &nod); + gmove(&nod, &nod2); + if(nn != Z) + gmove(&nod, nn); + regfree(&nod); + regfree(&nod1); + if(l->addable < INDEXED) + regfree(&nod2); + break; + + asbitop: + regalloc(&nod4, n, nn); + regalloc(&nod3, r, Z); + if(l->complex >= r->complex) { + bitload(l, &nod, &nod1, &nod2, &nod4); + cgen(r, &nod3); + } else { + cgen(r, &nod3); + bitload(l, &nod, &nod1, &nod2, &nod4); + } + gmove(&nod, &nod4); + gopcode(o, &nod3, Z, &nod4); + regfree(&nod3); + gmove(&nod4, &nod); + regfree(&nod4); + bitstore(l, &nod, &nod1, &nod2, nn); + break; + + case OADDR: + if(nn == Z) { + nullwarn(l, Z); + break; + } + lcgen(l, nn); + break; + + case OFUNC: + l = uncomma(l); + if(l->complex >= FNX) { + if(l->op != OIND) + diag(n, "bad function call"); + + regret(&nod, l->left); + cgen(l->left, &nod); + regsalloc(&nod1, l->left); + gopcode(OAS, &nod, Z, &nod1); + regfree(&nod); + + nod = *n; + nod.left = &nod2; + nod2 = *l; + nod2.left = &nod1; + nod2.complex = 1; + cgen(&nod, nn); + + return; + } + if(REGARG >= 0) + o = reg[REGARG]; + gargs(r, &nod, &nod1); + if(l->addable < INDEXED) { + reglcgen(&nod, l, Z); + gopcode(OFUNC, Z, Z, &nod); + regfree(&nod); + } else + gopcode(OFUNC, Z, Z, l); + if(REGARG >= 0) + if(o != reg[REGARG]) + reg[REGARG]--; + if(nn != Z) { + regret(&nod, n); + gopcode(OAS, &nod, Z, nn); + regfree(&nod); + } + break; + + case OIND: + if(nn == Z) { + nullwarn(l, Z); + break; + } + regialloc(&nod, n, nn); + r = l; + while(r->op == OADD) + r = r->right; + if(usableoffset(n, nod.xoffset, r)){ + v = r->vconst; + r->vconst = 0; + cgen(l, &nod); + nod.xoffset += v; + r->vconst = v; + } else + cgen(l, &nod); + regind(&nod, n); + gopcode(OAS, &nod, Z, nn); + regfree(&nod); + break; + + case OEQ: + case ONE: + case OLE: + case OLT: + case OGE: + case OGT: + case OLO: + case OLS: + case OHI: + case OHS: + if(nn == Z) { + nullwarn(l, r); + break; + } + boolgen(n, 1, nn); + break; + + case OANDAND: + case OOROR: + boolgen(n, 1, nn); + if(nn == Z) + patch(p, pc); + break; + + case ONOT: + if(nn == Z) { + nullwarn(l, Z); + break; + } + boolgen(n, 1, nn); + break; + + case OCOMMA: + cgen(l, Z); + cgen(r, nn); + break; + + case OCAST: + if(nn == Z) { + cgen(l, Z); + break; + } + /* + * convert from types l->n->nn + */ + if(nocast(l->type, n->type) && nocast(n->type, nn->type)) { + /* both null, gen l->nn */ + cgen(l, nn); + break; + } + if(ewidth[n->type->etype] < ewidth[l->type->etype]){ + if(l->type->etype == TIND && typechlp[n->type->etype]) + warn(n, "conversion of pointer to shorter integer"); + }else if(0){ + if(nocast(n->type, nn->type) || castup(n->type, nn->type)){ + if(typefd[l->type->etype] != typefd[nn->type->etype]) + regalloc(&nod, l, nn); + else + regalloc(&nod, nn, nn); + cgen(l, &nod); + gmove(&nod, nn); + regfree(&nod); + break; + } + } + regalloc(&nod, l, nn); + cgen(l, &nod); + regalloc(&nod1, n, &nod); + if(inrel) + gmover(&nod, &nod1); + else + gopcode(OAS, &nod, Z, &nod1); + gopcode(OAS, &nod1, Z, nn); + regfree(&nod1); + regfree(&nod); + break; + + case ODOT: + regsalloc(&nod, l); + sugen(l, &nod, l->type->width); + if(nn != Z) { + if(!r || r->op != OCONST) { + diag(n, "DOT and no offset"); + break; + } + nod.xoffset += (long)r->vconst; + nod.type = n->type; + cgen(&nod, nn); + } + break; + + case OCOND: + bcgen(l, 1); + p1 = p; + cgen(r->left, nn); + gbranch(OGOTO); + patch(p1, pc); + p1 = p; + cgen(r->right, nn); + patch(p1, pc); + break; + + case OPOSTINC: + case OPOSTDEC: + v = 1; + if(l->type->etype == TIND) + v = l->type->link->width; + if(o == OPOSTDEC) + v = -v; + if(l->op == OBIT) + goto bitinc; + if(nn == Z) + goto pre; + + if(l->addable < INDEXED) + reglcgen(&nod2, l, Z); + else + nod2 = *l; + + regalloc(&nod, l, nn); + gopcode(OAS, &nod2, Z, &nod); + if(nn != Z) + gmove(&nod, nn); + regalloc(&nod1, l, Z); + if(typefd[l->type->etype]) { + regalloc(&nod3, l, Z); + if(v < 0) { + gopcode(OAS, nodfconst(-v), Z, &nod3); + gopcode(OSUB, &nod3, &nod, &nod1); + } else { + gopcode(OAS, nodfconst(v), Z, &nod3); + gopcode(OADD, &nod3, &nod, &nod1); + } + regfree(&nod3); + } else + gopcode(OADD, nodconst(v), &nod, &nod1); + gopcode(OAS, &nod1, Z, &nod2); + + regfree(&nod); + regfree(&nod1); + if(l->addable < INDEXED) + regfree(&nod2); + break; + + case OPREINC: + case OPREDEC: + v = 1; + if(l->type->etype == TIND) + v = l->type->link->width; + if(o == OPREDEC) + v = -v; + if(l->op == OBIT) + goto bitinc; + + pre: + if(l->addable < INDEXED) + reglcgen(&nod2, l, Z); + else + nod2 = *l; + + regalloc(&nod, l, nn); + gopcode(OAS, &nod2, Z, &nod); + if(typefd[l->type->etype]) { + regalloc(&nod3, l, Z); + if(v < 0) { + gopcode(OAS, nodfconst(-v), Z, &nod3); + gopcode(OSUB, &nod3, Z, &nod); + } else { + gopcode(OAS, nodfconst(v), Z, &nod3); + gopcode(OADD, &nod3, Z, &nod); + } + regfree(&nod3); + } else + gopcode(OADD, nodconst(v), Z, &nod); + gopcode(OAS, &nod, Z, &nod2); + if(nn != Z){ + gmove(&nod, nn); + if(l->op == ONAME) /* in x=++i, emit USED(i) */ + gins(ANOP, l, Z); + } + regfree(&nod); + if(l->addable < INDEXED) + regfree(&nod2); + break; + + bitinc: + if(nn != Z && (o == OPOSTINC || o == OPOSTDEC)) { + bitload(l, &nod, &nod1, &nod2, Z); + gopcode(OAS, &nod, Z, nn); + gopcode(OADD, nodconst(v), Z, &nod); + bitstore(l, &nod, &nod1, &nod2, Z); + break; + } + bitload(l, &nod, &nod1, &nod2, nn); + gopcode(OADD, nodconst(v), Z, &nod); + bitstore(l, &nod, &nod1, &nod2, nn); + break; + } + cursafe = curs; + return; +} + +void +reglcgen(Node *t, Node *n, Node *nn) +{ + Node *r; + long v; + + regialloc(t, n, nn); + if(n->op == OIND) { + r = n->left; + while(r->op == OADD) + r = r->right; + if(usableoffset(n, t->xoffset, r)) { + v = r->vconst; + r->vconst = 0; + lcgen(n, t); + t->xoffset += v; + r->vconst = v; + regind(t, n); + return; + } + } else if(n->op == OINDREG) { + if(usableoffset(n, t->xoffset+n->xoffset, nil)) { + Type *tt = n->type; + n->type = types[TIND]; + n->op = OREGISTER; + v = n->xoffset; + n->xoffset = 0; + cgen(n, t); + t->xoffset += v; + n->xoffset = v; + n->op = OINDREG; + n->type = tt; + regind(t, n); + return; + } + } + lcgen(n, t); + regind(t, n); +} + +void +lcgen(Node *n, Node *nn) +{ + Prog *p1; + Node nod; + + if(debug['g']) { + prtree(nn, "lcgen lhs"); + prtree(n, "lcgen"); + } + if(n == Z || n->type == T) + return; + if(nn == Z) { + nn = &nod; + regalloc(&nod, n, Z); + } + switch(n->op) { + default: + if(n->addable < INDEXED) { + diag(n, "unknown op in lcgen: %O", n->op); + break; + } + nod = *n; + nod.op = OADDR; + nod.left = n; + nod.right = Z; + nod.type = types[TIND]; + gopcode(OAS, &nod, Z, nn); + break; + + case OCOMMA: + cgen(n->left, n->left); + lcgen(n->right, nn); + break; + + case OIND: + cgen(n->left, nn); + break; + + case OCOND: + bcgen(n->left, 1); + p1 = p; + lcgen(n->right->left, nn); + gbranch(OGOTO); + patch(p1, pc); + p1 = p; + lcgen(n->right->right, nn); + patch(p1, pc); + break; + } +} + +void +bcgen(Node *n, int true) +{ + + if(n->type == T) + gbranch(OGOTO); + else + boolgen(n, true, Z); +} + +void +boolgen(Node *n, int true, Node *nn) +{ + int o; + Prog *p1, *p2; + Node *l, *r, nod, nod1; + long curs; + + if(debug['g']) { + prtree(nn, "boolgen lhs"); + prtree(n, "boolgen"); + } + curs = cursafe; + l = n->left; + r = n->right; + switch(n->op) { + + default: + regalloc(&nod, n, nn); + cgen(n, &nod); + o = ONE; + if(true) + o = OEQ; + if(typefd[n->type->etype]) { + regalloc(&nod1, n, Z); + gmove(nodfconst(0.0), &nod1); + gopcode(true ? o | BTRUE : o, &nod1, &nod, Z); + regfree(&nod1); + }else + gopcode(o, nodconst(0), &nod, Z); + regfree(&nod); + goto com; + + case OCONST: + o = vconst(n); + if(!true) + o = !o; + gbranch(OGOTO); + if(o) { + p1 = p; + gbranch(OGOTO); + patch(p1, pc); + } + goto com; + + case OCOMMA: + cgen(l, Z); + boolgen(r, true, nn); + break; + + case ONOT: + boolgen(l, !true, nn); + break; + + case OCOND: + bcgen(l, 1); + p1 = p; + bcgen(r->left, true); + p2 = p; + gbranch(OGOTO); + patch(p1, pc); + p1 = p; + bcgen(r->right, !true); + patch(p2, pc); + p2 = p; + gbranch(OGOTO); + patch(p1, pc); + patch(p2, pc); + goto com; + + case OANDAND: + if(!true) + goto caseor; + + caseand: + bcgen(l, true); + p1 = p; + bcgen(r, !true); + p2 = p; + patch(p1, pc); + gbranch(OGOTO); + patch(p2, pc); + goto com; + + case OOROR: + if(!true) + goto caseand; + + caseor: + bcgen(l, !true); + p1 = p; + bcgen(r, !true); + p2 = p; + gbranch(OGOTO); + patch(p1, pc); + patch(p2, pc); + goto com; + + case OEQ: + case ONE: + case OLE: + case OLT: + case OGE: + case OGT: + case OHI: + case OHS: + case OLO: + case OLS: + o = n->op; + if(true) + o = comrel[relindex(o)]; + if(l->complex >= FNX && r->complex >= FNX) { + regret(&nod, r); + cgenrel(r, &nod, 1); + regsalloc(&nod1, r); + gopcode(OAS, &nod, Z, &nod1); + regfree(&nod); + nod = *n; + nod.right = &nod1; + boolgen(&nod, true, nn); + break; + } + if(sconst(l)) { + regalloc(&nod, r, nn); + cgenrel(r, &nod, 1); + o = invrel[relindex(o)]; + gopcode(true ? o | BTRUE : o, l, &nod, Z); + regfree(&nod); + goto com; + } + if(sconst(r)) { + regalloc(&nod, l, nn); + cgenrel(l, &nod, 1); + gopcode(true ? o | BTRUE : o, r, &nod, Z); + regfree(&nod); + goto com; + } + if(l->complex >= r->complex) { + regalloc(&nod1, l, nn); + cgenrel(l, &nod1, 1); + regalloc(&nod, r, Z); + cgenrel(r, &nod, 1); + } else { + regalloc(&nod, r, nn); + cgenrel(r, &nod, 1); + regalloc(&nod1, l, Z); + cgenrel(l, &nod1, 1); + } + gopcode(true ? o | BTRUE : o, &nod, &nod1, Z); + regfree(&nod); + regfree(&nod1); + + com: + if(nn != Z) { + p1 = p; + gopcode(OAS, nodconst(1), Z, nn); + gbranch(OGOTO); + p2 = p; + patch(p1, pc); + gopcode(OAS, nodconst(0), Z, nn); + patch(p2, pc); + } + break; + } + cursafe = curs; +} + +void +sugen(Node *n, Node *nn, long w) +{ + Prog *p1; + Node nod0, nod1, nod2, nod3, nod4, *l, *r; + Type *t; + long pc1; + int i, m, c; + + if(n == Z || n->type == T) + return; + if(debug['g']) { + prtree(nn, "sugen lhs"); + prtree(n, "sugen"); + } + switch(n->op) { + case OIND: + if(nn == Z) { + nullwarn(n->left, Z); + break; + } + + default: + goto copy; + + case OCONST: + if(n->type && typev[n->type->etype]) { + if(nn == Z) { + nullwarn(n->left, Z); + break; + } + + t = nn->type; + nn->type = types[TLONG]; + reglcgen(&nod1, nn, Z); + nn->type = t; + + if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ + gopcode(OAS, nod32const(n->vconst>>32), Z, &nod1); + else + gopcode(OAS, nod32const(n->vconst), Z, &nod1); + nod1.xoffset += SZ_LONG; + if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ + gopcode(OAS, nod32const(n->vconst), Z, &nod1); + else + gopcode(OAS, nod32const(n->vconst>>32), Z, &nod1); + + regfree(&nod1); + break; + } + goto copy; + + case ODOT: + l = n->left; + regsalloc(&nod1, l); + sugen(l, &nod1, l->type->width); + if(nn != Z) { + r = n->right; + if(!r || r->op != OCONST) { + diag(n, "DOT and no offset"); + break; + } + nod1.xoffset += (long)r->vconst; + nod1.type = n->type; + sugen(&nod1, nn, w); + } + break; + + case OSTRUCT: + /* + * rewrite so lhs has no side effects + */ + if(nn != Z && side(nn)) { + nod1 = *n; + nod1.type = typ(TIND, n->type); + regret(&nod2, &nod1); + lcgen(nn, &nod2); + regsalloc(&nod0, &nod1); + gopcode(OAS, &nod2, Z, &nod0); + regfree(&nod2); + + nod1 = *n; + nod1.op = OIND; + nod1.left = &nod0; + nod1.right = Z; + nod1.complex = 1; + + sugen(n, &nod1, w); + return; + } + + r = n->left; + for(t = n->type->link; t != T; t = t->down) { + l = r; + if(r->op == OLIST) { + l = r->left; + r = r->right; + } + if(nn == Z) { + cgen(l, nn); + continue; + } + /* + * hand craft *(&nn + o) = l + */ + nod0 = znode; + nod0.op = OAS; + nod0.type = t; + nod0.left = &nod1; + nod0.right = l; + + nod1 = znode; + nod1.op = OIND; + nod1.type = t; + nod1.left = &nod2; + + nod2 = znode; + nod2.op = OADD; + nod2.type = typ(TIND, t); + nod2.left = &nod3; + nod2.right = &nod4; + + nod3 = znode; + nod3.op = OADDR; + nod3.type = nod2.type; + nod3.left = nn; + + nod4 = znode; + nod4.op = OCONST; + nod4.type = nod2.type; + nod4.vconst = t->offset; + + ccom(&nod0); + acom(&nod0); + xcom(&nod0); + nod0.addable = 0; + + cgen(&nod0, Z); + } + break; + + case OAS: + if(nn == Z) { + if(n->addable < INDEXED) + sugen(n->right, n->left, w); + break; + } + regsalloc(&nod0, n->right); + sugen(n->right, &nod0, w); + sugen(&nod0, n->left, w); + sugen(&nod0, nn, w); + break; + + case OFUNC: + if(nn == Z) { + regsalloc(&nod0, n); + sugen(n, &nod0, w); + break; + } + if(nn->op != OIND) { + nn = new1(OADDR, nn, Z); + nn->type = types[TIND]; + nn->addable = 0; + } else + nn = nn->left; + n = new(OFUNC, n->left, new(OLIST, nn, n->right)); + n->type = types[TVOID]; + n->left->type = types[TVOID]; + cgen(n, Z); + break; + + case OCOND: + bcgen(n->left, 1); + p1 = p; + sugen(n->right->left, nn, w); + gbranch(OGOTO); + patch(p1, pc); + p1 = p; + sugen(n->right->right, nn, w); + patch(p1, pc); + break; + + case OCOMMA: + cgen(n->left, Z); + sugen(n->right, nn, w); + break; + } + return; + +copy: + if(nn == Z) + return; + if(n->complex >= FNX && nn->complex >= FNX) { + t = nn->type; + nn->type = types[TLONG]; + regialloc(&nod1, nn, Z); + lcgen(nn, &nod1); + regsalloc(&nod2, &nod1); + nn->type = t; + + gopcode(OAS, &nod1, Z, &nod2); + regfree(&nod1); + + nod2.type = typ(TIND, t); + + nod1 = nod2; + nod1.op = OIND; + nod1.left = &nod2; + nod1.right = Z; + nod1.complex = 1; + nod1.type = t; + + sugen(n, &nod1, w); + return; + } + + /* TO DO: use AMOV/VLONG when possible */ + if(n->complex > nn->complex) { + t = n->type; + n->type = types[TLONG]; + reglcgen(&nod1, n, Z); + n->type = t; + + t = nn->type; + nn->type = types[TLONG]; + reglcgen(&nod2, nn, Z); + nn->type = t; + } else { + t = nn->type; + nn->type = types[TLONG]; + reglcgen(&nod2, nn, Z); + nn->type = t; + + t = n->type; + n->type = types[TLONG]; + reglcgen(&nod1, n, Z); + n->type = t; + } + + if((m = w % SZ_LONG) > 0){ + nod1.xoffset += w - m; + nod2.xoffset += w - m; + regalloc(&nod3, ®node, Z); + do{ + gins(AMOVB, &nod1, &nod3); + gins(AMOVB, &nod3, &nod2); + nod1.xoffset++; + nod2.xoffset++; + w--; + }while(--m > 0); + regfree(&nod3); + nod1.xoffset -= w - m; + nod2.xoffset -= w - m; + } + + w /= SZ_LONG; + if(w <= 5) { + layout(&nod1, &nod2, w, 0, Z); + goto out; + } + + /* + * minimize space for unrolling loop + * 3,4,5 times. (6 or more is never minimum) + * if small structure, try 2 also. + */ + c = 0; /* set */ + m = 100; + i = 3; + if(w <= 15) + i = 2; + for(; i<=5; i++) + if(i + w%i <= m) { + c = i; + m = c + w%c; + } + + regalloc(&nod3, ®node, Z); + layout(&nod1, &nod2, w%c, w/c, &nod3); + + pc1 = pc; + layout(&nod1, &nod2, c, 0, Z); + + gopcode(OSUB, nodconst(1L), Z, &nod3); + nod1.op = OREGISTER; + t = nod1.type; + nod1.type = types[TIND]; + gopcode(OADD, nodconst(c*SZ_LONG), Z, &nod1); + nod1.type = t; + nod2.op = OREGISTER; + t = nod2.type; + nod2.type = types[TIND]; + gopcode(OADD, nodconst(c*SZ_LONG), Z, &nod2); + nod2.type = t; + + gopcode(OGT, nodconst(0), &nod3, Z); + patch(p, pc1); + + regfree(&nod3); +out: + regfree(&nod1); + regfree(&nod2); +} + +void +layout(Node *f, Node *t, int c, int cv, Node *cn) +{ + Node t1, t2; + + while(c > 3) { + layout(f, t, 2, 0, Z); + c -= 2; + } + + regalloc(&t1, ®node, Z); + regalloc(&t2, ®node, Z); + if(c > 0) { + gopcode(OAS, f, Z, &t1); + f->xoffset += SZ_LONG; + } + if(cn != Z) + gopcode(OAS, nodconst(cv), Z, cn); + if(c > 1) { + gopcode(OAS, f, Z, &t2); + f->xoffset += SZ_LONG; + } + if(c > 0) { + gopcode(OAS, &t1, Z, t); + t->xoffset += SZ_LONG; + } + if(c > 2) { + gopcode(OAS, f, Z, &t1); + f->xoffset += SZ_LONG; + } + if(c > 1) { + gopcode(OAS, &t2, Z, t); + t->xoffset += SZ_LONG; + } + if(c > 2) { + gopcode(OAS, &t1, Z, t); + t->xoffset += SZ_LONG; + } + regfree(&t1); + regfree(&t2); +} + +/* + * if a constant and vlong, doesn't fit as 32-bit signed immediate + */ +int +hardconst(Node *n) +{ + return n->op == OCONST && !sconst(n); +} + +/* + * casting up to t2 covers an intermediate cast to t1 + */ +int +castup(Type *t1, Type *t2) +{ + int ft; + + if(!nilcast(t1, t2)) + return 0; + /* known to be small to large */ + ft = t1->etype; + switch(t2->etype){ + case TINT: + case TLONG: + return ft == TLONG || ft == TINT || ft == TSHORT || ft == TCHAR; + case TUINT: + case TULONG: + return ft == TULONG || ft == TUINT || ft == TUSHORT || ft == TUCHAR; + case TVLONG: + return ft == TLONG || ft == TINT || ft == TSHORT; + case TUVLONG: + return ft == TULONG || ft == TUINT || ft == TUSHORT; + } + return 0; +} + +int +cond(int op) +{ + switch(op) { + case OANDAND: + case OOROR: + case ONOT: + return 1; + + case OEQ: + case ONE: + case OLE: + case OLT: + case OGE: + case OGT: + case OHI: + case OHS: + case OLO: + case OLS: + return 1; + } + return 0; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/enam.c Tue Feb 10 19:38:25 2026 @@ -0,0 +1,380 @@ +char* anames[] = +{ + "XXX", + "ADC", + "ADCS", + "ADCSW", + "ADCW", + "ADD", + "ADDS", + "ADDSW", + "ADDW", + "ADR", + "ADRP", + "AND", + "ANDS", + "ANDSW", + "ANDW", + "ASR", + "ASRW", + "AT", + "B", + "BFI", + "BFIW", + "BFM", + "BFMW", + "BFXIL", + "BFXILW", + "BIC", + "BICS", + "BICSW", + "BICW", + "BL", + "BRK", + "CBNZ", + "CBNZW", + "CBZ", + "CBZW", + "CCMN", + "CCMNW", + "CCMP", + "CCMPW", + "CINC", + "CINCW", + "CINV", + "CINVW", + "CLREX", + "CLS", + "CLSW", + "CLZ", + "CLZW", + "CMN", + "CMNW", + "CMP", + "CMPW", + "CNEG", + "CNEGW", + "CRC32B", + "CRC32CB", + "CRC32CH", + "CRC32CW", + "CRC32CX", + "CRC32H", + "CRC32W", + "CRC32X", + "CSEL", + "CSELW", + "CSET", + "CSETM", + "CSETMW", + "CSETW", + "CSINC", + "CSINCW", + "CSINV", + "CSINVW", + "CSNEG", + "CSNEGW", + "DC", + "DCPS1", + "DCPS2", + "DCPS3", + "DMB", + "DRPS", + "DSB", + "EON", + "EONW", + "EOR", + "EORW", + "ERET", + "EXTR", + "EXTRW", + "HINT", + "HLT", + "HVC", + "IC", + "ISB", + "LDAR", + "LDARB", + "LDARH", + "LDARW", + "LDAXP", + "LDAXPW", + "LDAXR", + "LDAXRB", + "LDAXRH", + "LDAXRW", + "LDXR", + "LDXRB", + "LDXRH", + "LDXRW", + "LDXP", + "LDXPW", + "LSL", + "LSLW", + "LSR", + "LSRW", + "MADD", + "MADDW", + "MNEG", + "MNEGW", + "MOVK", + "MOVKW", + "MOVN", + "MOVNW", + "MOVZ", + "MOVZW", + "MRS", + "MSR", + "MSUB", + "MSUBW", + "MUL", + "MULW", + "MVN", + "MVNW", + "NEG", + "NEGS", + "NEGSW", + "NEGW", + "NGC", + "NGCS", + "NGCSW", + "NGCW", + "NOP", + "ORN", + "ORNW", + "ORR", + "ORRW", + "PRFM", + "PRFUM", + "RBIT", + "RBITW", + "REM", + "REMW", + "RET", + "REV", + "REV16", + "REV16W", + "REV32", + "REVW", + "ROR", + "RORW", + "SBC", + "SBCS", + "SBCSW", + "SBCW", + "SBFIZ", + "SBFIZW", + "SBFM", + "SBFMW", + "SBFX", + "SBFXW", + "SDIV", + "SDIVW", + "SEV", + "SEVL", + "SMADDL", + "SMC", + "SMNEGL", + "SMSUBL", + "SMULH", + "SMULL", + "STXR", + "STXRB", + "STXRH", + "STXP", + "STXPW", + "STXRW", + "STLP, /*", + "STLPW", + "STLR", + "STLRB", + "STLRH", + "STLRW", + "STLXP", + "STLXPW", + "STLXR", + "STLXRB", + "STLXRH", + "STLXRW", + "SUB", + "SUBS", + "SUBSW", + "SUBW", + "SVC", + "SXTB", + "SXTBW", + "SXTH", + "SXTHW", + "SXTW", + "SYS", + "SYSL", + "TBNZ", + "TBZ", + "TLBI", + "TST", + "TSTW", + "UBFIZ", + "UBFIZW", + "UBFM", + "UBFMW", + "UBFX", + "UBFXW", + "UDIV", + "UDIVW", + "UMADDL", + "UMNEGL", + "UMSUBL", + "UMULH", + "UMULL", + "UREM", + "UREMW", + "UXTB", + "UXTH", + "UXTW", + "UXTBW", + "UXTHW", + "WFE", + "WFI", + "YIELD", + "MOVB", + "MOVBU", + "MOVH", + "MOVHU", + "MOVW", + "MOVWU", + "MOV", + "MOVNP", + "MOVNPW", + "MOVP", + "MOVPD", + "MOVPQ", + "MOVPS", + "MOVPSW", + "MOVPW", + "BEQ", + "BNE", + "BCS", + "BHS", + "BCC", + "BLO", + "BMI", + "BPL", + "BVS", + "BVC", + "BHI", + "BLS", + "BGE", + "BLT", + "BGT", + "BLE", + "FABSD", + "FABSS", + "FADDD", + "FADDS", + "FCCMPD", + "FCCMPED", + "FCCMPS", + "FCCMPES", + "FCMPD", + "FCMPED", + "FCMPES", + "FCMPS", + "FCVTSD", + "FCVTDS", + "FCVTZSD", + "FCVTZSDW", + "FCVTZSS", + "FCVTZSSW", + "FCVTZUD", + "FCVTZUDW", + "FCVTZUS", + "FCVTZUSW", + "FDIVD", + "FDIVS", + "FMOVD", + "FMOVS", + "FMULD", + "FMULS", + "FNEGD", + "FNEGS", + "FSQRTD", + "FSQRTS", + "FSUBD", + "FSUBS", + "SCVTFD", + "SCVTFS", + "SCVTFWD", + "SCVTFWS", + "UCVTFD", + "UCVTFS", + "UCVTFWD", + "UCVTFWS", + "TEXT", + "DATA", + "GLOBL", + "HISTORY", + "NAME", + "WORD", + "DYNT", + "INIT", + "BCASE", + "CASE", + "DWORD", + "SIGNAME", + "GOK", + "RETURN", + "END", + "FCSELS", + "FCSELD", + "FMAXS", + "FMINS", + "FMAXD", + "FMIND", + "FMAXNMS", + "FMAXNMD", + "FNMULS", + "FNMULD", + "FRINTNS", + "FRINTND", + "FRINTPS", + "FRINTPD", + "FRINTMS", + "FRINTMD", + "FRINTZS", + "FRINTZD", + "FRINTAS", + "FRINTAD", + "FRINTXS", + "FRINTXD", + "FRINTIS", + "FRINTID", + "FMADDS", + "FMADDD", + "FMSUBS", + "FMSUBD", + "FNMADDS", + "FNMADDD", + "FNMSUBS", + "FNMSUBD", + "FMINNMS", + "FMINNMD", + "FCVTDH", + "FCVTHS", + "FCVTHD", + "FCVTSH", + "AESD", + "AESE", + "AESIMC", + "AESMC", + "SHA1C", + "SHA1H", + "SHA1M", + "SHA1P", + "SHA1SU0", + "SHA1SU1", + "SHA256H", + "SHA256H2", + "SHA256SU0", + "SHA256SU1", + "LAST", +}; --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/gc.h Tue Dec 30 17:28:54 2025 @@ -0,0 +1,352 @@ +#include "../cc/cc.h" +#include "../7c/7.out.h" + +/* + * 7c/arm64 + * Arm64 + */ +#define SZ_CHAR 1 +#define SZ_SHORT 2 +#define SZ_INT 4 +#define SZ_LONG 4 +#define SZ_IND 8 +#define SZ_FLOAT 4 +#define SZ_VLONG 8 +#define SZ_DOUBLE 8 +#define FNX 100 +#define BTRUE 0x1000 + +typedef struct Adr Adr; +typedef struct Prog Prog; +typedef struct Case Case; +typedef struct C1 C1; +typedef struct Multab Multab; +typedef struct Hintab Hintab; +typedef struct Var Var; +typedef struct Reg Reg; +typedef struct Rgn Rgn; + + +struct Adr +{ + vlong offset; + double dval; + char sval[NSNAME]; + Ieee ieee; + + Sym* sym; + char type; + char reg; + char name; + char etype; +}; +#define A ((Adr*)0) + +#define INDEXED 9 +struct Prog +{ + Adr from; + Adr from3; + Adr to; + Prog* link; + long lineno; + ushort as; + char reg; + uchar scond; +}; +#define P ((Prog*)0) + +struct Case +{ + Case* link; + vlong val; + long label; + char def; + char isv; +}; +#define C ((Case*)0) + +struct C1 +{ + vlong val; + long label; +}; + +struct Multab +{ + long val; + char code[20]; +}; + +struct Hintab +{ + ushort val; + char hint[10]; +}; + +struct Var +{ + vlong offset; + Sym* sym; + char name; + char etype; +}; + +struct Reg +{ + long pc; + long rpo; /* reverse post ordering */ + + Bits set; + Bits use1; + Bits use2; + + Bits refbehind; + Bits refahead; + Bits calbehind; + Bits calahead; + Bits regdiff; + Bits act; + + long regu; + long loop; /* could be shorter */ + + + Reg* log5; + long active; + + Reg* p1; + Reg* p2; + Reg* p2link; + Reg* s1; + Reg* s2; + Reg* link; + Prog* prog; +}; +#define R ((Reg*)0) + +struct Rgn +{ + Reg* enter; + short cost; + short varno; + short regno; +}; + +EXTERN long breakpc; +EXTERN long nbreak; +EXTERN Case* cases; +EXTERN Node constnode; +EXTERN Node fconstnode; +EXTERN Node vconstnode; +EXTERN long continpc; +EXTERN long curarg; +EXTERN long cursafe; +EXTERN Prog* firstp; +EXTERN Prog* lastp; +EXTERN long maxargsafe; +EXTERN int mnstring; +EXTERN Multab multab[20]; +EXTERN int hintabsize; +EXTERN Node* nodret; +EXTERN Node* nodsafe; +EXTERN long nstring; +EXTERN Prog* p; +EXTERN long pc; +EXTERN Node regnode; +EXTERN Node qregnode; +EXTERN char string[NSNAME]; +EXTERN Node znode; +EXTERN Prog zprog; +EXTERN char reg[NREG+NFREG]; +EXTERN long exregoffset; +EXTERN long exfregoffset; +EXTERN int suppress; +EXTERN uchar typechlpv[NTYPE]; + +#define BLOAD(r) band(bnot(r->refbehind), r->refahead) +#define BSTORE(r) band(bnot(r->calbehind), r->calahead) +#define LOAD(r) (~r->refbehind.b[z] & r->refahead.b[z]) +#define STORE(r) (~r->calbehind.b[z] & r->calahead.b[z]) + +#define bset(a,n) ((a).b[(n)/32]&(1L<<(n)%32)) + +#define CLOAD 4 +#define CREF 5 +#define CINF 1000 +#define LOOP 3 + +EXTERN int nvar; + +EXTERN Bits externs; +EXTERN Bits params; +EXTERN Bits consts; +EXTERN Bits addrs; + +EXTERN long regbits; +EXTERN long exregbits; + +EXTERN int change; + +EXTERN Reg* firstr; +EXTERN Reg* lastr; +EXTERN Reg zreg; +EXTERN Reg* freer; +EXTERN Var var[NVAR]; +EXTERN long* idom; +EXTERN Reg** rpo2r; +EXTERN long maxnr; + +extern char* anames[]; +extern Hintab hintab[]; + +/* + * sgen.c + */ +void codgen(Node*, Node*); +void gen(Node*); +void noretval(int); +void usedset(Node*, int); +void xcom(Node*); +int bcomplex(Node*, Node*); + +/* + * cgen.c + */ +int castup(Type*, Type*); +void cgen(Node*, Node*); +void cgenrel(Node*, Node*, int); +int cond(int); +int hardconst(Node*); +void reglcgen(Node*, Node*, Node*); +void layout(Node*, Node*, int, int, Node*); +void lcgen(Node*, Node*); +void bcgen(Node*, int); +void boolgen(Node*, int, Node*); +void sugen(Node*, Node*, long); +void layout(Node*, Node*, int, int, Node*); + +/* + * txt.c + */ +void ginit(void); +void gclean(void); +void nextpc(void); +void gargs(Node*, Node*, Node*); +void garg1(Node*, Node*, Node*, int, Node**); +Node* nodconst(long); +Node* nod32const(vlong); +Node* nodfconst(double); +void nodreg(Node*, Node*, int); +void regret(Node*, Node*); +void regalloc(Node*, Node*, Node*); +void regfree(Node*); +void regialloc(Node*, Node*, Node*); +void regsalloc(Node*, Node*); +void regaalloc1(Node*, Node*); +void regaalloc(Node*, Node*); +void regind(Node*, Node*); +void gprep(Node*, Node*); +void raddr(Node*, Prog*); +void naddr(Node*, Adr*); +void gmovm(Node*, Node*, int); +void gmove(Node*, Node*); +void gmover(Node*, Node*); +void gins(int a, Node*, Node*); +void gopcode(int, Node*, Node*, Node*); +int samaddr(Node*, Node*); +void gbranch(int); +void patch(Prog*, long); +int sconst(Node*); +int sval(vlong); +void gpseudo(int, Sym*, Node*); +int usableoffset(Node*, vlong, Node*); + +/* + * swt.c + */ +int swcmp(void*, void*); +void doswit(Node*); +void swit1(C1*, int, long, Node*); +void swit2(C1*, int, long, Node*, Node*); +void casf(void); +void bitload(Node*, Node*, Node*, Node*, Node*); +void bitstore(Node*, Node*, Node*, Node*, Node*); +long outstring(char*, long); +int mulcon(Node*, Node*); +Multab* mulcon0(long); +void nullwarn(Node*, Node*); +void gextern(Sym*, Node*, long, long); +void outcode(void); +void ieeedtod(Ieee*, double); + +/* + * list + */ +void listinit(void); +int Pconv(Fmt*); +int Aconv(Fmt*); +int Dconv(Fmt*); +int Sconv(Fmt*); +int Nconv(Fmt*); +int Bconv(Fmt*); +int Rconv(Fmt*); + +/* + * reg.c + */ +Reg* rega(void); +int rcmp(void*, void*); +void regopt(Prog*); +void addmove(Reg*, int, int, int); +Bits mkvar(Adr*, int); +void prop(Reg*, Bits, Bits); +void loopit(Reg*, long); +void synch(Reg*, Bits); +ulong allreg(ulong, Rgn*); +void paint1(Reg*, int); +ulong paint2(Reg*, int); +void paint3(Reg*, int, long, int); +void addreg(Adr*, int); + +/* + * peep.c + */ +void peep(void); +void excise(Reg*); +Reg* uniqp(Reg*); +Reg* uniqs(Reg*); +int regtyp(Adr*); +int regzer(Adr*); +int anyvar(Adr*); +int subprop(Reg*); +int copyprop(Reg*); +int shiftprop(Reg*); +void constprop(int, Adr*, Adr*, Reg*); +int copy1(Adr*, Adr*, Reg*, int); +int copyu(Prog*, Adr*, Adr*); + +int copyas(Adr*, Adr*); +int copyau(Adr*, Adr*); +int copyau1(Prog*, Adr*); +int copysub(Adr*, Adr*, Adr*, int); +int copysub1(Prog*, Adr*, Adr*, int); + +long RtoB(int); +long FtoB(int); +int BtoR(long); +int BtoF(long); + +void predicate(void); +int isbranch(Prog *); +int predicable(Prog *p); +int modifiescpsr(Prog *p); + +#pragma varargck type "A" int +#pragma varargck type "A" uint +#pragma varargck type "B" Bits +#pragma varargck type "D" Adr* +#pragma varargck type "N" Adr* +#pragma varargck type "R" Adr* +#pragma varargck type "P" Prog* +#pragma varargck type "S" char* --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/list.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,295 @@ +#define EXTERN +#include "gc.h" + +void +listinit(void) +{ + + fmtinstall('A', Aconv); + fmtinstall('P', Pconv); + fmtinstall('S', Sconv); + fmtinstall('N', Nconv); + fmtinstall('B', Bconv); + fmtinstall('D', Dconv); + fmtinstall('R', Rconv); +} + +int +Bconv(Fmt *fp) +{ + Bits bits; + int i; + + bits = va_arg(fp->args, Bits); + while(bany(&bits)) { + i = bnum(bits); + bits.b[i/32] &= ~(1L << (i%32)); + if(var[i].sym == S) + fmtprint(fp, "$%lld ", var[i].offset); + else + fmtprint(fp, "%s ", var[i].sym->name); + } + return 0; +} + +static char *conds[] = { + ".EQ", ".NE", ".CS", ".CC", + ".MI", ".PL", ".VS", ".VC", + ".HI", ".LS", ".GE", ".LT", + ".GT", ".LE", "", ".NV", +}; + +int +Pconv(Fmt *fp) +{ + char str[STRINGSZ], *s, *e; + Prog *p; + int a; + + p = va_arg(fp->args, Prog*); + a = p->as; + s = str; + e = str + sizeof(str); + s = seprint(s, e, " %A %D", a, &p->from); + if(a == ADATA) + s = seprint(s, e, "/%d", p->reg); + else if(p->as == ATEXT) + s = seprint(s, e, ",%d", p->reg); + else if(p->reg != NREG) + if(p->from.type != D_FREG && p->from.type != D_FCONST) + s = seprint(s, e, ",R%d", p->reg); + else + s = seprint(s, e, ",F%d", p->reg); + if(p->from3.type != D_NONE) + s = seprint(s, e, ",%D", &p->from3); + if(p->to.type != D_NONE) + s = seprint(s, e, s[-1] == '\t' ? "%D" : ",%D", &p->to); + if(s[-1] == '\t') + s[-1] = 0; + return fmtstrcpy(fp, str); +} + +int +Aconv(Fmt *fp) +{ + char *s; + int a; + + a = va_arg(fp->args, int); + s = "???"; + if(a >= AXXX && a < ALAST) + s = anames[a]; + return fmtstrcpy(fp, s); +} + +int +Dconv(Fmt *fp) +{ + Adr *a; + char *op; + int v; + static char *extop[] = {".UB", ".UH", ".UW", ".UX", ".SB", ".SH", ".SW", ".SX"}; + + a = va_arg(fp->args, Adr*); + switch(a->type) { + default: + return fmtprint(fp, "GOK-type(%d)", a->type); + + case D_NONE: + if(a->name != D_NONE || a->reg != NREG || a->sym != S) + return fmtprint(fp, "%N(R%d)(NONE)", a, a->reg); + return 0; + + case D_CONST: + if(a->reg != NREG) + return fmtprint(fp, "$%N(R%d)", a, a->reg); + else + return fmtprint(fp, "$%N", a); + + case D_SHIFT: + v = a->offset; + op = "<<>>->@>" + (((v>>5) & 3) << 1); + if(v & (1<<4)) + fmtprint(fp, "R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15); + else + fmtprint(fp, "R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31); + if(a->reg != NREG) + fmtprint(fp, "(R%d)", a->reg); + return 0; + + case D_OREG: + if(a->reg != NREG) + return fmtprint(fp, "%N(R%d)", a, a->reg); + else + return fmtprint(fp, "%N", a); + + case D_XPRE: + if(a->reg != NREG) + return fmtprint(fp, "%N(R%d)!", a, a->reg); + else + return fmtprint(fp, "%N!", a); + + case D_XPOST: + if(a->reg != NREG) + return fmtprint(fp, "(R%d)%N!", a->reg, a); + else + return fmtprint(fp, "%N!", a); + + case D_EXTREG: + v = a->offset; + if(v & (7<<10)) + return fmtprint(fp, "R%d%s<<%d", (v>>16)&31, extop[(v>>13)&7], (v>>10)&7); + else + return fmtprint(fp, "R%d%s", (v>>16)&31, extop[(v>>13)&7]); + + case D_REG: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "R%d", a->reg); + + case D_SP: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "SP"); + + case D_FREG: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "F%d", a->reg); + + case D_SPR: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(SPR(%lld))(REG)", a, a->offset); + switch((ulong)a->offset){ + case D_FPSR: + return fmtprint(fp, "FPSR"); + case D_FPCR: + return fmtprint(fp, "FPCR"); + case D_NZCV: + return fmtprint(fp, "NZCV"); + default: + return fmtprint(fp, "SPR(%#llux)", a->offset); + } + + case D_BRANCH: + return fmtprint(fp, "%lld(PC)", a->offset-pc); + + case D_FCONST: + return fmtprint(fp, "$%.17e", a->dval); + + case D_SCONST: + return fmtprint(fp, "$\"%S\"", a->sval); + } +} + +int +Rconv(Fmt *fp) +{ + char str[STRINGSZ], *p, *e; + Adr *a; + int i, v; + + a = va_arg(fp->args, Adr*); + snprint(str, sizeof(str), "GOK-reglist"); + switch(a->type) { + case D_CONST: + if(a->reg != NREG) + break; + if(a->sym != S) + break; + v = a->offset; + p = str; + e = str+sizeof(str); + for(i=0; iargs, char*); + p = str; + for(i=0; i= 'a' && c <= 'z' || + c >= 'A' && c <= 'Z' || + c >= '0' && c <= '9' || + c == ' ' || c == '%') { + *p++ = c; + continue; + } + *p++ = '\\'; + switch(c) { + case 0: + *p++ = 'z'; + continue; + case '\\': + case '"': + *p++ = c; + continue; + case '\n': + *p++ = 'n'; + continue; + case '\t': + *p++ = 't'; + continue; + case '\r': + *p++ = 'r'; + continue; + case '\f': + *p++ = 'f'; + continue; + } + *p++ = (c>>6) + '0'; + *p++ = ((c>>3) & 7) + '0'; + *p++ = (c & 7) + '0'; + } + *p = 0; + return fmtstrcpy(fp, str); +} + +int +Nconv(Fmt *fp) +{ + Adr *a; + Sym *s; + + a = va_arg(fp->args, Adr*); + s = a->sym; + if(s == S) + return fmtprint(fp, "%lld", a->offset); + switch(a->name) { + default: + return fmtprint(fp, "GOK-name(%d)", a->name); + + case D_NONE: + return fmtprint(fp, "%lld", a->offset); + + case D_EXTERN: + return fmtprint(fp, "%s+%lld(SB)", s->name, a->offset); + + case D_STATIC: + return fmtprint(fp, "%s<>+%lld(SB)", s->name, a->offset); + + case D_AUTO: + return fmtprint(fp, "%s-%lld(SP)", s->name, -a->offset); + + case D_PARAM: + return fmtprint(fp, "%s+%lld(FP)", s->name, a->offset); + } +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/machcap.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,81 @@ +#include "gc.h" + +int +machcap(Node *n) +{ + + if(n == Z) + return 1; /* test */ + + switch(n->op) { + case OMUL: + case OLMUL: + case OASMUL: + case OASLMUL: + if(typechlv[n->type->etype]) + return 1; + break; + + case OADD: + case OAND: + case OOR: + case OSUB: + case OXOR: + case OASHL: + case OLSHR: + case OASHR: + if(typechlv[n->left->type->etype]) + return 1; + break; + + case OCAST: + return 1; + + case OCOND: + case OCOMMA: + case OLIST: + case OANDAND: + case OOROR: + case ONOT: + return 1; + + case OASADD: + case OASSUB: + case OASAND: + case OASOR: + case OASXOR: + return 1; + + case OASASHL: + case OASASHR: + case OASLSHR: + return 1; + + case OPOSTINC: + case OPOSTDEC: + case OPREINC: + case OPREDEC: + return 1; + + case OEQ: + case ONE: + case OLE: + case OGT: + case OLT: + case OGE: + case OHI: + case OHS: + case OLO: + case OLS: + return 1; + + case ONEG: + if(typechlv[n->left->type->etype]) + return 1; + break; + + case OCOM: + break; + } + return 0; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/mkenam Fri Mar 6 19:44:47 2026 @@ -0,0 +1,15 @@ +ed - ../7c/7.out.h <<'!' +v/^ A/d +,s/^ A/ "/ +g/ .*$/s/// +,s/,*$/",/ +1i +char* anames[] = +{ +. +$a +}; +. +w enam.c +Q +! --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/mkfile Fri Mar 6 19:45:19 2026 @@ -0,0 +1,43 @@ +val == v) { + if(m->code[0] == 0) + return 0; + return m; + } + m++; + } + + /* + * select a spot in cache to overwrite + */ + multabp++; + if(multabp < 0 || multabp >= nelem(multab)) + multabp = 0; + m = multab+multabp; + m->val = v; + mulval = v; + + /* + * look in execption hint table + */ + a1 = 0; + a2 = hintabsize; + for(;;) { + if(a1 >= a2) + goto no; + g = (a2 + a1)/2; + if(v < hintab[g].val) { + a2 = g; + continue; + } + if(v > hintab[g].val) { + a1 = g+1; + continue; + } + break; + } + + if(docode(hintab[g].hint, m->code, 1, 0)) + return m; + print("multiply table failure %ld\n", v); + m->code[0] = 0; + return 0; + +no: + /* + * try to search + */ + hint[0] = 0; + for(g=1; g<=maxmulops; g++) { + if(g >= maxmulops && v >= 65535) + break; + mulcp = hint+g; + *mulcp = 0; + if(gen1(g)) { + if(docode(hint, m->code, 1, 0)) + return m; + print("multiply table failure %ld\n", v); + break; + } + } + + /* + * try a recur followed by a shift + */ + g = 0; + while(!(v & 1)) { + g++; + v >>= 1; + } + if(g) { + m1 = mulcon0(v); + if(m1) { + snprint(m->code, sizeof(m->code), "%s%c0", m1->code, g+'a'); + return m; + } + } + m->code[0] = 0; + return 0; +} + +static int +docode(char *hp, char *cp, int r0, int r1) +{ + int c, i; + + c = *hp++; + *cp = c; + cp += 2; + switch(c) { + default: + c -= 'a'; + if(c < 1 || c >= 30) + break; + for(i=0; i<4; i++) { + switch(i) { + case 0: + if(docode(hp, cp, r0<= mulval) + break; + } + if(mulval == 1) + return 1; + + len--; + for(i=1; i<=shmax; i++) + if(gen2(len, 1<= r1 || + r1 > valmax) + return 0; + + len--; + if(len == 0) + goto calcr0; + + if(!(flag & UR1)) { + f1 = UR1|SR1; + for(i=1; i<=shmax; i++) { + x = r0< valmax) + break; + if(gen3(len, r0, x, f1)) { + i += 'a'; + goto out; + } + } + } + + if(!(flag & UR0)) { + f1 = UR1|SR1; + for(i=1; i<=shmax; i++) { + x = r1< valmax) + break; + if(gen3(len, r1, x, f1)) { + i += 'a'; + goto out; + } + } + } + + if(!(flag & SR1)) { + f1 = UR1|SR1|(flag&UR0); + for(i=1; i<=shmax; i++) { + x = r1< valmax) + break; + if(gen3(len, r0, x, f1)) { + i += 'a'; + goto out; + } + } + } + + if(!(flag & SR0)) { + f1 = UR0|SR0|(flag&(SR1|UR1)); + + f2 = UR1|SR1; + if(flag & UR1) + f2 |= UR0; + if(flag & SR1) + f2 |= SR0; + + for(i=1; i<=shmax; i++) { + x = r0< valmax) + break; + if(x > r1) { + if(gen3(len, r1, x, f2)) { + i += 'a'; + goto out; + } + } else + if(gen3(len, x, r1, f1)) { + i += 'a'; + goto out; + } + } + } + + x = r1+r0; + if(gen3(len, r0, x, UR1)) { + i = '+'; + goto out; + } + + if(gen3(len, r1, x, UR1)) { + i = '+'; + goto out; + } + + x = r1-r0; + if(gen3(len, x, r1, UR0)) { + i = '-'; + goto out; + } + + if(x > r0) { + if(gen3(len, r0, x, UR1)) { + i = '-'; + goto out; + } + } else + if(gen3(len, x, r0, UR0)) { + i = '-'; + goto out; + } + + return 0; + +calcr0: + f1 = flag & (UR0|UR1); + if(f1 == UR1) { + for(i=1; i<=shmax; i++) { + x = r1<= mulval) { + if(x == mulval) { + i += 'a'; + goto out; + } + break; + } + } + } + + if(mulval == r1+r0) { + i = '+'; + goto out; + } + if(mulval == r1-r0) { + i = '-'; + goto out; + } + + return 0; + +out: + *--mulcp = i; + return 1; +} + +/* + * hint table has numbers that + * the search algorithm fails on. + * <1000: + * all numbers + * <5000: + * ÷ by 5 + * <10000: + * ÷ by 50 + * <65536: + * ÷ by 250 + */ +Hintab hintab[] = +{ + 683, "b++d+e+", + 687, "b+e++e-", + 691, "b++d+e+", + 731, "b++d+e+", + 811, "b++d+i+", + 821, "b++e+e+", + 843, "b+d++e+", + 851, "b+f-+e-", + 853, "b++e+e+", + 877, "c++++g-", + 933, "b+c++g-", + 981, "c-+e-d+", + 1375, "b+c+b+h-", + 1675, "d+b++h+", + 2425, "c++f-e+", + 2675, "c+d++f-", + 2750, "b+d-b+h-", + 2775, "c-+g-e-", + 3125, "b++e+g+", + 3275, "b+c+g+e+", + 3350, "c++++i+", + 3475, "c-+e-f-", + 3525, "c-+d+g-", + 3625, "c-+e-j+", + 3675, "b+d+d+e+", + 3725, "b+d-+h+", + 3925, "b+d+f-d-", + 4275, "b+g++e+", + 4325, "b+h-+d+", + 4425, "b+b+g-j-", + 4525, "b+d-d+f+", + 4675, "c++d-g+", + 4775, "b+d+b+g-", + 4825, "c+c-+i-", + 4850, "c++++i-", + 4925, "b++e-g-", + 4975, "c+f++e-", + 5500, "b+g-c+d+", + 6700, "d+b++i+", + 9700, "d++++j-", + 11000, "b+f-c-h-", + 11750, "b+d+g+j-", + 12500, "b+c+e-k+", + 13250, "b+d+e-f+", + 13750, "b+h-c-d+", + 14250, "b+g-c+e-", + 14500, "c+f+j-d-", + 14750, "d-g--f+", + 16750, "b+e-d-n+", + 17750, "c+h-b+e+", + 18250, "d+b+h-d+", + 18750, "b+g-++f+", + 19250, "b+e+b+h+", + 19750, "b++h--f-", + 20250, "b+e-l-c+", + 20750, "c++bi+e-", + 21250, "b+i+l+c+", + 22000, "b+e+d-g-", + 22250, "b+d-h+k-", + 22750, "b+d-e-g+", + 23250, "b+c+h+e-", + 23500, "b+g-c-g-", + 23750, "b+g-b+h-", + 24250, "c++g+m-", + 24750, "b+e+e+j-", + 25000, "b++dh+g+", + 25250, "b+e+d-g-", + 25750, "b+e+b+j+", + 26250, "b+h+c+e+", + 26500, "b+h+c+g+", + 26750, "b+d+e+g-", + 27250, "b+e+e+f+", + 27500, "c-i-c-d+", + 27750, "b+bd++j+", + 28250, "d-d-++i-", + 28500, "c+c-h-e-", + 29000, "b+g-d-f+", + 29500, "c+h+++e-", + 29750, "b+g+f-c+", + 30250, "b+f-g-c+", + 33500, "c-f-d-n+", + 33750, "b+d-b+j-", + 34250, "c+e+++i+", + 35250, "e+b+d+k+", + 35500, "c+e+d-g-", + 35750, "c+i-++e+", + 36250, "b+bh-d+e+", + 36500, "c+c-h-e-", + 36750, "d+e--i+", + 37250, "b+g+g+b+", + 37500, "b+h-b+f+", + 37750, "c+be++j-", + 38500, "b+e+b+i+", + 38750, "d+i-b+d+", + 39250, "b+g-l-+d+", + 39500, "b+g-c+g-", + 39750, "b+bh-c+f-", + 40250, "b+bf+d+g-", + 40500, "b+g-c+g+", + 40750, "c+b+i-e+", + 41250, "d++bf+h+", + 41500, "b+j+c+d-", + 41750, "c+f+b+h-", + 42500, "c+h++g+", + 42750, "b+g+d-f-", + 43250, "b+l-e+d-", + 43750, "c+bd+h+f-", + 44000, "b+f+g-d-", + 44250, "b+d-g--f+", + 44500, "c+e+c+h+", + 44750, "b+e+d-h-", + 45250, "b++g+j-g+", + 45500, "c+d+e-g+", + 45750, "b+d-h-e-", + 46250, "c+bd++j+", + 46500, "b+d-c-j-", + 46750, "e-e-b+g-", + 47000, "b+c+d-j-", + 47250, "b+e+e-g-", + 47500, "b+g-c-h-", + 47750, "b+f-c+h-", + 48250, "d--h+n-", + 48500, "b+c-g+m-", + 48750, "b+e+e-g+", + 49500, "c-f+e+j-", + 49750, "c+c+g++f-", + 50000, "b+e+e+k+", + 50250, "b++i++g+", + 50500, "c+g+f-i+", + 50750, "b+e+d+k-", + 51500, "b+i+c-f+", + 51750, "b+bd+g-e-", + 52250, "b+d+g-j+", + 52500, "c+c+f+g+", + 52750, "b+c+e+i+", + 53000, "b+i+c+g+", + 53500, "c+g+g-n+", + 53750, "b+j+d-c+", + 54250, "b+d-g-j-", + 54500, "c-f+e+f+", + 54750, "b+f-+c+g+", + 55000, "b+g-d-g-", + 55250, "b+e+e+g+", + 55500, "b+cd++j+", + 55750, "b+bh-d-f-", + 56250, "c+d-b+j-", + 56500, "c+d+c+i+", + 56750, "b+e+d++h-", + 57000, "b+d+g-f+", + 57250, "b+f-m+d-", + 57750, "b+i+c+e-", + 58000, "b+e+d+h+", + 58250, "c+b+g+g+", + 58750, "d-e-j--e+", + 59000, "d-i-+e+", + 59250, "e--h-m+", + 59500, "c+c-h+f-", + 59750, "b+bh-e+i-", + 60250, "b+bh-e-e-", + 60500, "c+c-g-g-", + 60750, "b+e-l-e-", + 61250, "b+g-g-c+", + 61750, "b+g-c+g+", + 62250, "f--+c-i-", + 62750, "e+f--+g+", + 64750, "b+f+d+p-", +}; +int hintabsize = nelem(hintab); --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/peep.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,1949 @@ +#include "gc.h" + +int xtramodes(Reg*, Adr*); + +Reg* findset(Reg *r, Adr *v); +Reg* findpre(Reg *r, Adr *v); +Reg* findinc(Reg *r, Reg *r2, Adr *v); +static void +storeprop(int as, Adr *a, Adr *v, Reg *r); + +static void +swapprog(Prog *p1, Prog *p2) +{ + Prog tmp = *p1; + + p1->as = p2->as; + p1->scond = p2->scond; + p1->from = p2->from; + p1->to = p2->to; + p1->reg = p2->reg; + + p2->as = tmp.as; + p2->scond = tmp.scond; + p2->from = tmp.from; + p2->to = tmp.to; + p2->reg = tmp.reg; +} + +static int +isu32op(Prog *p) +{ + switch(p->as){ + case AADCSW: + case AADCW: + case AADDSW: + case AADDW: + case AANDSW: + case AANDW: + case AASRW: + case ABFIW: + case ABFMW: + case ABFXILW: + case ABICSW: + case ABICW: + case ACBNZW: + case ACBZW: + case ACCMNW: + case ACCMPW: + case ACINCW: + case ACINVW: + case ACLSW: + case ACLZW: + case ACMNW: + case ACNEGW: + case ACRC32CW: + case ACRC32W: + case ACSELW: + case ACSETMW: + case ACSETW: + case ACSINCW: + case ACSINVW: + case ACSNEGW: + case AEONW: + case AEORW: + case AEXTRW: + case ALDARW: + case ALDAXPW: + case ALDAXRW: + case ALDXRW: + case ALDXPW: + case ALSLW: + case ALSRW: + case AMADDW: + case AMNEGW: + case AMOVKW: + case AMOVNW: + case AMOVZW: + case AMSUBW: + case AMULW: + case AMVNW: + case ANEGSW: + case ANEGW: + case ANGCSW: + case ANGCW: + case AORNW: + case AORRW: + case ARBITW: + case AREMW: + case AREV16W: + case AREVW: + case ARORW: + case ASBCSW: + case ASBCW: + case ASBFIZW: + case ASBFMW: + case ASBFXW: + case ASDIVW: + case ASTXPW: + case ASTXRW: + case ASTLRW: + case ASTLXPW: + case ASTLXRW: + case ASUBSW: + case ASUBW: + case ASXTBW: + case ASXTHW: + case ATSTW: + case AUBFIZW: + case AUBFMW: + case AUBFXW: + case AUDIVW: + case AUREMW: + case AUMULL: + case AUXTW: + case AUXTBW: + case AUXTHW: + case AMOVWU: + return 1; + } + return 0; +} + +static int +independent(Prog *p1, Prog *p2) +{ + switch(p1->as){ + case ACMP: + case ACMPW: + case AFCMPS: + case AFCMPD: + case ACBZ: + case ACBZW: + case ACBNZ: + case ACBNZW: + case ATBZ: + case ATBNZ: + + case AB: + case ABL: + case ARET: + case ARETURN: + return 0; + } + + if(regtyp(&p1->to)){ + if(!copyu(p2, &p1->to, A)) + return 1; + return 0; + } + + if(p2->from.type == D_CONST || p2->from.type == D_FCONST) + return 1; + + if(p1->to.type == D_OREG){ + int w; + + if(p2->from.type != D_OREG) + return 1; + + switch(p1->as){ + default: + return 0; + case AMOV: + case AFMOVD: + w = 8; + break; + case AMOVW: + case AMOVWU: + case AFMOVS: + w = 4; + break; + case AMOVH: + case AMOVHU: + w = 2; + break; + case AMOVB: + case AMOVBU: + w = 1; + break; + } + + if(p1->to.reg != REGSP && p1->to.name <= D_NONE) + return 0; + if(p2->from.reg != REGSP && p2->from.name <= D_NONE) + return 0; + + if(p1->to.name != p2->from.name + || p1->to.reg != p2->from.reg + || abs(p1->to.offset - p2->from.offset) >= w) + return 1; + } + + /* assume not independent */ + return 0; +} + +void +peep(void) +{ + Reg *r, *r1, *r2; + Prog *p, *p1; + int t; +/* + * complete R structure + */ + t = 0; + for(r=firstr; r!=R; r=r1) { + r1 = r->link; + if(r1 == R) + break; + p = r->prog->link; + while(p != r1->prog) + switch(p->as) { + default: + r2 = rega(); + r->link = r2; + r2->link = r1; + + r2->prog = p; + r2->p1 = r; + r->s1 = r2; + r2->s1 = r1; + r1->p1 = r2; + + r = r2; + t++; + + case ADATA: + case AGLOBL: + case ANAME: + case ASIGNAME: + p = p->link; + } + } + +loop1: + t = 0; + for(r=firstr; r!=R; r=r->link) { + p = r->prog; + + /* registerize variable loads following stores */ + if(p->as == AMOV || p->as == AMOVW || p->as == AMOVWU || p->as == AFMOVS || p->as == AFMOVD){ + if(p->from.type == D_REG && p->to.type == D_OREG && p->to.name > D_NONE) + storeprop(p->as, &p->from, &p->to, r->s1); + } + + if(p->as == ALSL || p->as == ALSR || p->as == AASR + || p->as == ALSLW || p->as == ALSRW || p->as == AASRW) { + /* + * elide shift into D_SHIFT operand of subsequent instruction + */ + if(0 && shiftprop(r)) { + excise(r); + t++; + } + } else + if(p->as == ASXTW && p->from.type == D_REG && p->to.type == D_REG){ + if((r1 = findset(r, &p->from)) != R){ + p1 = r1->prog; + switch(p1->as){ + case AMOVW: + /* MOVW $const,r; does not sign extend */ + if(p1->from.type == D_CONST && (p1->from.offset & 0x80000000) != 0) + break; + case AMOVB: + case AMOVH: + case AMOVBU: + case AMOVHU: + case ASXTW: + if(p1->to.type == p->from.type && p1->to.reg == p->from.reg) + p->as = AMOVW; + break; + } + } + } else + if((p->as == AMOVB || p->as == AMOVBU || p->as == AMOVH || p->as == AMOVHU || p->as == AMOVWU) + && (p->from.type == D_REG && p->to.type == D_REG)){ + if((r1 = findset(r, &p->from)) != R){ + p1 = r1->prog; + if(p1->to.type == p->from.type && p1->to.reg == p->from.reg){ + if(p1->as == p->as || p->as == AMOVWU && isu32op(p1)) + p->as = AMOVW; + } + } + } + + if(p->as == AMOV || p->as == AMOVW || p->as == AFMOVS || p->as == AFMOVD) + if(regtyp(&p->to)) { + if(p->from.type == D_CONST || p->from.type == D_FCONST) + constprop(p->as, &p->from, &p->to, r->s1); + else if(regtyp(&p->from)) + if(p->from.type == p->to.type) { + if(copyprop(r)) { + excise(r); + t++; + } else + if(subprop(r) && copyprop(r)) { + excise(r); + t++; + } + } + if(regzer(&p->from)) + if(p->to.type == D_REG) { + p->from.type = D_REG; + p->from.reg = REGZERO; + if(copyprop(r)) { + excise(r); + t++; + } else + if(subprop(r) && copyprop(r)) { + excise(r); + t++; + } + } + } + } + if(t) + goto loop1; + + /* + * look for MOVB x,R; MOVB R,R + */ + for(r=firstr; r!=R; r=r->link) { + p = r->prog; + switch(p->as) { + default: + continue; + case AEOR: + /* + * EOR -1,x,y => MVN x,y + */ + if(p->from.type == D_CONST && p->from.offset == -1) { + p->as = AMVN; + p->from.type = D_REG; + if(p->reg != NREG) + p->from.reg = p->reg; + else + p->from.reg = p->to.reg; + p->reg = NREG; + } + continue; + case AEORW: + /* + * EOR -1,x,y => MVN x,y + */ + if(p->from.type == D_CONST && (p->from.offset&0xFFFFFFFF)==0xFFFFFFFF){ + p->as = AMVNW; + p->from.type = D_REG; + if(p->reg != NREG) + p->from.reg = p->reg; + else + p->from.reg = p->to.reg; + p->reg = NREG; + } + continue; + case AMOVH: + case AMOVHU: + case AMOVB: + case AMOVBU: + case AMOVW: + case AMOVWU: + if(p->to.type != D_REG) + continue; + break; + } + r1 = r->link; + if(r1 == R) + continue; + p1 = r1->prog; + if(p1->as != p->as) + continue; + if(p1->from.type != D_REG || p1->from.reg != p->to.reg) + continue; + if(p1->to.type != D_REG || p1->to.reg != p->to.reg) + continue; + excise(r1); + } + +#ifdef NOTYET + for(r=firstr; r!=R; r=r->link) { + p = r->prog; + switch(p->as) { + case AMOVW: + case AMOVB: + case AMOVBU: + if(p->from.type == D_OREG && p->from.offset == 0) + xtramodes(r, &p->from); + else if(p->to.type == D_OREG && p->to.offset == 0) + xtramodes(r, &p->to); + else + continue; + break; + case ACMP: + /* + * elide CMP $0,x if calculation of x can set condition codes + */ + if(p->from.type != D_CONST || p->from.offset != 0) + continue; + r2 = r->s1; + if(r2 == R) + continue; + t = r2->prog->as; + switch(t) { + default: + continue; + case ABEQ: + case ABNE: + case ABMI: + case ABPL: + break; + case ABGE: + t = ABPL; + break; + case ABLT: + t = ABMI; + break; + case ABHI: + t = ABNE; + break; + case ABLS: + t = ABEQ; + break; + } + r1 = r; + do + r1 = uniqp(r1); + while (r1 != R && r1->prog->as == ANOP); + if(r1 == R) + continue; + p1 = r1->prog; + if(p1->to.type != D_REG) + continue; + if(p1->to.reg != p->reg) + if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg)) + continue; + switch(p1->as) { + default: + continue; + case AMOVW: + if(p1->from.type != D_REG) + continue; + case AAND: + case AEOR: + case AORR: + case ABIC: + case AMVN: + case ASUB: + case AADD: + case AADC: + case ASBC: + break; + } + p1->scond |= C_SBIT; + r2->prog->as = t; + excise(r); + continue; + } + } +#endif + + /* + * software pipeline loads: + * + * insert a independent instruction (YYY) after a load: + * MOV v, r1 + * XXX r1, x + * YYY ... (not reading x or touching r1) + * --- + * MOV v, r1 + * YYY ... (not reading x or touching r1) + * XXX r1, x + */ + for(r=firstr; r!=R; r=r->link) { + p = r->prog; + switch(p->as){ + default: + continue; + case AFMOVD: + case AFMOVS: + if(p->from.type != D_OREG || p->to.type != D_FREG) + continue; + break; + case AMOV: + case AMOVW: + case AMOVWU: + case AMOVH: + case AMOVHU: + case AMOVB: + case AMOVBU: + if(p->from.type != D_OREG || p->to.type != D_REG) + continue; + break; + } + for(r1 = uniqs(r); r1 != R && r1->prog->as == ANOP; r1 = uniqs(r1)){ + if(uniqp(r1) == R){ + r1 = R; + break; + } + } + if(r1 == R || uniqp(r1) == R) + continue; + p1 = r1->prog; + if(!copyu(p1, &p->to, A)) + continue; + + for(r2 = uniqs(r1); r2 != R && r2->prog->as == ANOP; r2 = uniqs(r2)){ + if(uniqp(r2) == R){ + r2 = R; + break; + } + } + if(r2 == R || uniqp(r2) == R) + continue; + if(copyu(r2->prog, &p->to, A)) + continue; + + if(!independent(p1, r2->prog)) + continue; + if(!independent(r2->prog, p1)) + continue; + + /* + * if YYY happens to be a move from v, use register: + * MOV v, r1 + * MOV v, r2 + * --- + * MOV v, r1 + * MOV r1, r2 + */ + if(p->as == r2->prog->as + && (p->from.reg == REGSP || p->from.name > D_NONE) + && copyas(&p->from, &r2->prog->from)) + r2->prog->from = p->to; + + swapprog(p1, r2->prog); + t++; + } + if(t) + goto loop1; + +#ifdef XXX + predicate(); +#endif +} + +void +excise(Reg *r) +{ + Prog *p; + + p = r->prog; + p->as = ANOP; + p->scond = zprog.scond; + p->from = zprog.from; + p->from3 = zprog.from3; + p->to = zprog.to; + p->reg = zprog.reg; /**/ +} + +Reg* +uniqp(Reg *r) +{ + Reg *r1; + + r1 = r->p1; + if(r1 == R) { + r1 = r->p2; + if(r1 == R || r1->p2link != R) + return R; + } else + if(r->p2 != R) + return R; + return r1; +} + +Reg* +uniqs(Reg *r) +{ + Reg *r1; + + r1 = r->s1; + if(r1 == R) { + r1 = r->s2; + if(r1 == R) + return R; + } else + if(r->s2 != R) + return R; + return r1; +} + +/* + * convert references to $0 to references to ZR (REGZERO) + */ +int +regzer(Adr *a) +{ +return 0; + switch(a->type){ + case D_CONST: + return a->sym == S && a->offset == 0; + case D_REG: + return a->reg == REGZERO; + } + return 0; +} + +int +regtyp(Adr *a) +{ + + if(a->type == D_REG){ + if(a->reg == REGZERO) + return 0; + return 1; + } + if(a->type == D_FREG) + return 1; + return 0; +} + +/* + * the idea is to substitute + * one register for another + * from one MOV to another + * MOV a, R0 + * ADD b, R0 / no use of R1 + * MOV R0, R1 + * would be converted to + * MOV a, R1 + * ADD b, R1 + * MOV R1, R0 + * hopefully, then the former or latter MOV + * will be eliminated by copy propagation. + */ +int +subprop(Reg *r0) +{ + Prog *p; + Adr *v1, *v2; + Reg *r; + int t; + + p = r0->prog; + v1 = &p->from; + if(!regtyp(v1)) + return 0; + v2 = &p->to; + if(!regtyp(v2)) + return 0; + for(r=uniqp(r0); r!=R; r=uniqp(r)) { + if(uniqs(r) == R) + break; + p = r->prog; + switch(p->as) { + case ABL: + return 0; + + case ACMP: + case ACMN: + case AADC: + case AADCS: + case AADD: + case AADDS: + case ASUB: + case ASUBS: + case ALSL: + case ALSR: + case AASR: + case AROR: + case AORR: + case AAND: + case AANDS: + case AEOR: + case AMUL: + case ASDIV: + case AUDIV: + case AREM: + case AUREM: + + case ACMPW: + case ACMNW: + case AADCW: + case AADCSW: + case AADDSW: + case AADDW: + case ASUBSW: + case ASUBW: + case ALSLW: + case ALSRW: + case AASRW: + case ARORW: + case AORRW: + case AANDW: + case AANDSW: + case AEORW: + case AMULW: + case ASDIVW: + case AUDIVW: + case AREMW: + case AUREMW: + + case AFCMPS: + case AFCMPD: + case AFADDD: + case AFADDS: + case AFSUBD: + case AFSUBS: + case AFMULD: + case AFMULS: + case AFDIVD: + case AFDIVS: + if(p->to.type == v1->type) + if(p->to.reg == v1->reg) { + if(p->reg == NREG) + p->reg = p->to.reg; + goto gotit; + } + break; + + case ANEG: + case ANEGS: + case ANEGSW: + case ANEGW: + case ANGC: + case ANGCS: + case ANGCSW: + case ANGCW: + case AMVN: + case AMVNW: + case AFNEGD: + case AFNEGS: + case AFABSS: + case AFABSD: + case AFSQRTS: + case AFSQRTD: + case AFMOVS: + case AFMOVD: + case AMOVB: + case AMOVBU: + case AMOVH: + case AMOVHU: + case AMOVW: + case AMOVWU: + case AMOV: + case ASXTW: + if(p->to.type == v1->type) + if(p->to.reg == v1->reg) + goto gotit; + break; + + } + if(copyau(&p->from, v2) || + copyau1(p, v2) || + copyau(&p->to, v2)) + break; + if(copysub(&p->from, v1, v2, 0) || + copysub1(p, v1, v2, 0) || + copysub(&p->to, v1, v2, 0)) + break; + } + return 0; + +gotit: + copysub(&p->to, v1, v2, 1); + if(debug['P']) { + print("gotit: %D->%D\n%P", v1, v2, r->prog); + if(p->from.type == v2->type) + print(" excise"); + print("\n"); + } + for(r=uniqs(r); r!=r0; r=uniqs(r)) { + p = r->prog; + copysub(&p->from, v1, v2, 1); + copysub1(p, v1, v2, 1); + copysub(&p->to, v1, v2, 1); + if(debug['P']) + print("%P\n", r->prog); + } + t = v1->reg; + v1->reg = v2->reg; + v2->reg = t; + if(debug['P']) + print("%P last\n", r->prog); + return 1; +} + +/* + * The idea is to remove redundant copies. + * v1->v2 F=0 + * (use v2 s/v2/v1/)* + * set v1 F=1 + * use v2 return fail + * ----------------- + * v1->v2 F=0 + * (use v2 s/v2/v1/)* + * set v1 F=1 + * set v2 return success + */ +int +copyprop(Reg *r0) +{ + Prog *p; + Adr *v1, *v2; + Reg *r; + + p = r0->prog; + v1 = &p->from; + v2 = &p->to; + if(copyas(v1, v2)) + return 1; + for(r=firstr; r!=R; r=r->link) + r->active = 0; + return copy1(v1, v2, r0->s1, 0); +} + +int +copy1(Adr *v1, Adr *v2, Reg *r, int f) +{ + int t; + Prog *p; + + if(r->active) { + if(debug['P']) + print("act set; return 1\n"); + return 1; + } + r->active = 1; + if(debug['P']) + print("copy %D->%D f=%d\n", v1, v2, f); + for(; r != R; r = r->s1) { + p = r->prog; + if(debug['P']) + print("%P", p); + if(!f && uniqp(r) == R) { + f = 1; + if(debug['P']) + print("; merge; f=%d", f); + } + t = copyu(p, v2, A); + switch(t) { + case 2: /* rar, cant split */ + if(debug['P']) + print("; %D rar; return 0\n", v2); + return 0; + + case 3: /* set */ + if(debug['P']) + print("; %D set; return 1\n", v2); + return 1; + + case 1: /* used, substitute */ + case 4: /* use and set */ + if(f) { + if(!debug['P']) + return 0; + if(t == 4) + print("; %D used+set and f=%d; return 0\n", v2, f); + else + print("; %D used and f=%d; return 0\n", v2, f); + return 0; + } + if(copyu(p, v2, v1)) { + if(debug['P']) + print("; sub fail; return 0\n"); + return 0; + } + if(debug['P']) + print("; sub%D/%D", v2, v1); + if(t == 4) { + if(debug['P']) + print("; %D used+set; return 1\n", v2); + return 1; + } + break; + } + if(!f) { + t = copyu(p, v1, A); + if(!f && (t == 2 || t == 3 || t == 4)) { + f = 1; + if(debug['P']) + print("; %D set and !f; f=%d", v1, f); + } + } + if(debug['P']) + print("\n"); + if(r->s2) + if(!copy1(v1, v2, r->s2, f)) + return 0; + } + return 1; +} + +/* + * The idea is to remove redundant constants. + * $c1->v1 + * ($c1->v2 s/$c1/v1)* + * set v1 return + * The v1->v2 should be eliminated by copy propagation. + */ +void +constprop(int as, Adr *c1, Adr *v1, Reg *r) +{ + Prog *p; + + /* should be encodable with ZR */ + if(c1->type == D_CONST && c1->sym == S && c1->offset == 0) + return; + + if(debug['C']) + print("constprop %D->%D\n", c1, v1); + + for(; r != R; r = r->s1) { + p = r->prog; + if(debug['C']) + print("%P", p); + if(uniqp(r) == R) { + if(debug['C']) + print("; merge; return\n"); + return; + } + if((p->as == as || p->as == AMOVW || p->as == AMOVWU + || (p->as == AMOV && c1->offset >= 0)) /* immediate loads do not sign extend */ + && copyas(&p->from, c1)) { + if(debug['C']) + print("; sub%D/%D", &p->from, v1); + p->from = *v1; + } else if(copyu(p, v1, A) > 1) { + if(debug['C']) + print("; %Dset; return\n", v1); + return; + } + if(debug['C']) + print("\n"); + if(r->s2) + constprop(as, c1, v1, r->s2); + } +} + +/* + * Registerize loads from local variables: + * + * MOV a, v + * ... (a and v not touched) + * MOV v, b + * ---- + * MOV a, v + * ... (a and v not touched) + * MOV a, b + */ +static void +storeprop(int as, Adr *a, Adr *v, Reg *r) +{ + Prog *p; + + for(; r != R; r = r->s1) { + if(uniqp(r) == R) + return; + + p = r->prog; + if((as == p->as + || (as == AMOV && (p->as == AMOVW || p->as == AMOVWU)) + || (as == AMOVW && p->as == AMOVWU) + || (as == AMOVWU && p->as == AMOVW)) + && copyas(&p->from, v)){ + if(p->as == AMOVW) + p->as = ASXTW; + p->from = *a; + continue; + } + + if(copyu(p, a, A) > 1) + return; + + if(p->to.type == D_OREG || p->to.type == D_XPRE || p->to.type == D_XPOST) + if(p->to.name <= D_NONE || copyas(&p->to, v)) + return; + + if(r->s2) + storeprop(as, a, v, r->s2); + } +} + +/* + * ALSL x,y,w + * .. (not use w, not set x y w) + * AXXX w,a,b (a != w) + * .. (not use w) + * (set w) + * ----------- changed to + * .. + * AXXX (x<prog; + if(p->to.type != D_REG) + FAIL("BOTCH: result not reg"); + n = p->to.reg; + a = zprog.from; + if(p->reg != NREG && p->reg != p->to.reg) { + a.type = D_REG; + a.reg = p->reg; + } + if(debug['H']) + print("shiftprop\n%P", p); + r1 = r; + for(;;) { + /* find first use of shift result; abort if shift operands or result are changed */ + r1 = uniqs(r1); + if(r1 == R) + FAIL("branch"); + if(uniqp(r1) == R) + FAIL("merge"); + p1 = r1->prog; + if(debug['H']) + print("\n%P", p1); + switch(copyu(p1, &p->to, A)) { + case 0: /* not used or set */ + if((p->from.type == D_REG && copyu(p1, &p->from, A) > 1) || + (a.type == D_REG && copyu(p1, &a, A) > 1)) + FAIL("args modified"); + continue; + case 3: /* set, not used */ + FAIL("BOTCH: noref"); + } + break; + } + /* check whether substitution can be done */ + switch(p1->as) { + case ABIC: + case ACMP: + case ACMN: + if(p1->reg == n) + FAIL("can't swap"); + if(p1->reg == NREG && p1->to.reg == n) + FAIL("shift result used twice"); + case AMVN: + if(p1->from.type == D_SHIFT) + FAIL("shift result used in shift"); + if(p1->from.type != D_REG || p1->from.reg != n) + FAIL("BOTCH: where is it used?"); + break; + } + /* check whether shift result is used subsequently */ + p2 = p1; + if(p1->to.reg != n) + for (;;) { + r1 = uniqs(r1); + if(r1 == R) + FAIL("inconclusive"); + p1 = r1->prog; + if(debug['H']) + print("\n%P", p1); + switch(copyu(p1, &p->to, A)) { + case 0: /* not used or set */ + continue; + case 3: /* set, not used */ + break; + default:/* used */ + FAIL("reused"); + } + break; + } + /* make the substitution */ + p2->from.type = D_SHIFT; + p2->from.reg = NREG; + o = p->reg; + if(o == NREG) + o = p->to.reg; + switch(p->from.type){ + case D_CONST: + o |= (p->from.offset&0x3f)<<7; + break; + case D_REG: + o |= (1<<4) | (p->from.reg<<8); + break; + } + switch(p->as){ + case ALSL: + o |= 0<<5; + break; + case ALSR: + o |= 1<<5; + break; + case AASR: + o |= 2<<5; + break; + } + p2->from.offset = o; + if(debug['H']) + print("\t=>%P\tSUCCEED\n", p2); + return 1; +} + +Reg* +findset(Reg *r, Adr *v) +{ + + Reg *r1; + + for(r1=uniqp(r); r1!=R; r=r1,r1=uniqp(r)) { + if(uniqs(r1) != r) + return R; + if(copyu(r1->prog, v, A) > 1) + return r1; + } + return R; +} + +Reg* +findpre(Reg *r, Adr *v) +{ + Reg *r1; + + for(r1=uniqp(r); r1!=R; r=r1,r1=uniqp(r)) { + if(uniqs(r1) != r) + return R; + switch(copyu(r1->prog, v, A)) { + case 1: /* used */ + case 2: /* read-alter-rewrite */ + return R; + case 3: /* set */ + case 4: /* set and used */ + return r1; + } + } + return R; +} + +Reg* +findinc(Reg *r, Reg *r2, Adr *v) +{ + Reg *r1; + Prog *p; + + + for(r1=uniqs(r); r1!=R && r1!=r2; r=r1,r1=uniqs(r)) { + if(uniqp(r1) != r) + return R; + switch(copyu(r1->prog, v, A)) { + case 0: /* not touched */ + continue; + case 4: /* set and used */ + p = r1->prog; + if(p->as == AADD) + if(p->from.type == D_CONST) + if(p->from.offset > -256 && p->from.offset < 256) + return r1; + default: + return R; + } + } + return R; +} + +int +nochange(Reg *r, Reg *r2, Prog *p) +{ + Adr a[3]; + int i, n; + + if(r == r2) + return 1; + n = 0; + if(p->reg != NREG && p->reg != p->to.reg) { + a[n].type = D_REG; + a[n++].reg = p->reg; + } + switch(p->from.type) { + case D_SHIFT: + a[n].type = D_REG; + a[n++].reg = p->from.offset&0xf; + case D_REG: + a[n].type = D_REG; + a[n++].reg = p->from.reg; + } + if(n == 0) + return 1; + for(; r!=R && r!=r2; r=uniqs(r)) { + p = r->prog; + for(i=0; i 1) + return 0; + } + return 1; +} + +int +findu1(Reg *r, Adr *v) +{ + for(; r != R; r = r->s1) { + if(r->active) + return 0; + r->active = 1; + switch(copyu(r->prog, v, A)) { + case 1: /* used */ + case 2: /* read-alter-rewrite */ + case 4: /* set and used */ + return 1; + case 3: /* set */ + return 0; + } + if(r->s2) + if (findu1(r->s2, v)) + return 1; + } + return 0; +} + +int +finduse(Reg *r, Adr *v) +{ + Reg *r1; + + for(r1=firstr; r1!=R; r1=r1->link) + r1->active = 0; + return findu1(r, v); +} + +#ifdef NOTYET +int +xtramodes(Reg *r, Adr *a) +{ + Reg *r1, *r2, *r3; + Prog *p, *p1; + Adr v; + + p = r->prog; + if(debug['h'] && p->as == AMOVB && p->from.type == D_OREG) /* byte load */ + return 0; + v = *a; + v.type = D_REG; + r1 = findpre(r, &v); + if(r1 != R) { + p1 = r1->prog; + if(p1->to.type == D_REG && p1->to.reg == v.reg) + switch(p1->as) { + case AADD: + if(p1->from.type == D_REG || + (p1->from.type == D_SHIFT && (p1->from.offset&(1<<4)) == 0 && + (p->as != AMOVB || (a == &p->from && (p1->from.offset&~0xf) == 0))) || + (p1->from.type == D_CONST && + p1->from.offset > -4096 && p1->from.offset < 4096)) + if(nochange(uniqs(r1), r, p1)) { + if(a != &p->from || v.reg != p->to.reg) + if (finduse(r->s1, &v)) { + if(p1->reg == NREG || p1->reg == v.reg) + /* pre-indexing */ + p->scond |= C_WBIT; + else return 0; + } + switch (p1->from.type) { + case D_REG: + /* register offset */ + a->type = D_SHIFT; + a->offset = p1->from.reg; + break; + case D_SHIFT: + /* scaled register offset */ + a->type = D_SHIFT; + case D_CONST: + /* immediate offset */ + a->offset = p1->from.offset; + break; + } + if(p1->reg != NREG) + a->reg = p1->reg; + excise(r1); + return 1; + } + break; + case AMOVW: + if(p1->from.type == D_REG) + if((r2 = findinc(r1, r, &p1->from)) != R) { + for(r3=uniqs(r2); r3->prog->as==ANOP; r3=uniqs(r3)) + ; + if(r3 == r) { + /* post-indexing */ + p1 = r2->prog; + a->reg = p1->to.reg; + a->offset = p1->from.offset; + p->scond |= C_PBIT; + if(!finduse(r, &r1->prog->to)) + excise(r1); + excise(r2); + return 1; + } + } + break; + } + } + if(a != &p->from || a->reg != p->to.reg) + if((r1 = findinc(r, R, &v)) != R) { + /* post-indexing */ + p1 = r1->prog; + a->offset = p1->from.offset; + p->scond |= C_PBIT; + excise(r1); + return 1; + } + return 0; +} +#endif + +/* + * return + * 1 if v only used (and substitute), + * 2 if read-alter-rewrite + * 3 if set + * 4 if set and used + * 0 otherwise (not touched) + */ +int +copyu(Prog *p, Adr *v, Adr *s) +{ + + switch(p->as) { + + default: + if(debug['P']) + print(" (unk)"); + return 2; + + case ANOP: /* read, write */ + case AFMOVS: + case AFMOVD: + case AMOVH: + case AMOVHU: + case AMOVB: + case AMOVBU: + case AMOVW: + case AMOVWU: + case ASXTW: + case AMOV: + case AMVN: + case AMVNW: + case ANEG: + case ANEGS: + case ANEGW: + case ANEGSW: + case ANGC: + case ANGCS: + case ANGCW: + case ANGCSW: + case AFCVTSD: + case AFCVTDS: + case AFCVTZSD: + case AFCVTZSDW: + case AFCVTZSS: + case AFCVTZSSW: + case AFCVTZUD: + case AFCVTZUDW: + case AFCVTZUS: + case AFCVTZUSW: + case ASCVTFD: + case ASCVTFS: + case ASCVTFWD: + case ASCVTFWS: + case AUCVTFD: + case AUCVTFS: + case AUCVTFWD: + case AUCVTFWS: + case AFNEGD: + case AFNEGS: + case AFABSD: + case AFABSS: + case AFSQRTD: + case AFSQRTS: + case ACASE: +#ifdef YYY + if(p->scond&(C_WBIT|C_PBIT)) + if(v->type == D_REG) { + if(p->from.type == D_OREG || p->from.type == D_SHIFT) { + if(p->from.reg == v->reg) + return 2; + } else { + if(p->to.reg == v->reg) + return 2; + } + } +#endif + if(s != A) { + if(copysub(&p->from, v, s, 1)) + return 1; + if(!copyas(&p->to, v)) + if(copysub(&p->to, v, s, 1)) + return 1; + return 0; + } + if(copyas(&p->to, v)) { + if(copyau(&p->from, v)) + return 4; + return 3; + } + if(copyau(&p->from, v)) + return 1; + if(copyau(&p->to, v)) + return 1; + return 0; + + + case AADD: /* read, read, write */ + case AADDW: + case AADDS: + case AADDSW: + case ASUB: + case ASUBW: + case ASUBS: + case ASUBSW: + if(0 && p->from.type == D_CONST){ + if(s != A && regzer(s)) + return 4; /* add/sub $c,r,r -> r31 is sp not zr, don't touch */ + } + + case ALSL: + case ALSLW: + case ALSR: + case ALSRW: + case AASR: + case AASRW: + case AROR: + case ARORW: + case AORR: + case AORRW: + case AAND: + case AANDW: + case AEOR: + case AEORW: + case AMUL: + case AMULW: + case AUMULL: + case AREM: + case AREMW: + case ASDIV: + case ASDIVW: + case AUDIV: + case AUDIVW: + case AUREM: + case AUREMW: + case AFADDS: + case AFADDD: + case AFSUBS: + case AFSUBD: + case AFMULS: + case AFMULD: + case AFDIVS: + case AFDIVD: + if(s != A) { + if(copysub(&p->from, v, s, 1)) + return 1; + if(copysub1(p, v, s, 1)) + return 1; + if(!copyas(&p->to, v)) + if(copysub(&p->to, v, s, 1)) + return 1; + return 0; + } + if(copyas(&p->to, v)) { + if(p->reg == NREG) + p->reg = p->to.reg; + if(copyau(&p->from, v)) + return 4; + if(copyau1(p, v)) + return 4; + return 3; + } + if(copyau(&p->from, v)) + return 1; + if(copyau1(p, v)) + return 1; + if(copyau(&p->to, v)) + return 1; + return 0; + + case ABEQ: /* read, read */ + case ABNE: + case ABCS: + case ABHS: + case ABCC: + case ABLO: + case ABMI: + case ABPL: + case ABVS: + case ABVC: + case ABHI: + case ABLS: + case ABGE: + case ABLT: + case ABGT: + case ABLE: + + case AFCMPS: + case AFCMPD: + case ACMP: + case ACMPW: + case ACMN: + case ACMNW: + case ACBZ: + case ACBZW: + case ACBNZ: + case ACBNZW: + case ATBZ: + case ATBNZ: + if(s != A) { + if(copysub(&p->from, v, s, 1)) + return 1; + return copysub1(p, v, s, 1); + } + if(copyau(&p->from, v)) + return 1; + if(copyau1(p, v)) + return 1; + return 0; + + case AB: /* funny */ + if(s != A) { + if(copysub(&p->to, v, s, 1)) + return 1; + return 0; + } + if(copyau(&p->to, v)) + return 1; + return 0; + + case ARET: + case ARETURN: /* funny */ + if(v->type == D_REG) + if(v->reg == REGRET) + return 2; + if(v->type == D_FREG) + if(v->reg == FREGRET) + return 2; + + case ABL: /* funny */ + if(v->type == D_REG) { + if(v->reg <= REGEXT && v->reg > exregoffset) + return 2; + if(v->reg == REGARG) + return 2; + } + if(v->type == D_FREG) + if(v->reg <= FREGEXT && v->reg > exfregoffset) + return 2; + + if(s != A) { + if(copysub(&p->to, v, s, 1)) + return 1; + return 0; + } + if(copyau(&p->to, v)) + return 4; + return 3; + + case ATEXT: /* funny */ + if(v->type == D_REG) + if(v->reg == REGARG) + return 3; + return 0; + } +} + +int +a2type(Prog *p) +{ + + switch(p->as) { + + case ACMP: + case ACMPW: + case ACMN: + case ACMNW: + case ACBZ: + case ACBZW: + case ACBNZ: + case ACBNZW: + case ATBZ: + case ATBNZ: + + case AADD: + case AADDW: + case AADDS: + case AADDSW: + case ASUB: + case ASUBS: + case ASUBSW: + case ASUBW: + case ALSL: + case ALSLW: + case ALSR: + case ALSRW: + case AASR: + case AASRW: + case AROR: + case ARORW: + case AORR: + case AORRW: + case AAND: + case AANDW: + case AANDS: + case AANDSW: + case AEOR: + case AEORW: + case AMUL: + case AMULW: + case AUMULL: + case AREM: + case AREMW: + case ASDIV: + case ASDIVW: + case AUDIV: + case AUDIVW: + case AUREM: + case AUREMW: + return D_REG; + + case AFCMPS: + case AFCMPD: + + case AFADDS: + case AFADDD: + case AFSUBS: + case AFSUBD: + case AFMULS: + case AFMULD: + case AFDIVS: + case AFDIVD: + return D_FREG; + } + return D_NONE; +} + +/* + * direct reference, + * could be set/use depending on + * semantics + */ +int +copyas(Adr *a, Adr *v) +{ + if(regtyp(v)) { + if(a->type == v->type) + if(a->reg == v->reg) + return 1; + } else { + if(a->type == v->type) + if(a->name == v->name) + if(a->sym == v->sym) + if(a->reg == v->reg){ + if(a->type == D_FCONST){ + if(a->dval == v->dval) + return 1; + } else if(a->offset == v->offset) + return 1; + } + } + return 0; +} + +/* + * either direct or indirect + */ +int +copyau(Adr *a, Adr *v) +{ + if(copyas(a, v)) + return 1; + if(v->type == D_REG) { + if(a->type == D_OREG) { + if(v->reg == a->reg) + return 1; + } else if(a->type == D_SHIFT) { + if(((a->offset>>16)&0x1F) == v->reg) + return 1; + } else if(a->type == D_EXTREG) { + if(a->reg == v->reg || ((a->offset>>16)&0x1F) == v->reg) + return 1; + } + } + return 0; +} + +int +copyau1(Prog *p, Adr *v) +{ + + if(regtyp(v)) { + if(a2type(p) == v->type) + if(p->reg == v->reg) { + if(a2type(p) != v->type) + print("botch a2type %P\n", p); + return 1; + } + } + return 0; +} + +/* + * substitute s for v in a + * return failure to substitute + */ +int +copysub(Adr *a, Adr *v, Adr *s, int f) +{ + + if(f) + if(copyau(a, v)) { + if(a->type == D_SHIFT) { + if(((a->offset>>16)&0x1F) == v->reg) + a->offset = (a->offset&~(0x1F<<16))|(s->reg<<16); + } else + a->reg = s->reg; + } + return 0; +} + +int +copysub1(Prog *p1, Adr *v, Adr *s, int f) +{ + + if(f) + if(copyau1(p1, v)) + p1->reg = s->reg; + return 0; +} + +struct { + int opcode; + int notopcode; + int scond; + int notscond; +} predinfo[] = { + { ABEQ, ABNE, 0x0, 0x1, }, + { ABNE, ABEQ, 0x1, 0x0, }, + { ABCS, ABCC, 0x2, 0x3, }, + { ABHS, ABLO, 0x2, 0x3, }, + { ABCC, ABCS, 0x3, 0x2, }, + { ABLO, ABHS, 0x3, 0x2, }, + { ABMI, ABPL, 0x4, 0x5, }, + { ABPL, ABMI, 0x5, 0x4, }, + { ABVS, ABVC, 0x6, 0x7, }, + { ABVC, ABVS, 0x7, 0x6, }, + { ABHI, ABLS, 0x8, 0x9, }, + { ABLS, ABHI, 0x9, 0x8, }, + { ABGE, ABLT, 0xA, 0xB, }, + { ABLT, ABGE, 0xB, 0xA, }, + { ABGT, ABLE, 0xC, 0xD, }, + { ABLE, ABGT, 0xD, 0xC, }, +}; + +typedef struct { + Reg *start; + Reg *last; + Reg *end; + int len; +} Joininfo; + +enum { + Join, + Split, + End, + Branch, + Setcond, + Toolong +}; + +enum { + Falsecond, + Truecond, + Delbranch, + Keepbranch +}; + +int +isbranch(Prog *p) +{ + return (ABEQ <= p->as) && (p->as <= ABLE); +} + +int +predicable(Prog *p) +{ + if (isbranch(p) + || p->as == ANOP + || p->as == AXXX + || p->as == ADATA + || p->as == AGLOBL + || p->as == AGOK + || p->as == AHISTORY + || p->as == ANAME + || p->as == ASIGNAME + || p->as == ATEXT + || p->as == AWORD + || p->as == ADYNT + || p->as == AINIT + || p->as == ABCASE + || p->as == ACASE) + return 0; + return 1; +} + +/* + * Depends on an analysis of the encodings performed by 5l. + * These seem to be all of the opcodes that lead to the "S" bit + * being set in the instruction encodings. + * + * C_SBIT may also have been set explicitly in p->scond. + */ +int +modifiescpsr(Prog *p) +{ +// return (p->scond&C_SBIT) + return 1 + || p->as == ATST + || p->as == ACMN + || p->as == ACMP + || p->as == AUMULL + || p->as == AUDIV + || p->as == AMUL + || p->as == ASDIV + || p->as == AREM + || p->as == AUREM + || p->as == ABL; +} + +/* + * Find the maximal chain of instructions starting with r which could + * be executed conditionally + */ +int +joinsplit(Reg *r, Joininfo *j) +{ + j->start = r; + j->last = r; + j->len = 0; + do { + if (r->p2 && (r->p1 || r->p2->p2link)) { + j->end = r; + return Join; + } + if (r->s1 && r->s2) { + j->end = r; + return Split; + } + j->last = r; + if (r->prog->as != ANOP) + j->len++; + if (!r->s1 && !r->s2) { + j->end = r->link; + return End; + } + if (r->s2) { + j->end = r->s2; + return Branch; + } + if (modifiescpsr(r->prog)) { + j->end = r->s1; + return Setcond; + } + r = r->s1; + } while (j->len < 4); + j->end = r; + return Toolong; +} + +Reg * +successor(Reg *r) +{ + if (r->s1) + return r->s1; + else + return r->s2; +} + +#ifdef XXX +void +applypred(Reg *rstart, Joininfo *j, int cond, int branch) +{ + int pred; + Reg *r; + + if(j->len == 0) + return; + if (cond == Truecond) + pred = predinfo[rstart->prog->as - ABEQ].scond; + else + pred = predinfo[rstart->prog->as - ABEQ].notscond; + + for (r = j->start; ; r = successor(r)) { + if (r->prog->as == AB) { + if (r != j->last || branch == Delbranch) + excise(r); + else { + if (cond == Truecond) + r->prog->as = predinfo[rstart->prog->as - ABEQ].opcode; + else + r->prog->as = predinfo[rstart->prog->as - ABEQ].notopcode; + } + } + else if (predicable(r->prog)) + r->prog->scond = (r->prog->scond&~C_SCOND)|pred; + if (r->s1 != r->link) { + r->s1 = r->link; + r->link->p1 = r; + } + if (r == j->last) + break; + } +} + + +void +predicate(void) +{ + Reg *r; + int t1, t2; + Joininfo j1, j2; + + for(r=firstr; r!=R; r=r->link) { + if (isbranch(r->prog)) { + t1 = joinsplit(r->s1, &j1); + t2 = joinsplit(r->s2, &j2); + if(j1.last->link != j2.start) + continue; + if(j1.end == j2.end) + if((t1 == Branch && (t2 == Join || t2 == Setcond)) || + (t2 == Join && (t1 == Join || t1 == Setcond))) { + applypred(r, &j1, Falsecond, Delbranch); + applypred(r, &j2, Truecond, Delbranch); + excise(r); + continue; + } + if(t1 == End || t1 == Branch) { + applypred(r, &j1, Falsecond, Keepbranch); + excise(r); + continue; + } + } + } +} +#endif --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/reg.c Tue Dec 30 17:28:54 2025 @@ -0,0 +1,1184 @@ +#include "gc.h" + +void addsplits(void); + +Reg* +rega(void) +{ + Reg *r; + + r = freer; + if(r == R) { + r = alloc(sizeof(*r)); + } else + freer = r->link; + + *r = zreg; + return r; +} + +int +rcmp(void *a1, void *a2) +{ + Rgn *p1, *p2; + int c1, c2; + + p1 = (Rgn*)a1; + p2 = (Rgn*)a2; + c1 = p2->cost; + c2 = p1->cost; + if(c1 -= c2) + return c1; + return p2->varno - p1->varno; +} + +void +regopt(Prog *p) +{ + static int maxregion; + static Rgn *region; + Rgn *rgp; + Reg *r, *r1, *r2; + Prog *p1; + int i, z, nregion; + long initpc, val, npc; + ulong vreg; + Bits bit; + struct + { + long m; + long c; + Reg* p; + } log5[6], *lp; + + firstr = R; + lastr = R; + nvar = 0; + regbits = 0; + for(z=0; zm = val; + lp->c = 0; + lp->p = R; + val /= 5L; + lp++; + } + val = 0; + for(; p != P; p = p->link) { + switch(p->as) { + case ADATA: + case AGLOBL: + case ANAME: + case ASIGNAME: + continue; + } + r = rega(); + if(firstr == R) { + firstr = r; + lastr = r; + } else { + lastr->link = r; + r->p1 = lastr; + lastr->s1 = r; + lastr = r; + } + r->prog = p; + r->pc = val; + val++; + + lp = log5; + for(i=0; i<5; i++) { + lp->c--; + if(lp->c <= 0) { + lp->c = lp->m; + if(lp->p != R) + lp->p->log5 = r; + lp->p = r; + (lp+1)->c = 0; + break; + } + lp++; + } + + r1 = r->p1; + if(r1 != R) + switch(r1->prog->as) { + case ARETURN: + case ARET: + case AB: + case AERET: + r->p1 = R; + r1->s1 = R; + } + + /* + * left side always read + */ + bit = mkvar(&p->from, p->as==AMOVW || p->as == AMOVWU || p->as == AMOV); + for(z=0; zuse1.b[z] |= bit.b[z]; + + /* + * right side depends on opcode + */ + bit = mkvar(&p->to, 0); + if(bany(&bit)) + switch(p->as) { + default: + diag(Z, "reg: unknown asop: %A", p->as); + break; + + /* + * right side write + */ + case ANOP: + case AMOV: + case AMOVB: + case AMOVBU: + case AMOVH: + case AMOVHU: + case AMOVW: + case AMOVWU: + case ASXTW: + case AFMOVS: + case AFCVTSD: + case AFMOVD: + case AFCVTDS: + for(z=0; zset.b[z] |= bit.b[z]; + break; + + /* + * funny + */ + case ABL: + for(z=0; zlink) { + p = r->prog; + if(p->to.type == D_BRANCH) { + val = p->to.offset - initpc; + r1 = firstr; + while(r1 != R) { + r2 = r1->log5; + if(r2 != R && val >= r2->pc) { + r1 = r2; + continue; + } + if(r1->pc == val) + break; + r1 = r1->link; + } + if(r1 == R) { + nearln = p->lineno; + diag(Z, "ref not found\n%P", p); + continue; + } + if(r1 == r) { + nearln = p->lineno; + diag(Z, "ref to self\n%P", p); + continue; + } + r->s2 = r1; + r->p2link = r1->p2; + r1->p2 = r; + } + } + if(debug['R']) { + p = firstr->prog; + print("\n%L %D\n", p->lineno, &p->from); + } + + /* + * pass 2.5 + * find looping structure + */ + for(r = firstr; r != R; r = r->link) + r->active = 0; + change = 0; + loopit(firstr, npc); + + /* + * pass 3 + * iterate propagating usage + * back until flow graph is complete + */ +loop1: + change = 0; + for(r = firstr; r != R; r = r->link) + r->active = 0; + for(r = firstr; r != R; r = r->link) + if(r->prog->as == ARET || r->prog->as == ARETURN) + prop(r, zbits, zbits); +loop11: + /* pick up unreachable code */ + i = 0; + for(r = firstr; r != R; r = r1) { + r1 = r->link; + if(r1 && r1->active && !r->active) { + prop(r, zbits, zbits); + i = 1; + } + } + if(i) + goto loop11; + if(change) + goto loop1; + + + /* + * pass 4 + * iterate propagating register/variable synchrony + * forward until graph is complete + */ +loop2: + change = 0; + for(r = firstr; r != R; r = r->link) + r->active = 0; + synch(firstr, zbits); + if(change) + goto loop2; + + addsplits(); + + if(debug['R'] && debug['v']) { + print("\nprop structure:\n"); + for(r = firstr; r != R; r = r->link) { + print("%ld:%P", r->loop, r->prog); + for(z=0; zset.b[z] | + r->refahead.b[z] | r->calahead.b[z] | + r->refbehind.b[z] | r->calbehind.b[z] | + r->use1.b[z] | r->use2.b[z]; + if(bany(&bit)) { + print("\t"); + if(bany(&r->use1)) + print(" u1=%B", r->use1); + if(bany(&r->use2)) + print(" u2=%B", r->use2); + if(bany(&r->set)) + print(" st=%B", r->set); + if(bany(&r->refahead)) + print(" ra=%B", r->refahead); + if(bany(&r->calahead)) + print(" ca=%B", r->calahead); + if(bany(&r->refbehind)) + print(" rb=%B", r->refbehind); + if(bany(&r->calbehind)) + print(" cb=%B", r->calbehind); + } + print("\n"); + } + } + + /* + * pass 5 + * isolate regions + * calculate costs (paint1) + */ + r = firstr; + if(r) { + for(z=0; zrefahead.b[z] | r->calahead.b[z]) & + ~(externs.b[z] | params.b[z] | addrs.b[z] | consts.b[z]); + if(bany(&bit)) { + nearln = r->prog->lineno; + warn(Z, "used and not set: %B", bit); + if(debug['R'] && !debug['w']) + print("used and not set: %B\n", bit); + } + } + + for(r = firstr; r != R; r = r->link) + r->act = zbits; + nregion = 0; + if(region == nil){ + maxregion = 300; + region = alloc(maxregion * sizeof(Rgn)); + } + for(r = firstr; r != R; r = r->link) { + for(z=0; zset.b[z] & + ~(r->refahead.b[z] | r->calahead.b[z] | addrs.b[z]); + if(bany(&bit)) { + nearln = r->prog->lineno; + warn(Z, "set and not used: %B", bit); + if(debug['R']) + print("set and not used: %B\n", bit); + excise(r); + } + for(z=0; zact.b[z] | addrs.b[z]); + while(bany(&bit)) { + i = bnum(bit); + rgp = ®ion[nregion]; + rgp->enter = r; + rgp->varno = i; + change = 0; + if(debug['R'] && debug['v']) + print("\n"); + paint1(r, i); + bit.b[i/32] &= ~(1L<<(i%32)); + if(change <= 0) { + if(debug['R']) + print("%L $%d: %B\n", + r->prog->lineno, change, blsh(i)); + continue; + } + rgp->cost = change; + nregion++; + if(nregion >= maxregion) { + region = allocn(region, maxregion * sizeof(Rgn), 128*sizeof(Rgn)); + maxregion += 128; + } + } + } + qsort(region, nregion, sizeof(region[0]), rcmp); + + /* + * pass 6 + * determine used registers (paint2) + * replace code (paint3) + */ + rgp = region; + for(i=0; ivarno); + vreg = paint2(rgp->enter, rgp->varno); + vreg = allreg(vreg, rgp); + if(debug['R']) { + if(rgp->regno >= NREG) + print("%L $%d F%d: %B\n", + rgp->enter->prog->lineno, + rgp->cost, + rgp->regno-NREG, + bit); + else + print("%L $%d R%d: %B\n", + rgp->enter->prog->lineno, + rgp->cost, + rgp->regno, + bit); + } + if(rgp->regno != 0) + paint3(rgp->enter, rgp->varno, vreg, rgp->regno); + rgp++; + } + /* + * pass 7 + * peep-hole on basic block + */ + if(!debug['R'] || debug['P']) + peep(); + + /* + * pass 8 + * recalculate pc + */ + val = initpc; + for(r = firstr; r != R; r = r1) { + r->pc = val; + p = r->prog; + p1 = P; + r1 = r->link; + if(r1 != R) + p1 = r1->prog; + for(; p != p1; p = p->link) { + switch(p->as) { + default: + val++; + break; + + case ANOP: + case ADATA: + case AGLOBL: + case ANAME: + case ASIGNAME: + break; + } + } + } + pc = val; + + /* + * fix up branches + */ + if(debug['R']) + if(bany(&addrs)) + print("addrs: %B\n", addrs); + + r1 = 0; /* set */ + for(r = firstr; r != R; r = r->link) { + p = r->prog; + if(p->to.type == D_BRANCH) + p->to.offset = r->s2->pc; + r1 = r; + } + + /* + * last pass + * eliminate nops + * free aux structures + */ + for(p = firstr->prog; p != P; p = p->link){ + while(p->link && p->link->as == ANOP) + p->link = p->link->link; + } + if(r1 != R) { + r1->link = freer; + freer = firstr; + } +} + +void +addsplits(void) +{ + Reg *r, *r1; + int z, i; + Bits bit; + + for(r = firstr; r != R; r = r->link) { + if(r->loop > 1) + continue; + if(r->prog->as == ABL) + continue; + for(r1 = r->p2; r1 != R; r1 = r1->p2link) { + if(r1->loop <= 1) + continue; + for(z=0; zcalbehind.b[z] & + (r->refahead.b[z] | r->use1.b[z] | r->use2.b[z]) & + ~(r->calahead.b[z] & addrs.b[z]); + while(bany(&bit)) { + i = bnum(bit); + bit.b[i/32] &= ~(1L << (i%32)); + } + } + } +} + +/* + * add mov b,rn + * just after r + */ +void +addmove(Reg *r, int bn, int rn, int f) +{ + Prog *p, *p1; + Adr *a; + Var *v; + + p1 = alloc(sizeof(*p1)); + *p1 = zprog; + p = r->prog; + + p1->link = p->link; + p->link = p1; + p1->lineno = p->lineno; + + v = var + bn; + + a = &p1->to; + a->sym = v->sym; + a->name = v->name; + a->offset = v->offset; + a->etype = v->etype; + a->type = D_OREG; + if(a->etype == TARRAY || a->sym == S) + a->type = D_CONST; + + p1->as = AMOVW; + if(v->etype == TCHAR || v->etype == TUCHAR) + p1->as = AMOVB; + if(v->etype == TSHORT || v->etype == TUSHORT) + p1->as = AMOVH; + if(v->etype == TVLONG || v->etype == TUVLONG || v->etype == TIND) + p1->as = AMOV; + if(v->etype == TFLOAT) + p1->as = AFMOVS; + if(v->etype == TDOUBLE) + p1->as = AFMOVD; + + p1->from.type = D_REG; + p1->from.reg = rn; + if(rn >= NREG) { + p1->from.type = D_FREG; + p1->from.reg = rn-NREG; + } + if(!f) { + p1->from = *a; + *a = zprog.from; + a->type = D_REG; + a->reg = rn; + if(rn >= NREG) { + a->type = D_FREG; + a->reg = rn-NREG; + } + if(v->etype == TUCHAR) + p1->as = AMOVBU; + if(v->etype == TUSHORT) + p1->as = AMOVHU; + if(v->etype == TUINT || v->etype == TULONG) + p1->as = AMOVWU; + } + if(debug['R']) + print("%P\t.a%P\n", p, p1); +} + +Bits +mkvar(Adr *a, int docon) +{ + Var *v; + int i, t, n, et, z; + vlong o; + Bits bit; + Sym *s; + + t = a->type; + if(t == D_REG && a->reg != NREG) + regbits |= RtoB(a->reg); + if(t == D_FREG && a->reg != NREG) + regbits |= FtoB(a->reg); + s = a->sym; + o = a->offset; + et = a->etype; + if(s == S) { + if(t != D_CONST || !docon || a->reg != NREG) + goto none; + // et = TLONG; + } + if(t == D_CONST) { + if(s == S && sval(o)) + goto none; + } + + n = a->name; + v = var; + for(i=0; isym) + if(n == v->name) + if(o == v->offset) + goto out; + v++; + } + if(s) + if(s->name[0] == '.' && strcmp(s->name, ".ret") != 0) + goto none; + if(nvar >= NVAR) { + if(debug['w'] > 1 && s) + warn(Z, "variable not optimized: %s", s->name); + goto none; + } + i = nvar; + nvar++; + v = &var[i]; + v->sym = s; + v->offset = o; + v->etype = et; + v->name = n; + if(debug['R']) + print("bit=%2d et=%2d %D\n", i, et, a); +out: + bit = blsh(i); + if(n == D_EXTERN || n == D_STATIC) + for(z=0; zetype != et || !(typechlpfd[et] || typev[et])) /* funny punning */ + for(z=0; zp1) { + for(z=0; zrefahead.b[z]; + if(ref.b[z] != r1->refahead.b[z]) { + r1->refahead.b[z] = ref.b[z]; + change++; + } + cal.b[z] |= r1->calahead.b[z]; + if(cal.b[z] != r1->calahead.b[z]) { + r1->calahead.b[z] = cal.b[z]; + change++; + } + } + switch(r1->prog->as) { + case ABL: + for(z=0; zset.b[z]) | + r1->use1.b[z] | r1->use2.b[z]; + cal.b[z] &= ~(r1->set.b[z] | r1->use1.b[z] | r1->use2.b[z]); + r1->refbehind.b[z] = ref.b[z]; + r1->calbehind.b[z] = cal.b[z]; + } + if(r1->active) + break; + r1->active = 1; + } + for(; r != r1; r = r->p1) + for(r2 = r->p2; r2 != R; r2 = r2->p2link) + prop(r2, r->refbehind, r->calbehind); +} + +/* + * find looping structure + * + * 1) find reverse postordering + * 2) find approximate dominators, + * the actual dominators if the flow graph is reducible + * otherwise, dominators plus some other non-dominators. + * See Matthew S. Hecht and Jeffrey D. Ullman, + * "Analysis of a Simple Algorithm for Global Data Flow Problems", + * Conf. Record of ACM Symp. on Principles of Prog. Langs, Boston, Massachusetts, + * Oct. 1-3, 1973, pp. 207-217. + * 3) find all nodes with a predecessor dominated by the current node. + * such a node is a loop head. + * recursively, all preds with a greater rpo number are in the loop + */ +long +postorder(Reg *r, Reg **rpo2r, long n) +{ + Reg *r1; + + r->rpo = 1; + r1 = r->s1; + if(r1 && !r1->rpo) + n = postorder(r1, rpo2r, n); + r1 = r->s2; + if(r1 && !r1->rpo) + n = postorder(r1, rpo2r, n); + rpo2r[n] = r; + n++; + return n; +} + +long +rpolca(long *idom, long rpo1, long rpo2) +{ + long t; + + if(rpo1 == -1) + return rpo2; + while(rpo1 != rpo2){ + if(rpo1 > rpo2){ + t = rpo2; + rpo2 = rpo1; + rpo1 = t; + } + while(rpo1 < rpo2){ + t = idom[rpo2]; + if(t >= rpo2) + fatal(Z, "bad idom"); + rpo2 = t; + } + } + return rpo1; +} + +int +doms(long *idom, long r, long s) +{ + while(s > r) + s = idom[s]; + return s == r; +} + +int +loophead(long *idom, Reg *r) +{ + long src; + + src = r->rpo; + if(r->p1 != R && doms(idom, src, r->p1->rpo)) + return 1; + for(r = r->p2; r != R; r = r->p2link) + if(doms(idom, src, r->rpo)) + return 1; + return 0; +} + +void +loopmark(Reg **rpo2r, long head, Reg *r) +{ + if(r->rpo < head || r->active == head) + return; + r->active = head; + r->loop += LOOP; + if(r->p1 != R) + loopmark(rpo2r, head, r->p1); + for(r = r->p2; r != R; r = r->p2link) + loopmark(rpo2r, head, r); +} + +void +loopit(Reg *r, long nr) +{ + Reg *r1; + long i, d, me; + + if(nr > maxnr) { + rpo2r = alloc(nr * sizeof(Reg*)); + idom = alloc(nr * sizeof(long)); + maxnr = nr; + } + + d = postorder(r, rpo2r, 0); + if(d > nr) + fatal(Z, "too many reg nodes"); + nr = d; + for(i = 0; i < nr / 2; i++){ + r1 = rpo2r[i]; + rpo2r[i] = rpo2r[nr - 1 - i]; + rpo2r[nr - 1 - i] = r1; + } + for(i = 0; i < nr; i++) + rpo2r[i]->rpo = i; + + idom[0] = 0; + for(i = 0; i < nr; i++){ + r1 = rpo2r[i]; + me = r1->rpo; + d = -1; + if(r1->p1 != R && r1->p1->rpo < me) + d = r1->p1->rpo; + for(r1 = r1->p2; r1 != nil; r1 = r1->p2link) + if(r1->rpo < me) + d = rpolca(idom, d, r1->rpo); + idom[i] = d; + } + + for(i = 0; i < nr; i++){ + r1 = rpo2r[i]; + r1->loop++; + if(r1->p2 != R && loophead(idom, r1)) + loopmark(rpo2r, i, r1); + } +} + +void +synch(Reg *r, Bits dif) +{ + Reg *r1; + int z; + + for(r1 = r; r1 != R; r1 = r1->s1) { + for(z=0; zrefbehind.b[z] & r1->refahead.b[z])) | + r1->set.b[z] | r1->regdiff.b[z]; + if(dif.b[z] != r1->regdiff.b[z]) { + r1->regdiff.b[z] = dif.b[z]; + change++; + } + } + if(r1->active) + break; + r1->active = 1; + for(z=0; zcalbehind.b[z] & r1->calahead.b[z]); + if(r1->s2 != R) + synch(r1->s2, dif); + } +} + +ulong +allreg(ulong b, Rgn *r) +{ + Var *v; + int i; + + v = var + r->varno; + r->regno = 0; + switch(v->etype) { + + default: + diag(Z, "unknown etype %d/%d", bitno(b), v->etype); + break; + + case TCHAR: + case TUCHAR: + case TSHORT: + case TUSHORT: + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TIND: + case TVLONG: + case TUVLONG: + case TARRAY: + i = BtoR(~b); + if(i && r->cost > 0) { + r->regno = i; + return RtoB(i); + } + break; + + case TDOUBLE: + case TFLOAT: + i = BtoF(~b); + if(i && r->cost > 0) { + r->regno = i+NREG; + return FtoB(i); + } + break; + } + return 0; +} + +void +paint1(Reg *r, int bn) +{ + Reg *r1; + Prog *p; + int z; + ulong bb; + + z = bn/32; + bb = 1L<<(bn%32); + if(r->act.b[z] & bb) + return; + for(;;) { + if(!(r->refbehind.b[z] & bb)) + break; + r1 = r->p1; + if(r1 == R) + break; + if(!(r1->refahead.b[z] & bb)) + break; + if(r1->act.b[z] & bb) + break; + r = r1; + } + + if(LOAD(r) & ~(r->set.b[z] & ~(r->use1.b[z]|r->use2.b[z])) & bb) { + change -= CLOAD * r->loop; + if(debug['R'] && debug['v']) + print("%ld%P\tld %B $%d\n", r->loop, + r->prog, blsh(bn), change); + } + for(;;) { + r->act.b[z] |= bb; + p = r->prog; + + if(r->use1.b[z] & bb) { + change += CREF * r->loop; + if(p->to.type == D_FREG && (p->as == AMOVW || p->as == AMOV)) + change = -CINF; /* cant go Rreg to Freg */ + if(debug['R'] && debug['v']) + print("%ld%P\tu1 %B $%d\n", r->loop, + p, blsh(bn), change); + } + + if((r->use2.b[z]|r->set.b[z]) & bb) { + change += CREF * r->loop; + if(p->from.type == D_FREG && (p->as == AMOVW || p->as == AMOV)) + change = -CINF; /* cant go Rreg to Freg */ + if(debug['R'] && debug['v']) + print("%ld%P\tu2 %B $%d\n", r->loop, + p, blsh(bn), change); + } + + if(STORE(r) & r->regdiff.b[z] & bb) { + change -= CLOAD * r->loop; + if(debug['R'] && debug['v']) + print("%ld%P\tst %B $%d\n", r->loop, + p, blsh(bn), change); + } + + if(r->refbehind.b[z] & bb) + for(r1 = r->p2; r1 != R; r1 = r1->p2link) + if(r1->refahead.b[z] & bb) + paint1(r1, bn); + + if(!(r->refahead.b[z] & bb)) + break; + r1 = r->s2; + if(r1 != R) + if(r1->refbehind.b[z] & bb) + paint1(r1, bn); + r = r->s1; + if(r == R) + break; + if(r->act.b[z] & bb) + break; + if(!(r->refbehind.b[z] & bb)) + break; + } +} + +ulong +paint2(Reg *r, int bn) +{ + Reg *r1; + int z; + ulong bb, vreg; + + z = bn/32; + bb = 1L << (bn%32); + vreg = regbits; + if(!(r->act.b[z] & bb)) + return vreg; + for(;;) { + if(!(r->refbehind.b[z] & bb)) + break; + r1 = r->p1; + if(r1 == R) + break; + if(!(r1->refahead.b[z] & bb)) + break; + if(!(r1->act.b[z] & bb)) + break; + r = r1; + } + for(;;) { + r->act.b[z] &= ~bb; + + vreg |= r->regu; + + if(r->refbehind.b[z] & bb) + for(r1 = r->p2; r1 != R; r1 = r1->p2link) + if(r1->refahead.b[z] & bb) + vreg |= paint2(r1, bn); + + if(!(r->refahead.b[z] & bb)) + break; + r1 = r->s2; + if(r1 != R) + if(r1->refbehind.b[z] & bb) + vreg |= paint2(r1, bn); + r = r->s1; + if(r == R) + break; + if(!(r->act.b[z] & bb)) + break; + if(!(r->refbehind.b[z] & bb)) + break; + } + return vreg; +} + +void +paint3(Reg *r, int bn, long rb, int rn) +{ + Reg *r1; + Prog *p; + int z; + ulong bb; + + z = bn/32; + bb = 1L << (bn%32); + if(r->act.b[z] & bb) + return; + for(;;) { + if(!(r->refbehind.b[z] & bb)) + break; + r1 = r->p1; + if(r1 == R) + break; + if(!(r1->refahead.b[z] & bb)) + break; + if(r1->act.b[z] & bb) + break; + r = r1; + } + + if(LOAD(r) & ~(r->set.b[z] & ~(r->use1.b[z]|r->use2.b[z])) & bb) + addmove(r, bn, rn, 0); + for(;;) { + r->act.b[z] |= bb; + p = r->prog; + + if(r->use1.b[z] & bb) { + int et = var[bn].etype; + + if(debug['R']) + print("%P", p); + addreg(&p->from, rn); + + /* + * avoid type converting move instructions when variable type matches. + * the register is already loaded with the correct type conversion + * and type conversing move instructions prevent the peephole optimizer + * from eleminating redundant moves. + */ + if(p->as == AMOVB && et == TCHAR + || p->as == AMOVBU && et == TUCHAR + || p->as == AMOVH && et == TSHORT + || p->as == AMOVHU && et == TUSHORT + || p->as == AMOVW && (et == TLONG || et == TINT) + || p->as == AMOVWU && (et == TULONG || et == TUINT)) + p->as = AMOV; + + if(debug['R']) + print("\t.c%P\n", p); + } + if((r->use2.b[z]|r->set.b[z]) & bb) { + if(debug['R']) + print("%P", p); + addreg(&p->to, rn); + if(debug['R']) + print("\t.c%P\n", p); + } + + if(STORE(r) & r->regdiff.b[z] & bb) + addmove(r, bn, rn, 1); + r->regu |= rb; + + if(r->refbehind.b[z] & bb) + for(r1 = r->p2; r1 != R; r1 = r1->p2link) + if(r1->refahead.b[z] & bb) + paint3(r1, bn, rb, rn); + + if(!(r->refahead.b[z] & bb)) + break; + r1 = r->s2; + if(r1 != R) + if(r1->refbehind.b[z] & bb) + paint3(r1, bn, rb, rn); + r = r->s1; + if(r == R) + break; + if(r->act.b[z] & bb) + break; + if(!(r->refbehind.b[z] & bb)) + break; + } +} + +void +addreg(Adr *a, int rn) +{ + + a->sym = 0; + a->name = D_NONE; + a->type = D_REG; + a->reg = rn; + if(rn >= NREG) { + a->type = D_FREG; + a->reg = rn-NREG; + } +} + +/* + * bit reg + * 0 R9 + * 1 R10 + * ... ... + * 14 R23 + */ +long +RtoB(int r) +{ + if(r >= REGMIN && r <= REGMAX) + return 1L << (r-REGMIN); + return 0; +} + +int +BtoR(long b) +{ + b &= (1 << (1+REGMAX-REGMIN))-1; + b &= ~(1 << (REGTMP-REGMIN)); + if(b == 0) + return 0; + return bitno(b) + REGMIN; +} + +/* + * bit reg + * 22 F7 + * 23 F8 + * ... ... + * 29 F14 + */ +long +FtoB(int f) +{ + if(f < FREGMIN || f >= FREGEXT) + return 0; + return 1L << (f - FREGMIN + 22); +} + +int +BtoF(long b) +{ + + b &= ((1 << (FREGEXT - FREGMIN))-1) << 22; + if(b == 0) + return 0; + return bitno(b) - 22 + FREGMIN; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/sgen.c Fri Mar 6 11:05:00 2026 @@ -0,0 +1,259 @@ +#include "gc.h" + +void +noretval(int n) +{ + + if(n & 1) { + gins(ANOP, Z, Z); + p->to.type = D_REG; + p->to.reg = REGRET; + } + if(n & 2) { + gins(ANOP, Z, Z); + p->to.type = D_FREG; + p->to.reg = FREGRET; + } +} + +/* + * calculate addressability as follows + * CONST ==> 20 $value + * NAME ==> 10 name + * REGISTER ==> 11 register + * INDREG ==> 12 *[(reg)+offset] + * &10 ==> 2 $name + * ADD(2, 20) ==> 2 $name+offset + * ADD(3, 20) ==> 3 $(reg)+offset + * &12 ==> 3 $(reg)+offset + * *11 ==> 11 ?? + * *2 ==> 10 name + * *3 ==> 12 *(reg)+offset + * calculate complexity (number of registers) + */ +void +xcom(Node *n) +{ + Node *l, *r; + int t; + + if(n == Z) + return; + l = n->left; + r = n->right; + n->addable = 0; + n->complex = 0; + switch(n->op) { + case OCONST: + n->addable = 20; + return; + + case OREGISTER: + n->addable = 11; + return; + + case OINDREG: + n->addable = 12; + return; + + case ONAME: + n->addable = 10; + return; + + case OADDR: + xcom(l); + if(l->addable == 10) + n->addable = 2; + if(l->addable == 12) + n->addable = 3; + break; + + case OIND: + xcom(l); + if(l->addable == 11) + n->addable = 12; + if(l->addable == 3) + n->addable = 12; + if(l->addable == 2) + n->addable = 10; + break; + + case OADD: + xcom(l); + xcom(r); + if(l->addable == 20) { + if(r->addable == 2) + n->addable = 2; + if(r->addable == 3) + n->addable = 3; + } + if(r->addable == 20) { + if(l->addable == 2) + n->addable = 2; + if(l->addable == 3) + n->addable = 3; + } + break; + + case OASMUL: + case OASLMUL: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OASASHL; + r->vconst = t; + r->type = types[TINT]; + } + break; + + case OMUL: + case OLMUL: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OASHL; + r->vconst = t; + r->type = types[TINT]; + } + t = vlog(l); + if(t >= 0) { + n->op = OASHL; + n->left = r; + n->right = l; + r = l; + l = n->left; + r->vconst = t; + r->type = types[TINT]; + simplifyshift(n); + } + break; + + case OASLDIV: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OASLSHR; + r->vconst = t; + r->type = types[TINT]; + } + break; + + case OLDIV: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OLSHR; + r->vconst = t; + r->type = types[TINT]; + simplifyshift(n); + } + break; + + case OASLMOD: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OASAND; + r->vconst--; + } + break; + + case OLMOD: + xcom(l); + xcom(r); + t = vlog(r); + if(t >= 0) { + n->op = OAND; + r->vconst--; + } + break; + + case OLSHR: + case OASHL: + case OASHR: + xcom(l); + xcom(r); + simplifyshift(n); + break; + + //case OOR: + // xcom(l); + // xcom(r); + // switch(n->type->etype){ + // case TUINT: + // case TULONG: + // case TUVLONG: + // rolor(n); + // break; + // } + // break; + + default: + if(l != Z) + xcom(l); + if(r != Z) + xcom(r); + break; + } + if(n->addable >= 10) + return; + + if(l != Z) + n->complex = l->complex; + if(r != Z) { + if(r->complex == n->complex) + n->complex = r->complex+1; + else + if(r->complex > n->complex) + n->complex = r->complex; + } + if(n->complex == 0) + n->complex++; + +// if(com64(n)) +// return; + + switch(n->op) { + case OFUNC: + n->complex = FNX; + break; + + case OEQ: + case ONE: + case OLE: + case OLT: + case OGE: + case OGT: + case OHI: + case OHS: + case OLO: + case OLS: + /* + * immediate operators, make const on right + */ + if(l->op == OCONST) { + n->left = r; + n->right = l; + n->op = invrel[relindex(n->op)]; + } + break; + + case OADD: + case OXOR: + case OAND: + case OOR: + /* + * immediate operators, make const on right + */ + if(l->op == OCONST) { + n->left = r; + n->right = l; + } + break; + } +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/swt.c Mon Mar 9 13:48:24 2026 @@ -0,0 +1,659 @@ +#include "gc.h" + +void +swit1(C1 *q, int nc, long def, Node *n) +{ + Node tn; + + regalloc(&tn, ®node, Z); + swit2(q, nc, def, n, &tn); + regfree(&tn); +} + +void +swit2(C1 *q, int nc, long def, Node *n, Node *tn) +{ + C1 *r; + int i; + long v; + Prog *sp; + + if(nc >= 3) { + i = (q+nc-1)->val - (q+0)->val; + if(i > 0 && i < nc*2) + goto direct; + } + if(nc < 5) { + for(i=0; ival); + gopcode(OEQ, nodconst(q->val), n, Z); + patch(p, q->label); + q++; + } + gbranch(OGOTO); + patch(p, def); + return; + } + + i = nc / 2; + r = q+i; + if(debug['K']) + print("case > %.8llux\n", r->val); + gopcode(OGT, nodconst(r->val), n, Z); + sp = p; + gopcode(OEQ, nodconst(r->val), n, Z); /* just gen the B.EQ */ + patch(p, r->label); + swit2(q, i, def, n, tn); + + if(debug['K']) + print("case < %.8llux\n", r->val); + patch(sp, pc); + swit2(r+1, nc-i-1, def, n, tn); + return; + +direct: + v = q->val; + if(v != 0) + gopcode(OSUB, nodconst(v), Z, n); + gopcode(OHI, nodconst((q+nc-1)->val - v), n, Z); + patch(p, def); + gopcode(OCASE, n, Z, tn); + for(i=0; ival); + while(q->val != v) { + nextpc(); + p->as = ABCASE; + patch(p, def); + v++; + } + nextpc(); + p->as = ABCASE; + patch(p, q->label); + q++; + v++; + } + gbranch(OGOTO); /* so that regopt() won't be confused */ + patch(p, def); +} + +void +bitload(Node *b, Node *n1, Node *n2, Node *n3, Node *nn) +{ + int sh; + long v; + Node *l; + + /* + * n1 gets adjusted/masked value + * n2 gets address of cell + * n3 gets contents of cell + */ + l = b->left; + if(n2 != Z) { + regalloc(n1, l, nn); + reglcgen(n2, l, Z); + regalloc(n3, l, Z); + gopcode(OAS, n2, Z, n3); + gopcode(OAS, n3, Z, n1); + } else { + regalloc(n1, l, nn); + cgen(l, n1); + } + if(b->type->shift == 0 && typeu[b->type->etype]) { + v = ~0 + (1L << b->type->nbits); + gopcode(OAND, nodconst(v), Z, n1); + } else { + sh = 32 - b->type->shift - b->type->nbits; + if(sh > 0) + gopcode(OASHL, nodconst(sh), Z, n1); + sh += b->type->shift; + if(sh > 0) + if(typeu[b->type->etype]) + gopcode(OLSHR, nodconst(sh), Z, n1); + else + gopcode(OASHR, nodconst(sh), Z, n1); + } +} + +void +bitstore(Node *b, Node *n1, Node *n2, Node *n3, Node *nn) +{ + long v; + Node nod, *l; + int sh; + + /* + * n1 has adjusted/masked value + * n2 has address of cell + * n3 has contents of cell + */ + l = b->left; + regalloc(&nod, l, Z); + v = ~0 + (1L << b->type->nbits); + gopcode(OAND, nodconst(v), Z, n1); + gopcode(OAS, n1, Z, &nod); + if(nn != Z) + gopcode(OAS, n1, Z, nn); + sh = b->type->shift; + if(sh > 0) + gopcode(OASHL, nodconst(sh), Z, &nod); + v <<= sh; + gopcode(OAND, nodconst(~v), Z, n3); + gopcode(OOR, n3, Z, &nod); + gopcode(OAS, &nod, Z, n2); + + regfree(&nod); + regfree(n1); + regfree(n2); + regfree(n3); +} + +long +outstring(char *s, long n) +{ + long r; + + if(suppress) + return nstring; + r = nstring; + while(n) { + string[mnstring] = *s++; + mnstring++; + nstring++; + if(mnstring >= NSNAME) { + gpseudo(ADATA, symstring, nodconst(0L)); + p->from.offset += nstring - NSNAME; + p->reg = NSNAME; + p->to.type = D_SCONST; + memmove(p->to.sval, string, NSNAME); + mnstring = 0; + } + n--; + } + return r; +} + +int +mulcon(Node *n, Node *nn) +{ + Node *l, *r, nod1, nod2; + Multab *m; + long v, vs; + int o; + char code[sizeof(m->code)+2], *p; + + if(typefd[n->type->etype]) + return 0; + l = n->left; + r = n->right; + if(l->op == OCONST) { + l = r; + r = n->left; + } + if(r->op != OCONST) + return 0; + v = convvtox(r->vconst, n->type->etype); + if(v != r->vconst) { + if(debug['M']) + print("%L multiply conv: %lld\n", n->lineno, r->vconst); + return 0; + } + m = mulcon0(v); + if(!m) { + if(debug['M']) + print("%L multiply table: %lld\n", n->lineno, r->vconst); + return 0; + } + if(debug['M'] && debug['v']) + print("%L multiply: %ld\n", n->lineno, v); + + memmove(code, m->code, sizeof(m->code)); + code[sizeof(m->code)] = 0; + + p = code; + if(p[1] == 'i') + p += 2; + regalloc(&nod1, n, nn); + cgen(l, &nod1); + vs = v; + regalloc(&nod2, n, Z); + +loop: + switch(*p) { + case 0: + regfree(&nod2); + if(vs < 0) { + gopcode(OAS, &nod1, Z, &nod1); + gopcode(ONEG, &nod1, Z, nn); + } else + gopcode(OAS, &nod1, Z, nn); + regfree(&nod1); + return 1; + case '+': + o = OADD; + goto addsub; + case '-': + o = OSUB; + addsub: /* number is r,n,l */ + v = p[1] - '0'; + r = &nod1; + if(v&4) + r = &nod2; + n = &nod1; + if(v&2) + n = &nod2; + l = &nod1; + if(v&1) + l = &nod2; + gopcode(o, l, n, r); + break; + default: /* op is shiftcount, number is r,l */ + v = p[1] - '0'; + r = &nod1; + if(v&2) + r = &nod2; + l = &nod1; + if(v&1) + l = &nod2; + v = *p - 'a'; + if(v < 0 || v >= 32) { + diag(n, "mulcon unknown op: %c%c", p[0], p[1]); + break; + } + gopcode(OASHL, nodconst(v), l, r); + break; + } + p += 2; + goto loop; +} + +void +gextern(Sym *s, Node *a, long o, long w) +{ + + if(a->op == OCONST && typev[a->type->etype]) { + if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ + gpseudo(ADATA, s, nod32const(a->vconst>>32)); + else + gpseudo(ADATA, s, nod32const(a->vconst)); + p->from.offset += o; + p->reg = 4; + if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ + gpseudo(ADATA, s, nod32const(a->vconst)); + else + gpseudo(ADATA, s, nod32const(a->vconst>>32)); + p->from.offset += o + 4; + p->reg = 4; + return; + } + gpseudo(ADATA, s, a); + p->from.offset += o; + p->reg = w; + if(p->to.type == D_OREG) + p->to.type = D_CONST; +} + +void zname(Biobuf*, Sym*, int); +char* zaddr(char*, Adr*, int); +void zwrite(Biobuf*, Prog*, int, int); +void outhist(Biobuf*); + +void +zwrite(Biobuf *b, Prog *p, int sf, int st) +{ + char bf[100], *bp; + long l; + + bf[0] = p->as; + bf[1] = p->as>>8; + bf[2] = p->reg; + if(p->from3.type != D_NONE) + bf[2] |= 0x40; + l = p->lineno; + bf[3] = l; + bf[4] = l>>8; + bf[5] = l>>16; + bf[6] = l>>24; + bp = zaddr(bf+7, &p->from, sf); + if(bf[2] & 0x40) + bp = zaddr(bp, &p->from3, 0); + bp = zaddr(bp, &p->to, st); + Bwrite(b, bf, bp-bf); +} + +void +outcode(void) +{ + struct { Sym *sym; short type; } h[NSYM]; + Prog *p; + Sym *s; + int sf, st, t, sym; + + if(debug['S']) { + for(p = firstp; p != P; p = p->link) + if(p->as != ADATA && p->as != AGLOBL) + pc--; + for(p = firstp; p != P; p = p->link) { + print("%P\n", p); + if(p->as != ADATA && p->as != AGLOBL) + pc++; + } + } + outhist(&outbuf); + for(sym=0; symlink) { + jackpot: + sf = 0; + s = p->from.sym; + while(s != S) { + sf = s->sym; + if(sf < 0 || sf >= NSYM) + sf = 0; + t = p->from.name; + if(h[sf].type == t) + if(h[sf].sym == s) + break; + s->sym = sym; + zname(&outbuf, s, t); + h[sym].sym = s; + h[sym].type = t; + sf = sym; + sym++; + if(sym >= NSYM) + sym = 1; + break; + } + st = 0; + s = p->to.sym; + while(s != S) { + st = s->sym; + if(st < 0 || st >= NSYM) + st = 0; + t = p->to.name; + if(h[st].type == t) + if(h[st].sym == s) + break; + s->sym = sym; + zname(&outbuf, s, t); + h[sym].sym = s; + h[sym].type = t; + st = sym; + sym++; + if(sym >= NSYM) + sym = 1; + if(st == sf) + goto jackpot; + break; + } + zwrite(&outbuf, p, sf, st); + } + firstp = P; + lastp = P; +} + +void +outhist(Biobuf *b) +{ + Hist *h; + char *p, *q, *op, c; + Prog pg; + int n; + + pg = zprog; + pg.as = AHISTORY; + c = pathchar(); + for(h = hist; h != H; h = h->link) { + p = h->name; + op = 0; + /* on windows skip drive specifier in pathname */ + if(systemtype(Windows) && p && p[1] == ':'){ + p += 2; + c = *p; + } + if(p && p[0] != c && h->offset == 0 && pathname){ + /* on windows skip drive specifier in pathname */ + if(systemtype(Windows) && pathname[1] == ':') { + op = p; + p = pathname+2; + c = *p; + } else if(pathname[0] == c){ + op = p; + p = pathname; + } + } + while(p) { + q = utfrune(p, c); + if(q) { + n = q-p; + if(n == 0){ + n = 1; /* leading "/" */ + *p = '/'; /* don't emit "\" on windows */ + } + q++; + } else { + n = strlen(p); + q = 0; + } + if(n) { + Bputc(b, ANAME); + Bputc(b, ANAME>>8); + Bputc(b, D_FILE); + Bputc(b, 1); + Bputc(b, '<'); + Bwrite(b, p, n); + Bputc(b, 0); + } + p = q; + if(p == 0 && op) { + p = op; + op = 0; + } + } + pg.lineno = h->line; + pg.to.type = zprog.to.type; + pg.to.offset = h->offset; + if(h->offset) + pg.to.type = D_CONST; + + zwrite(b, &pg, 0, 0); + } +} + +void +zname(Biobuf *b, Sym *s, int t) +{ + char *n, bf[8]; + ulong sig; + + n = s->name; + if(debug['T'] && t == D_EXTERN && s->sig != SIGDONE && s->type != types[TENUM]){ + sig = sign(s); + bf[0] = ASIGNAME; + bf[1] = ASIGNAME>>8; + bf[2] = sig; + bf[3] = sig>>8; + bf[4] = sig>>16; + bf[5] = sig>>24; + bf[6] = t; + bf[7] = s->sym; + Bwrite(b, bf, 8); + s->sig = SIGDONE; + } + else{ + bf[0] = ANAME; + bf[1] = ANAME>>8; + bf[2] = t; /* type */ + bf[3] = s->sym; /* sym */ + Bwrite(b, bf, 4); + } + Bwrite(b, n, strlen(n)+1); +} + +char* +zaddr(char *bp, Adr *a, int s) +{ + long l; + Ieee e; + + if(a->type == D_CONST){ + l = a->offset; + if((vlong)l != a->offset) + a->type = D_DCONST; + } + bp[0] = a->type; + bp[1] = a->reg; + bp[2] = s; + bp[3] = a->name; + bp += 4; + switch(a->type) { + default: + diag(Z, "unknown type %d in zaddr", a->type); + + case D_NONE: + case D_REG: + case D_SP: + case D_FREG: + case D_VREG: + break; + + case D_PAIR: + *bp++ = a->offset; + break; + + case D_OREG: + case D_XPRE: + case D_XPOST: + case D_CONST: + case D_BRANCH: + case D_SHIFT: + case D_EXTREG: + case D_SPR: + l = a->offset; + bp[0] = l; + bp[1] = l>>8; + bp[2] = l>>16; + bp[3] = l>>24; + bp += 4; + break; + + case D_DCONST: + l = a->offset; + bp[0] = l; + bp[1] = l>>8; + bp[2] = l>>16; + bp[3] = l>>24; + bp += 4; + l = a->offset>>32; + bp[0] = l; + bp[1] = l>>8; + bp[2] = l>>16; + bp[3] = l>>24; + bp += 4; + break; + + case D_SCONST: + memmove(bp, a->sval, NSNAME); + bp += NSNAME; + break; + + case D_FCONST: + ieeedtod(&e, a->dval); + l = e.l; + bp[0] = l; + bp[1] = l>>8; + bp[2] = l>>16; + bp[3] = l>>24; + bp += 4; + l = e.h; + bp[0] = l; + bp[1] = l>>8; + bp[2] = l>>16; + bp[3] = l>>24; + bp += 4; + break; + } + return bp; +} + +long +align(long i, Type *t, int op) +{ + long o; + Type *v; + int w; + + o = i; + w = 1; + switch(op) { + default: + diag(Z, "unknown align opcode %d", op); + break; + + case Asu2: /* padding at end of a struct */ + w = SZ_VLONG; + if(packflg) + w = packflg; + break; + + case Ael1: /* initial align of struct element */ + for(v=t; v->etype==TARRAY; v=v->link) + ; + w = ewidth[v->etype]; + if(w <= 0 || w >= SZ_VLONG) + w = SZ_VLONG; + if(packflg) + w = packflg; + break; + + case Ael2: /* width of a struct element */ + o += t->width; + break; + + case Aarg0: /* initial passbyptr argument in arg list */ + if(typesu[t->etype]) { + o = align(o, types[TIND], Aarg1); + o = align(o, types[TIND], Aarg2); + } + break; + + case Aarg1: /* initial align of parameter */ + w = ewidth[t->etype]; + if(w <= 0 || w >= SZ_VLONG) { + w = SZ_VLONG; + break; + } + w = 1; /* little endian no adjustment */ + break; + + case Aarg2: /* width of a parameter */ + o += t->width; + w = SZ_VLONG; + break; + + case Aaut3: /* total align of automatic */ + o = align(o, t, Ael2); + o = align(o, t, Ael1); + if(t->width > SZ_VLONG) + w = SZ_VLONG; /* because of a pun in cc/dcl.c:contig() */ + break; + } + o = round(o, w); + if(debug['A']) + print("align %s %ld %T = %ld\n", bnames[op], i, t, o); + return o; +} + +long +maxround(long max, long v) +{ + v = round(v, SZ_VLONG); + if(v > max) + return v; + return max; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7c/txt.c Fri Mar 6 11:04:21 2026 @@ -0,0 +1,1457 @@ +#include "gc.h" + +static char resvreg[nelem(reg)]; + +#define isv(et) ((et) == TVLONG || (et) == TUVLONG || (et) == TIND) + +void +ginit(void) +{ + thechar = '7'; + thestring = "arm64"; + exregoffset = REGEXT; + exfregoffset = FREGEXT; + newvlongcode = 1; + listinit(); + nstring = 0; + mnstring = 0; + pc = 0; + breakpc = -1; + continpc = -1; + cases = C; + firstp = P; + lastp = P; + tfield = types[TLONG]; + + typeswitch = typechlv; + typeword = typechlvp; + typecmplx = typesu; + /* TO DO */ + memmove(typechlpv, typechlp, sizeof(typechlpv)); + typechlpv[TVLONG] = 1; + typechlpv[TUVLONG] = 1; + + zprog.link = P; + zprog.as = AGOK; + zprog.reg = NREG; + zprog.from.type = D_NONE; + zprog.from.name = D_NONE; + zprog.from.reg = NREG; + zprog.from3 = zprog.from; + zprog.to = zprog.from; + + regnode.op = OREGISTER; + regnode.class = CEXREG; + regnode.reg = REGTMP; + regnode.complex = 0; + regnode.addable = 11; + regnode.type = types[TLONG]; + + qregnode = regnode; + qregnode.type = types[TVLONG]; + + constnode.op = OCONST; + constnode.class = CXXX; + constnode.complex = 0; + constnode.addable = 20; + constnode.type = types[TLONG]; + + vconstnode = constnode; + vconstnode.type = types[TVLONG]; + + fconstnode.op = OCONST; + fconstnode.class = CXXX; + fconstnode.complex = 0; + fconstnode.addable = 20; + fconstnode.type = types[TDOUBLE]; + + nodsafe = new(ONAME, Z, Z); + nodsafe->sym = slookup(".safe"); + nodsafe->type = types[TINT]; + nodsafe->etype = types[TINT]->etype; + nodsafe->class = CAUTO; + complex(nodsafe); + + nodret = new(ONAME, Z, Z); + nodret->sym = slookup(".ret"); + nodret->type = types[TIND]; + nodret->etype = TIND; + nodret->class = CPARAM; + nodret = new(OIND, nodret, Z); + complex(nodret); + + com64init(); + + memset(reg, 0, sizeof(reg)); + /* don't allocate */ + reg[REGTMP] = 1; + reg[REGSB] = 1; + reg[REGLINK] = 1; + reg[REGSP] = 1; + reg[REGZERO] = 1; + /* keep two external registers */ + reg[REGEXT] = 1; + reg[REGEXT-1] = 1; + memmove(resvreg, reg, sizeof(reg)); +} + +void +gclean(void) +{ + int i; + Sym *s; + + for(i=0; itype->width = nstring; + for(i=0; ilink) { + if(s->type == T) + continue; + if(s->type->width == 0) + continue; + if(s->class != CGLOBL && s->class != CSTATIC) + continue; + if(s->type == types[TENUM]) + continue; + gpseudo(AGLOBL, s, nodconst(s->type->width)); + } + nextpc(); + p->as = AEND; + outcode(); +} + +void +nextpc(void) +{ + + p = alloc(sizeof(*p)); + *p = zprog; + p->lineno = nearln; + pc++; + if(firstp == P) { + firstp = p; + lastp = p; + return; + } + lastp->link = p; + lastp = p; +} + +void +gargs(Node *n, Node *tn1, Node *tn2) +{ + long regs; + Node fnxargs[20], *fnxp; + + regs = cursafe; + + fnxp = fnxargs; + garg1(n, tn1, tn2, 0, &fnxp); /* compile fns to temps */ + + curarg = 0; + fnxp = fnxargs; + garg1(n, tn1, tn2, 1, &fnxp); /* compile normal args and temps */ + + cursafe = regs; +} + +void +garg1(Node *n, Node *tn1, Node *tn2, int f, Node **fnxp) +{ + Node nod; + + if(n == Z) + return; + if(n->op == OLIST) { + garg1(n->left, tn1, tn2, f, fnxp); + garg1(n->right, tn1, tn2, f, fnxp); + return; + } + if(f == 0) { + if(n->complex >= FNX) { + regsalloc(*fnxp, n); + nod = znode; + nod.op = OAS; + nod.left = *fnxp; + nod.right = n; + nod.type = n->type; + cgen(&nod, Z); + (*fnxp)++; + } + return; + } + if(typesu[n->type->etype]) { + regaalloc(tn2, n); + if(n->complex >= FNX) { + sugen(*fnxp, tn2, n->type->width); + (*fnxp)++; + } else + sugen(n, tn2, n->type->width); + return; + } + if(REGARG >= 0 && curarg == 0 && typechlpv[n->type->etype]) { + regaalloc1(tn1, n); + if(n->complex >= FNX) { + cgen(*fnxp, tn1); + (*fnxp)++; + } else + cgen(n, tn1); + return; + } + if(vconst(n) == 0) { + regaalloc(tn2, n); + gopcode(OAS, n, Z, tn2); + return; + } + regalloc(tn1, n, Z); + if(n->complex >= FNX) { + cgen(*fnxp, tn1); + (*fnxp)++; + } else + cgen(n, tn1); + regaalloc(tn2, n); + gopcode(OAS, tn1, Z, tn2); + regfree(tn1); +} + +Node* +nodgconst(vlong v, Type *t) +{ + if(!typev[t->etype]) + return nodconst((long)v); + vconstnode.vconst = v; + return &vconstnode; +} + +Node* +nodconst(long v) +{ + constnode.vconst = v; + return &constnode; +} + +Node* +nod32const(vlong v) +{ + constnode.vconst = v & MASK(32); + return &constnode; +} + +Node* +nodfconst(double d) +{ + fconstnode.fconst = d; + return &fconstnode; +} + +void +nodreg(Node *n, Node *nn, int reg) +{ + *n = qregnode; + n->reg = reg; + n->type = nn->type; + n->lineno = nn->lineno; +} + +void +regret(Node *n, Node *nn) +{ + int r; + + r = REGRET; + if(typefd[nn->type->etype]) + r = FREGRET+NREG; + nodreg(n, nn, r); + reg[r]++; +} + +void +regalloc(Node *n, Node *tn, Node *o) +{ + int i, j; + static int lasti, lastf; + + switch(tn->type->etype) { + case TCHAR: + case TUCHAR: + case TSHORT: + case TUSHORT: + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TVLONG: + case TUVLONG: + case TIND: + if(o != Z && o->op == OREGISTER) { + i = o->reg; + if(i >= 0 && i < NREG) + goto out; + } + j = lasti + REGRET+1; + for(i=REGRET+1; i= NREG) + j = REGRET+1; + if(reg[j] == 0 && resvreg[j] == 0) { + i = j; + lasti = (i - REGRET) % 5; + goto out; + } + j++; + } + diag(tn, "out of fixed registers"); + goto err; + + case TFLOAT: + case TDOUBLE: + if(o != Z && o->op == OREGISTER) { + i = o->reg; + if(i >= NREG && i < NREG+NFREG) + goto out; + } + j = lastf + NREG; + for(i=NREG; i= NREG+NFREG) + j = NREG; + if(reg[j] == 0) { + i = j; + lastf = (i - NREG-1) % 5; + goto out; + } + j++; + } + diag(tn, "out of float registers"); + goto err; + } + diag(tn, "unknown type in regalloc: %T", tn->type); +err: + nodreg(n, tn, 0); + return; +out: + reg[i]++; + lasti++; + nodreg(n, tn, i); +} + +void +regialloc(Node *n, Node *tn, Node *o) +{ + Node nod; + + nod = *tn; + nod.type = types[TIND]; + regalloc(n, &nod, o); +} + +void +regfree(Node *n) +{ + int i; + + i = 0; + if(n->op != OREGISTER && n->op != OINDREG) + goto err; + i = n->reg; + if(i < 0 || i >= sizeof(reg)) + goto err; + if(reg[i] <= 0) + goto err; + reg[i]--; + return; +err: + diag(n, "error in regfree: %d", i); +} + +void +regsalloc(Node *n, Node *nn) +{ + cursafe = align(cursafe, nn->type, Aaut3); + maxargsafe = maxround(maxargsafe, cursafe+curarg); + *n = *nodsafe; + n->xoffset = -(stkoff + cursafe); + n->type = nn->type; + n->etype = nn->type->etype; + n->lineno = nn->lineno; +} + +void +regaalloc1(Node *n, Node *nn) +{ + nodreg(n, nn, REGARG); + reg[REGARG]++; + curarg = align(curarg, nn->type, Aarg1); + curarg = align(curarg, nn->type, Aarg2); + maxargsafe = maxround(maxargsafe, cursafe+curarg); +} + +void +regaalloc(Node *n, Node *nn) +{ + curarg = align(curarg, nn->type, Aarg1); + *n = *nn; + n->op = OINDREG; + n->reg = REGSP; + n->xoffset = curarg + SZ_VLONG; + n->complex = 0; + n->addable = 20; + curarg = align(curarg, nn->type, Aarg2); + maxargsafe = maxround(maxargsafe, cursafe+curarg); +} + +void +regind(Node *n, Node *nn) +{ + + if(n->op != OREGISTER) { + diag(n, "regind not OREGISTER"); + return; + } + n->op = OINDREG; + n->type = nn->type; +} + +void +raddr(Node *n, Prog *p) +{ + Adr a; + + naddr(n, &a); + if(a.type == D_CONST && a.offset == 0) { + a.type = D_REG; + a.reg = REGZERO; + } + if(a.type != D_REG && a.type != D_FREG) { + if(n) + diag(n, "bad in raddr: %O", n->op); + else + diag(n, "bad in raddr: "); + p->reg = NREG; + } else + p->reg = a.reg; +} + +void +naddr(Node *n, Adr *a) +{ + long v; + + a->type = D_NONE; + if(n == Z) + return; + switch(n->op) { + default: + bad: + diag(n, "bad in naddr: %O", n->op); + break; + + case OREGISTER: + a->type = D_REG; + a->sym = S; + a->reg = n->reg; + if(a->reg >= NREG) { + a->type = D_FREG; + a->reg -= NREG; + } + break; + + case OIND: + naddr(n->left, a); + if(a->type == D_REG) { + a->type = D_OREG; + break; + } + if(a->type == D_CONST) { + a->type = D_OREG; + break; + } + goto bad; + + case OINDREG: + a->type = D_OREG; + a->sym = S; + a->offset = n->xoffset; + a->reg = n->reg; + break; + + case ONAME: + a->etype = n->etype; + a->type = D_OREG; + a->name = D_STATIC; + a->sym = n->sym; + a->offset = n->xoffset; + if(n->class == CSTATIC) + break; + if(n->class == CEXTERN || n->class == CGLOBL) { + a->name = D_EXTERN; + break; + } + if(n->class == CAUTO) { + a->name = D_AUTO; + break; + } + if(n->class == CPARAM) { + a->name = D_PARAM; + break; + } + goto bad; + + case OCONST: + a->sym = S; + a->reg = NREG; + if(typefd[n->type->etype]) { + a->type = D_FCONST; + a->dval = n->fconst; + } else { + a->type = D_CONST; + a->offset = n->vconst; + } + break; + + case OADDR: + naddr(n->left, a); + if(a->type == D_OREG) { + a->type = D_CONST; + break; + } +print("bad addr %D\n", a); + goto bad; + + case OADD: + if(n->left->op == OCONST) { + naddr(n->left, a); + v = a->offset; + naddr(n->right, a); + } else { + naddr(n->right, a); + v = a->offset; + naddr(n->left, a); + } + a->offset += v; + break; + + } +} + +void +fop(int as, int f1, int f2, Node *t) +{ + Node nod1, nod2, nod3; + + nodreg(&nod1, t, NREG+f1); + nodreg(&nod2, t, NREG+f2); + regalloc(&nod3, t, t); + gopcode(as, &nod1, &nod2, &nod3); + gmove(&nod3, t); + regfree(&nod3); +} + +void +gmove(Node *f, Node *t) +{ + int ft, tt, a; + Node nod; + + ft = f->type->etype; + tt = t->type->etype; + + if(ft == TDOUBLE && f->op == OCONST) { + } + if(ft == TFLOAT && f->op == OCONST) { + } + + /* + * a load -- + * put it into a register then + * worry what to do with it. + */ + if(f->op == ONAME || f->op == OINDREG || f->op == OIND) { + switch(ft) { + default: + if(ewidth[ft] == 4){ + if(typeu[ft]) + a = AMOVWU; + else + a = AMOVW; + }else + a = AMOV; + break; + case TINT: + a = AMOVW; + break; + case TUINT: + a = AMOVWU; + break; + case TFLOAT: + a = AFMOVS; + break; + case TDOUBLE: + a = AFMOVD; + break; + case TCHAR: + a = AMOVB; + break; + case TUCHAR: + a = AMOVBU; + break; + case TSHORT: + a = AMOVH; + break; + case TUSHORT: + a = AMOVHU; + break; + } + regalloc(&nod, f, t); + gins(a, f, &nod); + gmove(&nod, t); + regfree(&nod); + return; + } + + /* + * a store -- + * put it into a register then + * store it. + */ + if(t->op == ONAME || t->op == OINDREG || t->op == OIND) { + switch(tt) { + default: + if(ewidth[tt] == 4) + a = AMOVW; + else + a = AMOV; + break; + case TINT: + a = AMOVW; + break; + case TUINT: + a = AMOVWU; + break; + case TUCHAR: + a = AMOVBU; + break; + case TCHAR: + a = AMOVB; + break; + case TUSHORT: + a = AMOVHU; + break; + case TSHORT: + a = AMOVH; + break; + case TFLOAT: + a = AFMOVS; + break; + case TDOUBLE: + a = AFMOVD; + break; + } + if(!typefd[ft] && vconst(f) == 0) { + gins(a, f, t); + return; + } + if(ft == tt) + regalloc(&nod, t, f); + else + regalloc(&nod, t, Z); + gmove(f, &nod); + gins(a, &nod, t); + regfree(&nod); + return; + } + + /* + * type x type cross table + */ + a = AGOK; + switch(ft) { + case TDOUBLE: + case TFLOAT: + switch(tt) { + case TDOUBLE: + a = AFMOVD; + if(ft == TFLOAT) + a = AFCVTSD; + break; + case TFLOAT: + a = AFMOVS; + if(ft == TDOUBLE) + a = AFCVTDS; + break; + case TCHAR: + case TSHORT: + case TINT: + case TLONG: + a = AFCVTZSDW; + if(ft == TFLOAT) + a = AFCVTZSSW; + break; + case TUCHAR: + case TUSHORT: + case TUINT: + case TULONG: + a = AFCVTZUDW; + if(ft == TFLOAT) + a = AFCVTZUSW; + break; + case TVLONG: + a = AFCVTZSD; + if(ft == TFLOAT) + a = AFCVTZSS; + break; + case TUVLONG: + case TIND: + a = AFCVTZUD; + if(ft == TFLOAT) + a = AFCVTZUS; + break; + } + break; + case TUINT: + case TULONG: + case TINT: + case TLONG: + switch(tt) { + case TDOUBLE: + if(ft == TUINT || ft == TULONG) + gins(AUCVTFWD, f, t); + else + gins(ASCVTFWD, f, t); + return; + case TFLOAT: + if(ft == TUINT || ft == TULONG) + gins(AUCVTFWS, f, t); + else + gins(ASCVTFWS, f, t); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TSHORT: + case TUSHORT: + case TCHAR: + case TUCHAR: + if(typeu[tt]) + a = AMOVWU; + else + a = AMOVW; + break; + case TVLONG: + case TUVLONG: + case TIND: + if(typeu[ft]) + a = AMOVWU; + else + a = (f->op == OREGISTER) ? ASXTW : AMOVW; + break; + } + break; + case TVLONG: + case TUVLONG: + case TIND: + switch(tt) { + case TDOUBLE: + if(ft == TVLONG) + gins(ASCVTFD, f, t); + else + gins(AUCVTFD, f, t); + return; + case TFLOAT: + if(ft == TVLONG) + gins(ASCVTFS, f, t); + else + gins(AUCVTFS, f, t); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TSHORT: + case TUSHORT: + case TCHAR: + case TUCHAR: + a = AMOVWU; + break; + case TVLONG: + case TUVLONG: + case TIND: + a = AMOV; + break; + } + break; + case TSHORT: + switch(tt) { + case TDOUBLE: + regalloc(&nod, f, Z); + gins(AMOVH, f, &nod); + gins(ASCVTFWD, &nod, t); + regfree(&nod); + return; + case TFLOAT: + regalloc(&nod, f, Z); + gins(AMOVH, f, &nod); + gins(ASCVTFWS, &nod, t); + regfree(&nod); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TVLONG: + case TUVLONG: + case TIND: + a = AMOVH; + break; + case TSHORT: + case TUSHORT: + case TCHAR: + case TUCHAR: + a = AMOV; + break; + } + break; + case TUSHORT: + switch(tt) { + case TDOUBLE: + regalloc(&nod, f, Z); + gins(AMOVHU, f, &nod); + gins(AUCVTFWD, &nod, t); + regfree(&nod); + return; + case TFLOAT: + regalloc(&nod, f, Z); + gins(AMOVHU, f, &nod); + gins(AUCVTFWS, &nod, t); + regfree(&nod); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TVLONG: + case TUVLONG: + case TIND: + a = AMOVHU; + break; + case TSHORT: + case TUSHORT: + case TCHAR: + case TUCHAR: + a = AMOV; + break; + } + break; + case TCHAR: + switch(tt) { + case TDOUBLE: + regalloc(&nod, f, Z); + gins(AMOVB, f, &nod); + gins(ASCVTFWD, &nod, t); + regfree(&nod); + return; + case TFLOAT: + regalloc(&nod, f, Z); + gins(AMOVB, f, &nod); + gins(ASCVTFWS, &nod, t); + regfree(&nod); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TIND: + case TSHORT: + case TUSHORT: + case TVLONG: + case TUVLONG: + a = AMOVB; + break; + case TCHAR: + case TUCHAR: + a = AMOV; + break; + } + break; + case TUCHAR: + switch(tt) { + case TDOUBLE: + regalloc(&nod, f, Z); + gins(AMOVBU, f, &nod); + gins(AUCVTFWD, &nod, t); + regfree(&nod); + return; + case TFLOAT: + regalloc(&nod, f, Z); + gins(AMOVBU, f, &nod); + gins(AUCVTFWS, &nod, t); + regfree(&nod); + return; + case TINT: + case TUINT: + case TLONG: + case TULONG: + case TIND: + case TSHORT: + case TUSHORT: + case TVLONG: + case TUVLONG: + a = AMOVBU; + break; + case TCHAR: + case TUCHAR: + a = AMOV; + break; + } + break; + } + if(a == AGOK) + diag(Z, "bad opcode in gmove %T -> %T", f->type, t->type); + if(a == AMOV || (a == AMOVW || a == AMOVWU) && ewidth[ft] == ewidth[tt] || a == AFMOVS || a == AFMOVD) + if(samaddr(f, t)) + return; + gins(a, f, t); +} + +void +gmover(Node *f, Node *t) +{ + int ft, tt, a; + + ft = f->type->etype; + tt = t->type->etype; + a = AGOK; + if(typechlp[ft] && typechlp[tt] && ewidth[ft] >= ewidth[tt]){ + switch(tt){ + case TSHORT: + a = AMOVH; + break; + case TUSHORT: + a = AMOVHU; + break; + case TCHAR: + a = AMOVB; + break; + case TUCHAR: + a = AMOVBU; + break; + case TINT: + a = AMOVW; + break; + case TUINT: + a = AMOVWU; + break; + } + } + if(a == AGOK) + gmove(f, t); + else + gins(a, f, t); +} + +void +gins(int a, Node *f, Node *t) +{ + + nextpc(); + p->as = a; + if(f != Z) + naddr(f, &p->from); + if(t != Z) + naddr(t, &p->to); + if(debug['g']) + print("%P\n", p); +} + +static int +zcmp(Prog *p, int as) +{ + if(p->from.type != D_CONST || p->from.offset != 0) + return 0; + switch(p->as){ + case ACMP: + p->as = as; + if(as == ATBZ || as == ATBNZ){ + p->from.offset = 63; + return 1; + } + break; + case ACMPW: + p->as = as; + if(as == ATBZ || as == ATBNZ){ + p->from.offset = 31; + return 1; + } + break; + default: + return 0; + } + p->from.type = D_REG; + p->from.reg = p->reg; + p->reg = NREG; + return 1; +} + +void +gopcode(int o, Node *f1, Node *f2, Node *t) +{ + int a, et, true; + Adr ta; + + et = TLONG; + if(f1 != Z && f1->type != T) { + et = f1->type->etype; + if(f1->op == OCONST){ + if(t != Z && t->type != T) + et = t->type->etype; + else if(f2 != Z && f2->type != T && ewidth[f2->type->etype] > ewidth[et]) + et = f2->type->etype; + } + } + true = o & BTRUE; + o &= ~BTRUE; + a = AGOK; + switch(o) { + case OAS: + gmove(f1, t); + return; + + case OASADD: + case OADD: + a = AADDW; + if(isv(et)) + a = AADD; + else if(et == TFLOAT) + a = AFADDS; + else if(et == TDOUBLE) + a = AFADDD; + break; + + case OASSUB: + case OSUB: + a = ASUBW; + if(isv(et)) + a = ASUB; + else if(et == TFLOAT) + a = AFSUBS; + else if(et == TDOUBLE) + a = AFSUBD; + break; + + case OASOR: + case OOR: + a = AORRW; + if(isv(et)) + a = AORR; + break; + + //case OROL: + // if(isv(et)){ + // a = AROR; + // f1->vconst = 64-f1->vconst; + // } else { + // a = ARORW; + // f1->vconst = 32-f1->vconst; + // } + // break; + + case OASAND: + case OAND: + a = AANDW; + if(isv(et)) + a = AAND; + break; + + case OASXOR: + case OXOR: + a = AEORW; + if(isv(et)) + a = AEOR; + break; + + case OASLSHR: + case OLSHR: + a = ALSRW; + if(isv(et)) + a = ALSR; + break; + + case OASASHR: + case OASHR: + a = AASRW; + if(isv(et)) + a = AASR; + break; + + case OASASHL: + case OASHL: + a = ALSLW; + if(isv(et)) + a = ALSL; + break; + + case OFUNC: + a = ABL; + break; + + case OASMUL: + case OMUL: + a = AMULW; + if(isv(et)) + a = AMUL; + else if(et == TFLOAT) + a = AFMULS; + else if(et == TDOUBLE) + a = AFMULD; + break; + + case OASDIV: + case ODIV: + a = ASDIVW; + if(isv(et)) + a = ASDIV; + else if(et == TFLOAT) + a = AFDIVS; + else if(et == TDOUBLE) + a = AFDIVD; + break; + + case OASMOD: + case OMOD: + a = AREMW; + if(isv(et)) + a = AREM; + break; + + case OASLMUL: + case OLMUL: + a = AUMULL; + if(isv(et)) + a = AMUL; + break; + + case OASLMOD: + case OLMOD: + a = AUREMW; + if(isv(et)) + a = AUREM; + break; + + case OASLDIV: + case OLDIV: + a = AUDIVW; + if(isv(et)) + a = AUDIV; + break; + + case OCOM: + a = AMVNW; + if(isv(et)) + a = AMVN; + break; + + case ONEG: + a = ANEGW; + if(isv(et)) + a = ANEG; + break; + + case OCASE: + a = ACASE; /* ACASEW? */ + break; + + case OEQ: + case ONE: + case OLT: + case OLE: + case OGE: + case OGT: + case OLO: + case OLS: + case OHS: + case OHI: + a = ACMPW; + if(isv(et)) + a = ACMP; + if(et == TFLOAT) + a = AFCMPS; + else if(et == TDOUBLE) + a = AFCMPD; + nextpc(); + p->as = a; + naddr(f1, &p->from); + if(f1->op == OCONST && p->from.offset < 0){ + if(a == ACMPW && (ulong)p->from.offset != 0x80000000UL) { + p->as = ACMNW; + p->from.offset = -p->from.offset; + }else if(a == ACMP && p->from.offset != 0x8000000000000000LL){ + p->as = ACMN; + p->from.offset = -p->from.offset; + } + } + raddr(f2, p); + switch(o) { + case OEQ: + if(zcmp(p, a == ACMP ? ACBZ : ACBZW)) + goto done; + a = ABEQ; + break; + case ONE: + if(zcmp(p, a == ACMP ? ACBNZ : ACBNZW)) + goto done; + a = ABNE; + break; + case OLT: + if(zcmp(p, ATBNZ)) + goto done; + a = ABLT; + /* ensure NaN comparison is always false */ + if(typefd[et] && !true) + a = ABMI; + break; + case OLE: + a = ABLE; + if(typefd[et] && !true) + a = ABLS; + break; + case OGE: + if(zcmp(p, ATBZ)) + goto done; + a = ABGE; + if(typefd[et] && true) + a = ABPL; + break; + case OGT: + a = ABGT; + if(typefd[et] && true) + a = ABHI; + break; + case OLO: + a = ABLO; + break; + case OLS: + if(zcmp(p, a == ACMP ? ACBZ : ACBZW)) + goto done; + a = ABLS; + break; + case OHS: + a = ABHS; + break; + case OHI: + if(zcmp(p, a == ACMP ? ACBNZ : ACBNZW)) + goto done; + a = ABHI; + break; + } + f1 = Z; + f2 = Z; + break; + } + if(a == AGOK) + diag(Z, "bad in gopcode %O", o); + nextpc(); + p->as = a; + if(f1 != Z) + naddr(f1, &p->from); + if(f2 != Z) { + naddr(f2, &ta); + p->reg = ta.reg; + } + if(t != Z) + naddr(t, &p->to); +done: + if(debug['g']) + print("%P\n", p); +} + +int +samaddr(Node *f, Node *t) +{ + return f->op == OREGISTER && t->op == OREGISTER && f->reg == t->reg; +} + +void +gbranch(int o) +{ + int a; + + a = AGOK; + switch(o) { + case ORETURN: + a = ARETURN; + break; + case OGOTO: + a = AB; + break; + } + nextpc(); + if(a == AGOK) { + diag(Z, "bad in gbranch %O", o); + nextpc(); + } + p->as = a; +} + +void +patch(Prog *op, long pc) +{ + + op->to.offset = pc; + op->to.type = D_BRANCH; +} + +void +gpseudo(int a, Sym *s, Node *n) +{ + + nextpc(); + p->as = a; + p->from.type = D_OREG; + p->from.sym = s; + p->from.name = D_EXTERN; + if(a == ATEXT) + p->reg = (profileflg ? 0 : NOPROF); + if(s->class == CSTATIC) + p->from.name = D_STATIC; + naddr(n, &p->to); + if(a == ADATA || a == AGLOBL) + pc--; +} + +int +sconst(Node *n) +{ + vlong vv; + + if(n->op == OCONST) { + if(!typefd[n->type->etype]) { + vv = n->vconst; + if(vv >= (vlong)(-32766) && vv < (vlong)32766) + return 1; + /* + * should be specialised for constant values which will + * fit in different instructionsl; for now, let 5l + * sort it out + */ + return 1; + } + } + return 0; +} + +static int +isaddcon(vlong v) +{ + /* uimm12 or uimm24? */ + if(v < 0) + return 0; + if((v & 0xFFF) == 0) + v >>= 12; + return v <= 0xFFF; +} + +int +sval(vlong v) +{ + return isaddcon(v) || isaddcon(-v); +} + +int +usableoffset(Node *n, vlong o, Node *v) +{ + int s; + + if(v != nil){ + if(v->op != OCONST || typefd[v->type->etype]) + return 0; + o += v->vconst; + } + s = n->type->width; + if(s > 16) + s = 16; + if((o % s) != 0) + return 0; + return o >= -256 && o < 4096*s; +} + +long +exreg(Type *t) +{ + long o; + + if(typechlpv[t->etype]) { + if(exregoffset <= REGEXT-2) + return 0; + o = exregoffset; + if(reg[o] && !resvreg[o]) + return 0; + resvreg[o] = reg[o] = 1; + exregoffset--; + return o; + } + if(typefd[t->etype]) { + if(exfregoffset <= NFREG-1) + return 0; + o = exfregoffset + NREG; + if(reg[o] && !resvreg[o]) + return 0; + resvreg[o] = reg[o] = 1; + exfregoffset--; + return o; + } + return 0; +} + +schar ewidth[NTYPE] = +{ + -1, /* [TXXX] */ + SZ_CHAR, /* [TCHAR] */ + SZ_CHAR, /* [TUCHAR] */ + SZ_SHORT, /* [TSHORT] */ + SZ_SHORT, /* [TUSHORT] */ + SZ_INT, /* [TINT] */ + SZ_INT, /* [TUINT] */ + SZ_LONG, /* [TLONG] */ + SZ_LONG, /* [TULONG] */ + SZ_VLONG, /* [TVLONG] */ + SZ_VLONG, /* [TUVLONG] */ + SZ_FLOAT, /* [TFLOAT] */ + SZ_DOUBLE, /* [TDOUBLE] */ + SZ_IND, /* [TIND] */ + 0, /* [TFUNC] */ + -1, /* [TARRAY] */ + 0, /* [TVOID] */ + -1, /* [TSTRUCT] */ + -1, /* [TUNION] */ + SZ_INT, /* [TENUM] */ +}; + +long ncast[NTYPE] = +{ + 0, /* [TXXX] */ + BCHAR|BUCHAR, /* [TCHAR] */ + BCHAR|BUCHAR, /* [TUCHAR] */ + BSHORT|BUSHORT, /* [TSHORT] */ + BSHORT|BUSHORT, /* [TUSHORT] */ + BINT|BUINT|BLONG|BULONG, /* [TINT] */ + BINT|BUINT|BLONG|BULONG, /* [TUINT] */ + BINT|BUINT|BLONG|BULONG, /* [TLONG] */ + BINT|BUINT|BLONG|BULONG, /* [TULONG] */ + BVLONG|BUVLONG|BIND, /* [TVLONG] */ + BVLONG|BUVLONG|BIND, /* [TUVLONG] */ + BFLOAT, /* [TFLOAT] */ + BDOUBLE, /* [TDOUBLE] */ + BVLONG|BUVLONG|BIND, /* [TIND] */ + 0, /* [TFUNC] */ + 0, /* [TARRAY] */ + 0, /* [TVOID] */ + BSTRUCT, /* [TSTRUCT] */ + BUNION, /* [TUNION] */ + 0, /* [TENUM] */ +}; --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/asm.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,562 @@ +#include "l.h" + +long OFFSET; + +#define PADDR(a) ((a) & ~0xfffffffff0000000ull) + +vlong +entryvalue(void) +{ + char *a; + Sym *s; + + a = INITENTRY; + if(*a >= '0' && *a <= '9') + return atolwhex(a); + s = lookup(a, 0); + if(s->type == 0) + return INITTEXT; + switch(s->type) { + case STEXT: + case SLEAF: + break; + case SDATA: + if(dlm) + return s->value+INITDAT; + default: + diag("entry not text: %s", s->name); + } + return s->value; +} + +void +cflush(void) +{ + int n; + + n = sizeof(buf.cbuf) - cbc; + if(n) + write(cout, buf.cbuf, n); + cbp = buf.cbuf; + cbc = sizeof(buf.cbuf); +} + +void +asmb(void) +{ + Prog *p; + long magic; + vlong vl, etext; + Optab *o; + uchar *sbuf, *dbuf; + + if(debug['v']) + Bprint(&bso, "%5.2f asm\n", cputime()); + Bflush(&bso); + OFFSET = HEADR; + seek(cout, OFFSET, 0); + pc = INITTEXT; + for(p = firstp; p != P; p = p->link) { + if(p->as == ATEXT) { + curtext = p; + autosize = p->to.offset + PCSZ; + }else if(p->as == ADWORD && (pc & 7) != 0) { + lputl(0); + pc += 4; + } + if(p->pc != pc) { + diag("phase error %llux sb %llux", + p->pc, pc); + if(!debug['a']) + prasm(curp); + pc = p->pc; + } + curp = p; + o = oplook(p); /* could probably avoid this call */ + asmout(p, o); + pc += o->size; + } + + if(debug['a']) + Bprint(&bso, "\n"); + Bflush(&bso); + cflush(); + + /* output strings in text segment */ + etext = INITTEXT + textsize; + sbuf = calloc(1, etext-pc); + dbuf = calloc(1, datsize); + datfill(sbuf, pc, dbuf, 0); + write(cout, sbuf, etext-pc); + free(sbuf); + + curtext = P; + switch(HEADTYPE) { + case 0: + case 2: + case 7: + OFFSET = HEADR+textsize; + seek(cout, OFFSET, 0); + break; + case 6: /* no header, padded segments */ + OFFSET = rnd(HEADR+textsize, INITRND); + seek(cout, OFFSET, 0); + break; + } + if(dlm){ + char buf[8]; + + write(cout, buf, INITDAT-textsize); + textsize = INITDAT; + } + write(cout, dbuf, datsize); + free(dbuf); + + symsize = 0; + lcsize = 0; + if(!debug['s']) { + if(debug['v']) + Bprint(&bso, "%5.2f sym\n", cputime()); + Bflush(&bso); + switch(HEADTYPE) { + case 0: + debug['s'] = 1; + break; + case 2: + OFFSET = HEADR+textsize+datsize; + seek(cout, OFFSET, 0); + break; + case 6: /* no header, padded segments */ + OFFSET += rnd(datsize, INITRND); + seek(cout, OFFSET, 0); + break; + case 7: + break; + } + if(!debug['s']) + asmsym(); + if(debug['v']) + Bprint(&bso, "%5.2f pc\n", cputime()); + Bflush(&bso); + if(!debug['s']) + asmlc(); + if(dlm) + asmdyn(); + cflush(); + } + else if(dlm){ + seek(cout, HEADR+textsize+datsize, 0); + asmdyn(); + cflush(); + } + + if(debug['v']) + Bprint(&bso, "%5.2f header\n", cputime()); + Bflush(&bso); + OFFSET = 0; + seek(cout, OFFSET, 0); + switch(HEADTYPE) { + case 0: /* no header */ + case 6: /* no header, padded segments */ + break; + case 2: /* plan 9 */ + magic = 4*28*28+7; + magic |= 0x00008000; /* fat header */ + if(dlm) + magic |= 0x80000000; /* dlm */ + lput(magic); /* magic */ + lput(textsize); /* sizes */ + lput(datsize); + lput(bsssize); + lput(symsize); /* nsyms */ + vl = entryvalue(); + lput(PADDR(vl)); /* va of entry */ + lput(0L); + lput(lcsize); + llput(vl); /* va of entry */ + break; + } + cflush(); +} + +void +cput(int c) +{ + cbp[0] = c; + cbp++; + cbc--; + if(cbc <= 0) + cflush(); +} + +void +wput(long l) +{ + + cbp[0] = l>>8; + cbp[1] = l; + cbp += 2; + cbc -= 2; + if(cbc <= 0) + cflush(); +} + +void +wputl(long l) +{ + + cbp[0] = l; + cbp[1] = l>>8; + cbp += 2; + cbc -= 2; + if(cbc <= 0) + cflush(); +} + +void +lput(long l) +{ + + cbp[0] = l>>24; + cbp[1] = l>>16; + cbp[2] = l>>8; + cbp[3] = l; + cbp += 4; + cbc -= 4; + if(cbc <= 0) + cflush(); +} + +void +lputl(long l) +{ + + cbp[3] = l>>24; + cbp[2] = l>>16; + cbp[1] = l>>8; + cbp[0] = l; + cbp += 4; + cbc -= 4; + if(cbc <= 0) + cflush(); +} + +void +llput(vlong v) +{ + lput(v>>32); + lput(v); +} + +void +llputl(vlong v) +{ + lputl(v); + lputl(v>>32); +} + +void +asmsym(void) +{ + Prog *p; + Auto *a; + Sym *s; + int h; + + s = lookup("etext", 0); + if(s->type == STEXT) + putsymb(s->name, 'T', s->value, s->version); + + for(h=0; hlink) + switch(s->type) { + case SCONST: + putsymb(s->name, 'D', s->value, s->version); + continue; + + case SDATA: + putsymb(s->name, 'D', s->value+INITDAT, s->version); + continue; + + case SBSS: + putsymb(s->name, 'B', s->value+INITDAT, s->version); + continue; + + case SSTRING: + putsymb(s->name, 'T', s->value, s->version); + continue; + + case SFILE: + putsymb(s->name, 'f', s->value, s->version); + continue; + } + + for(p=textp; p!=P; p=p->cond) { + s = p->from.sym; + if(s->type != STEXT && s->type != SLEAF) + continue; + + /* filenames first */ + for(a=p->to.autom; a; a=a->link) + if(a->type == D_FILE) + putsymb(a->asym->name, 'z', a->aoffset, 0); + else + if(a->type == D_FILE1) + putsymb(a->asym->name, 'Z', a->aoffset, 0); + + if(s->type == STEXT) + putsymb(s->name, 'T', s->value, s->version); + else + putsymb(s->name, 'L', s->value, s->version); + + /* frame, auto and param after */ + putsymb(".frame", 'm', p->to.offset+PCSZ, 0); + for(a=p->to.autom; a; a=a->link) + if(a->type == D_AUTO) + putsymb(a->asym->name, 'a', -a->aoffset, 0); + else + if(a->type == D_PARAM) + putsymb(a->asym->name, 'p', a->aoffset, 0); + } + if(debug['v'] || debug['n']) + Bprint(&bso, "symsize = %lud\n", symsize); + Bflush(&bso); +} + +void +putsymb(char *s, int t, vlong v, int ver) +{ + int i, f, l; + + if(t == 'f') + s++; + l = 4; + switch(HEADTYPE){ + default: + break; + case 2: + lput(v>>32); + l = 8; + break; + } + lput(v); + if(ver) + t += 'a' - 'A'; + cput(t+0x80); /* 0x80 is variable length */ + + if(t == 'Z' || t == 'z') { + cput(s[0]); + for(i=1; s[i] != 0 || s[i+1] != 0; i += 2) { + cput(s[i]); + cput(s[i+1]); + } + cput(0); + cput(0); + i++; + } + else { + for(i=0; s[i]; i++) + cput(s[i]); + cput(0); + } + symsize += l + 1 + i + 1; + + if(debug['n']) { + if(t == 'z' || t == 'Z') { + Bprint(&bso, "%c %.8llux ", t, v); + for(i=1; s[i] != 0 || s[i+1] != 0; i+=2) { + f = ((s[i]&0xff) << 8) | (s[i+1]&0xff); + Bprint(&bso, "/%x", f); + } + Bprint(&bso, "\n"); + return; + } + if(ver) + Bprint(&bso, "%c %.8llux %s<%d>\n", t, v, s, ver); + else + Bprint(&bso, "%c %.8llux %s\n", t, v, s); + } +} + +#define MINLC 4 +void +asmlc(void) +{ + vlong oldpc; + Prog *p; + long v, s, oldlc; + + oldpc = INITTEXT; + oldlc = 0; + for(p = firstp; p != P; p = p->link) { + if(p->line == oldlc || p->as == ATEXT || p->as == ANOP) { + if(p->as == ATEXT) + curtext = p; + if(debug['V']) + Bprint(&bso, "%6llux %P\n", + p->pc, p); + continue; + } + if(debug['V']) + Bprint(&bso, "\t\t%6ld", lcsize); + v = (p->pc - oldpc) / MINLC; + while(v) { + s = 127; + if(v < 127) + s = v; + cput(s+128); /* 129-255 +pc */ + if(debug['V']) + Bprint(&bso, " pc+%ld*%d(%ld)", s, MINLC, s+128); + v -= s; + lcsize++; + } + s = p->line - oldlc; + oldlc = p->line; + oldpc = p->pc + MINLC; + if(s > 64 || s < -64) { + cput(0); /* 0 vv +lc */ + cput(s>>24); + cput(s>>16); + cput(s>>8); + cput(s); + if(debug['V']) { + if(s > 0) + Bprint(&bso, " lc+%ld(%d,%ld)\n", + s, 0, s); + else + Bprint(&bso, " lc%ld(%d,%ld)\n", + s, 0, s); + Bprint(&bso, "%6llux %P\n", + p->pc, p); + } + lcsize += 5; + continue; + } + if(s > 0) { + cput(0+s); /* 1-64 +lc */ + if(debug['V']) { + Bprint(&bso, " lc+%ld(%ld)\n", s, 0+s); + Bprint(&bso, "%6llux %P\n", + p->pc, p); + } + } else { + cput(64-s); /* 65-128 -lc */ + if(debug['V']) { + Bprint(&bso, " lc%ld(%ld)\n", s, 64-s); + Bprint(&bso, "%6llux %P\n", + p->pc, p); + } + } + lcsize++; + } + while(lcsize & 1) { + s = 129; + cput(s); + lcsize++; + } + if(debug['v'] || debug['V']) + Bprint(&bso, "lcsize = %ld\n", lcsize); + Bflush(&bso); +} + +void +datfill(uchar *sbuf, long soff, uchar *dbuf, long doff) +{ + Sym *v; + Prog *p; + uchar *cast, *b, *nuxi; + long a, l, fl, j; + vlong d; + int i, c; + + for(p = datap; p != P; p = p->link) { + curp = p; + a = p->from.sym->value + p->from.offset; + l = a; + if(p->from.sym->type == SSTRING){ + b = sbuf; + l -= soff; + }else{ + b = dbuf; + l -= doff; + } + + c = p->reg; + i = 0; + if(p->as != AINIT && p->as != ADYNT && !p->from.sym->dupok) { + for(j=l+(c-i)-1; j>=l; j--) + if(b[j]) { + print("%P\n", p); + diag("multiple initialization"); + break; + } + } + cast = nuxi = nil; + switch(p->to.type) { + default: + diag("unknown mode in initialization%P", p); + break; + + case D_SCONST: + while(i < c) + b[l++] = p->to.sval[i++]; + break; + + case D_FCONST: + switch(c) { + default: + case 4: + fl = ieeedtof(p->to.ieee); + cast = (uchar*)&fl; + nuxi = fnuxi4; + break; + case 8: + cast = (uchar*)p->to.ieee; + nuxi = fnuxi8; + break; + } + break; + + case D_CONST: + d = p->to.offset; + v = p->to.sym; + if(v) { + switch(v->type) { + case SUNDEF: + ckoff(v, d); + case STEXT: + case SLEAF: + case SSTRING: + d += p->to.sym->value; + break; + case SDATA: + case SBSS: + d += p->to.sym->value + INITDAT; + } + if(dlm) + dynreloc(v, a+INITDAT, 1); + } + cast = (uchar*)&d; + nuxi = inuxi[c]; + break; + } + if(cast) + while(i < c) + b[l++] = cast[nuxi[i++]]; + } +} + +int +chipfloat(Ieee *e) +{ + int n, Bbbbbbbbb; + + if(e->l != 0 || (e->h & 0xffffU) != 0) + return -1; + n = e->h >> 16; + Bbbbbbbbb = (n>>6) & 0x1ff; + if(Bbbbbbbbb != 0x100 && Bbbbbbbbb != 0xff) + return -1; + n = (n & 0x8000) >> 8 | (n & 0x7f); + return n; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/asmout.c Tue Dec 30 17:28:54 2025 @@ -0,0 +1,1791 @@ +#include "l.h" + +#define S32 (0U<<31) +#define S64 (1U<<31) +#define Rm(X) (((X)&31)<<16) +#define Rn(X) (((X)&31)<<5) +#define Rd(X) (((X)&31)<<0) +#define Sbit (1U<<29) + +#define OPDP2(x) (0<<30 | 0 << 29 | 0xd6<<21 | (x)<<10) +#define OPDP3(sf,op54,op31,o0) ((sf)<<31 | (op54)<<29 | 0x1B<<24 | (op31)<<21 | (o0)<<15) +#define OPBcc(x) (0x2A<<25 | 0<<24 | 0<<4 | ((x)&15)) +#define OPBLR(x) (0x6B<<25 | 0<<23 | (x)<<21 | 0x1F<<16 | 0<<10) /* x=0, JMP; 1, CALL; 2, RET */ +#define SYSOP(l,op0,op1,crn,crm,op2,rt) (0x354<<22 | (l)<<21 | (op0)<<19 | (op1)<<16 | (crn)<<12 | (crm)<<8 | (op2)<<5 | (rt)) +#define SYSHINT(x) SYSOP(0,0,3,2,0,(x),0x1F) + +#define LDSTR12U(sz,v,opc) ((sz)<<30 | 7<<27 | (v)<<26 | 1<<24 | (opc)<<22) +#define LDSTR9S(sz,v,opc) ((sz)<<30 | 7<<27 | (v)<<26 | 0<<24 | (opc)<<22) +#define LD2STR(o) ((o) & ~(3<<22)) + +#define LDSTX(sz,o2,l,o1,o0) ((sz)<<30 | 0x8<<24 | (o2)<<23 | (l)<<22 | (o1)<<21 | (o0)<<15) + +#define FPCMP(m,s,type,op,op2) ((m)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 1<<21 | (op)<<14 | 8<<10 | (op2)) +#define FPCCMP(m,s,type,op) ((m)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 1<<21 | 1<<10 | (op)<<4) +#define FPOP1S(m,s,type,op) ((m)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 1<<21 | (op)<<15 | 0x10<<10) +#define FPOP2S(m,s,type,op) ((m)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 1<<21 | (op)<<12 | 2<<10) +#define FPOP3S(type,op,op2) (0x1F<<24 | (type)<<22 | (op2)<<21 | (op)<<15) +#define FPCVTI(sf,s,type,rmode,op) ((sf)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 1<<21 | (rmode)<<19 | (op)<<16 | 0<<10) +#define FPCVTF(sf,s,type,rmode,op,scale) ((sf)<<31 | (s)<<29 | 0x1E<<24 | (type)<<22 | 0<<21 | (rmode)<<19 | (op)<<16 | (scale)<<10) +#define ADR(p,o,rt) ((p)<<31 | ((o)&3)<<29 | (0x10<<24) | (((o>>2)&0x7FFFF)<<5) | (rt)) + +#define LSL0_32 (2<<13) +#define LSL0_64 (3<<13) + +static long opbrr(int); +static long opbra(int); +static long oshrr(int, int, int); +static long olhrr(int, int, int); +static long olsr12u(long, long, int, int); +static long olsr9s(long, long, int, int); +static long opimm(int); +static vlong brdist(Prog*, int, int, int); +static long opbfm(int, int, int, int, int); +static long opextr(int, long, int, int, int); +static long opbit(int); +static long op0(int); +static long opstr12(int); +static long opstr9(int); +static long opldr9(int); +static long opxrrr(int); +static long olsxrr(int, int, int, int); +static long opfmovr(int); +static long oprrr(int); +static long opirr(int); +static long opldr12(int); +static long opldrpp(int); +static long opload(int); +static long opstore(int); +static long omovlit(int, Prog*, Adr*, int); +static int movesize(int); +static long oaddi(long, long, int, int); + +/* + * valid pstate field values, and value to use in instruction + */ +static struct{ + ulong a; + ulong b; +} pstatefield[] = { +D_SPSel, (0<<16) | (4<<12) | (5<<5), +D_DAIFSet, (3<<16) | (4<<12) | (6<<5), +D_DAIFClr, (3<<16) | (4<<12) | (7<<5), +}; + +void +asmout(Prog *p, Optab *o) +{ + long o1, o2, o3, o4, o5, v, hi; + vlong d; + int r, s, rf, rt, ra, nzcv, cond, i, as; + Mask *mask; + static Prog *lastcase; + + o1 = 0; + o2 = 0; + o3 = 0; + o4 = 0; + o5 = 0; + switch(o->type) { + default: + diag("unknown asm %d", o->type); + prasm(p); + break; + + case 0: /* pseudo ops */ + break; + + case 1: /* op Rm,[Rn],Rd; default Rn=Rd -> op Rm<<0,[Rn,]Rd (shifted register) */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + r = p->reg; + if(p->to.type == D_NONE) + rt = REGZERO; + if(r == NREG) + r = rt; + o1 |= (rf<<16) | (r<<5) | rt; + break; + + case 2: /* add/sub $(uimm12|uimm24)[,R],R; cmp $(uimm12|uimm24),R */ + o1 = opirr(p->as); + rt = p->to.reg; + if(p->to.type == D_NONE){ + if((o1 & Sbit) == 0) + diag("ineffective ZR destination\n%P", p); + rt = REGZERO; + } + r = p->reg; + if(r == NREG) + r = rt; + v = regoff(&p->from); + o1 = oaddi(o1, v, r, rt); + break; + + case 3: /* op R<as); + o1 |= p->from.offset; /* includes reg, op, etc */ + rt = p->to.reg; + if(p->to.type == D_NONE) + rt = REGZERO; + r = p->reg; + if(p->as == AMVN || p->as == AMVNW) + r = REGZERO; + else if(r == NREG) + r = rt; + o1 |= (r<<5) | rt; + break; + + case 4: /* mov $addcon, R; mov $recon, R; mov $racon, R */ + o1 = opirr(p->as); + rt = p->to.reg; + r = o->param; + if(r == 0) + r = REGZERO; + v = regoff(&p->from); + if((v & 0xFFF000) != 0){ + v >>= 12; + o1 |= 1<<22; /* shift, by 12 */ + } + o1 |= ((v& 0xFFF) << 10) | (r<<5) | rt; + break; + + case 5: /* b s; bl s */ + o1 = opbra(p->as); + o1 |= brdist(p, 0, 26, 2); + break; + + case 6: /* b ,O(R); bl ,O(R) */ + o1 = opbrr(p->as); + o1 |= p->to.reg << 5; + break; + + case 7: /* beq s */ + o1 = opbra(p->as); + o1 |= brdist(p, 0, 19, 2)<<5; + break; + + case 8: /* lsl $c,[R],R -> ubfm $(W-1)-c,$(-c MOD (W-1)),Rn,Rd */ + rt = p->to.reg; + rf = p->reg; + if(rf == NREG) + rf = rt; + v = p->from.offset; + switch(p->as){ + case AASR: o1 = opbfm(ASBFM, v, 63, rf, rt); break; + case AASRW: o1 = opbfm(ASBFMW, v, 31, rf, rt); break; + case ALSL: o1 = opbfm(AUBFM, (64-v)&63, 63-v, rf, rt); break; + case ALSLW: o1 = opbfm(AUBFMW, (32-v)&31, 31-v, rf, rt); break; + case ALSR: o1 = opbfm(AUBFM, v, 63, rf, rt); break; + case ALSRW: o1 = opbfm(AUBFMW, v, 31, rf, rt); break; + case AROR: o1 = opextr(AEXTR, v, rf, rf, rt); break; + case ARORW: o1 = opextr(AEXTRW, v, rf, rf, rt); break; + default: + diag("bad shift $con\n%P", curp); + break; + } + break; + + case 9: /* lsl Rm,[Rn],Rd -> lslv Rm, Rn, Rd */ + o1 = oprrr(p->as); + r = p->reg; + if(r == NREG) + r = p->to.reg; + o1 |= (p->from.reg << 16) | (r<<5) | p->to.reg; + break; + + case 10: /* brk/hvc/.../svc [$con] */ + o1 = opimm(p->as); + if(p->to.type != D_NONE) + o1 |= (p->to.offset & 0xffff)<<5; + break; + + case 11: /* dword */ + switch(aclass(&p->to)) { + case C_VCON: + case C_ZCON: + case C_LCON: + if(!dlm) + break; + if(p->to.name != D_EXTERN && p->to.name != D_STATIC) + break; + case C_ADDR: + if(p->to.sym->type == SUNDEF) + ckoff(p->to.sym, p->to.offset); + dynreloc(p->to.sym, p->pc, 1); + } + o1 = instoffset; + o2 = instoffset >> 32; + break; + + case 12: /* movT $lcon, reg */ + o1 = omovlit(p->as, p, &p->from, p->to.reg); + break; + + case 13: /* addop $lcon, [R], R (64 bit literal); cmp $lcon,R -> addop $lcon,R, ZR */ + o1 = omovlit(AMOV, p, &p->from, REGTMP); + rt = p->to.reg; + if(p->to.type == D_NONE) + rt = REGZERO; + r = p->reg; + if(r == NREG) + r = rt; + if(p->to.type != D_NONE && (p->to.reg == REGSP || r == REGSP)){ + o2 = opxrrr(p->as); + o2 |= REGTMP<<16; + o2 |= LSL0_64; + }else{ + o2 = oprrr(p->as); + o2 |= REGTMP << 16; /* shift is 0 */ + } + o2 |= r << 5; + o2 |= rt; + break; + + case 14: /* word */ + if(aclass(&p->to) == C_ADDR) + diag("address constant needs DWORD\n%P", p); + o1 = instoffset; + break; + + case 15: /* mul/mneg/umulh/umull r,[r,]r; madd/msub Rm,Rn,[Ra,]Rd */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + if(p->from3.type == D_REG){ + r = p->from3.reg; + ra = p->reg; + if(ra == NREG) + ra = REGZERO; + }else{ + r = p->reg; + if(r == NREG) + r = rt; + ra = REGZERO; + } + o1 |= (rf<<16) | (ra<<10) | (r<<5) | rt; + break; + + case 16: /* XremY R[,R],R -> XdivY; XmsubY */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + r = p->reg; + if(r == NREG) + r = rt; + o1 |= (rf<<16) | (r<<5) | REGTMP; + o2 = oprrr(AMSUBW); + o2 |= o1 & (1<<31); /* same size */ + o2 |= (rf<<16) | (r<<10) | (REGTMP<<5) | rt; + break; + + case 17: /* op Rm,[Rn],Rd; default Rn=ZR */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + r = p->reg; + if(p->to.type == D_NONE) + rt = REGZERO; + if(r == NREG) + r = REGZERO; + o1 |= (rf<<16) | (r<<5) | rt; + break; + + case 18: /* csel cond,Rn,Rm,Rd; cinc/cinv/cneg cond,Rn,Rd; cset cond,Rd */ + o1 = oprrr(p->as); + cond = p->from.reg; + r = p->reg; + if(r != NREG){ + if(p->from3.type == D_NONE){ + /* CINC/CINV/CNEG */ + rf = r; + cond ^= 1; + }else + rf = p->from3.reg; /* CSEL */ + }else{ + /* CSET */ + if(p->from3.type != D_NONE) + diag("invalid combination\n%P", p); + r = rf = REGZERO; + cond ^= 1; + } + rt = p->to.reg; + o1 |= (r<<16) | (cond<<12) | (rf<<5) | rt; + break; + + case 19: /* CCMN cond, (Rm|uimm5),Rn, uimm4 -> ccmn Rn,Rm,uimm4,cond */ + nzcv = p->to.offset; + cond = p->from.reg; + if(p->from3.type == D_REG){ + o1 = oprrr(p->as); + rf = p->from3.reg; /* Rm */ + }else{ + o1 = opirr(p->as); + rf = p->from3.offset & 0x1F; + } + o1 |= (rf<<16) | (cond<<12) | (p->reg<<5) | nzcv; + break; + + case 20: /* movT R,O(R) -> strT */ + v = regoff(&p->to); + r = p->to.reg; + if(r == NREG) + r = o->param; + if(v < 0){ /* unscaled 9-bit signed */ + o1 = olsr9s(opstr9(p->as), v, r, p->from.reg); + }else{ + v = offsetshift(v, o->a3); + o1 = olsr12u(opstr12(p->as), v, r, p->from.reg); + } + break; + + case 21: /* movT O(R),R -> ldrT */ + v = regoff(&p->from); + r = p->from.reg; + if(r == NREG) + r = o->param; + if(v < 0){ /* unscaled 9-bit signed */ + o1 = olsr9s(opldr9(p->as), v, r, p->to.reg); + }else{ + v = offsetshift(v, o->a1); + //print("offset=%lld v=%ld a1=%d\n", instoffset, v, o->a1); + o1 = olsr12u(opldr12(p->as), v, r, p->to.reg); + } + break; + + case 22: /* movT (R)O!,R; movT O(R)!, R -> ldrT */ + v = p->from.offset; + if(v < -256 || v > 255) + diag("offset out of range\n%P", p); + o1 = opldrpp(p->as); + if(p->from.type == D_XPOST) + o1 |= 1<<10; + else + o1 |= 3<<10; + o1 |= ((v&0x1FF)<<12) | (p->from.reg<<5) | p->to.reg; + break; + + case 23: /* movT R,(R)O!; movT O(R)!, R -> strT */ + v = p->to.offset; + if(v < -256 || v > 255) + diag("offset out of range\n%P", p); + o1 = LD2STR(opldrpp(p->as)); + if(p->to.type == D_XPOST) + o1 |= 1<<10; + else + o1 |= 3<<10; + o1 |= ((v&0x1FF)<<12) | (p->to.reg<<5) | p->from.reg; + break; + + case 24: /* mov/mvn Rs,Rd -> add $0,Rs,Rd or orr Rs,ZR,Rd */ + rf = p->from.reg; + rt = p->to.reg; + s = rf == REGSP || rt == REGSP; + if(p->as == AMVN || p->as == AMVNW){ + if(s) + diag("illegal SP reference\n%P", p); + o1 = oprrr(p->as); + o1 |= (rf<<16) | (REGZERO<<5) | rt; + }else if(s){ + o1 = opirr(p->as); + o1 |= (rf<<5) | rt; + }else{ + o1 = oprrr(p->as); + o1 |= (rf<<16) | (REGZERO<<5) | rt; + } + break; + + case 25: /* negX Rs, Rd -> subX Rs<<0, ZR, Rd */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + o1 |= (rf<<16) | (REGZERO<<5) | rt; + break; + + case 26: /* negX Rm< subX Rm<as); + o1 |= p->from.offset; /* includes reg, op, etc */ + rt = p->to.reg; + o1 |= (REGZERO<<5) | rt; + break; + + case 27: /* op Rm<as); + if(p->from.type == D_EXTREG) + o1 |= p->from.offset; /* includes reg, op, etc */ + else + o1 |= p->from.reg << 16; + rt = p->to.reg; + if(p->to.type == D_NONE) + rt = REGZERO; + r = p->reg; + if(r == NREG) + r = rt; + o1 |= (r<<5) | rt; + break; + + case 28: /* logop $lcon, [R], R (64 bit literal) */ + o1 = omovlit(AMOV, p, &p->from, REGTMP); + r = p->reg; + if(r == NREG) + r = p->to.reg; + o2 = oprrr(p->as); + o2 |= REGTMP << 16; /* shift is 0 */ + o2 |= r << 5; + o2 |= p->to.reg; + break; + + case 29: /* op Rn, Rd */ + o1 = oprrr(p->as); + o1 |= p->from.reg<<5 | p->to.reg; + break; + + case 30: /* movT R,L(R) -> strT */ + s = movesize(o->as); + if(s < 0) + diag("unexpected long move, op %A tab %A\n%P", p->as, o->as, p); + v = regoff(&p->to); + if((v & ((1<>s) >= (1<<24)) + goto Hugestxr; + hi = v - (v & (0xFFF<>s)&0xFFF, ((v-hi)>>s)&0xFFF); + r = p->to.reg; + if(r == NREG) + r = o->param; + o1 = oaddi(opirr(AADD), hi, r, REGTMP); + o2 = olsr12u(opstr12(p->as), ((v-hi)>>s)&0xFFF, REGTMP, p->from.reg); + break; + + case 31: /* movT L(R), R -> ldrT */ + s = movesize(o->as); + if(s < 0) + diag("unexpected long move, op %A tab %A\n%P", p->as, o->as, p); + v = regoff(&p->from); + if((v & ((1<>s) >= (1<<24)) + goto Hugeldxr; + hi = v - (v & (0xFFF<>s)&0xFFF, ((v-hi)>>s)&0xFFF); + r = p->from.reg; + if(r == NREG) + r = o->param; + o1 = oaddi(opirr(AADD), hi, r, REGTMP); + o2 = olsr12u(opldr12(p->as), ((v-hi)>>s)&0xFFF, REGTMP, p->to.reg); + break; + + case 32: /* mov $con, R -> movz/movn */ + r = 32; + if(p->as == AMOV) + r = 64; + d = p->from.offset; + s = movcon(d); + if(s < 0 || s >= r){ + d = ~d; + s = movcon(d); + if(s < 0 || s >= r) + diag("impossible move wide: %#llux\n%P", p->from.offset, p); + if(p->as == AMOV) + o1 = opirr(AMOVN); + else + o1 = opirr(AMOVNW); + }else{ + if(p->as == AMOV) + o1 = opirr(AMOVZ); + else + o1 = opirr(AMOVZW); + } + rt = p->to.reg; + o1 |= (((d>>(s*16))& 0xFFFF) << 5) | ((s&3)<<21) | rt; + break; + + case 33: /* movk $uimm16 << pos */ + o1 = opirr(p->as); + d = p->from.offset; + if((d>>16) != 0) + diag("requires uimm16\n%P", p); + s = 0; + if(p->from3.type != D_NONE){ + if(p->from3.type != D_CONST) + diag("missing bit position\n%P", p); + s = p->from3.offset; + if((s&0xF) != 0 || (s /= 16) >= 4 || (o1&S64) == 0 && s >= 2) + diag("illegal bit position\n%P", p); + } + rt = p->to.reg; + o1 |= ((d & 0xFFFF) << 5) | ((s&3)<<21) | rt; + break; + + case 34: /* mov $lacon,R */ + o1 = omovlit(AMOV, p, &p->from, REGTMP); + if(!o1) + break; + + o2 = opxrrr(AADD); + o2 |= REGTMP << 16; + o2 |= LSL0_64; + r = p->from.reg; + if(r == NREG) + r = o->param; + o2 |= r << 5; + o2 |= p->to.reg; + break; + + case 35: /* mov SPR,R -> mrs */ + o1 = oprrr(AMRS); + v = p->from.offset; + if((o1 & (v & ~(3<<19))) != 0) + diag("MRS register value overlap\n%P", p); + o1 |= v; + o1 |= p->to.reg; + break; + + case 36: /* mov R,SPR */ + o1 = oprrr(AMSR); + v = p->to.offset; + if((o1 & (v & ~(3<<19))) != 0) + diag("MSR register value overlap\n%P", p); + o1 |= v; + o1 |= p->from.reg; + break; + + case 37: /* mov $con,PSTATEfield -> MSR [immediate] */ + if((p->from.offset&~(uvlong)0xF) != 0) + diag("illegal immediate for PSTATE field\n%P", p); + o1 = opirr(AMSR); + o1 |= (p->from.offset&0xF) << 8; /* Crm */ + v = 0; + for(i = 0; i < nelem(pstatefield); i++) + if(pstatefield[i].a == p->to.offset){ + v = pstatefield[i].b; + break; + } + if(v == 0) + diag("illegal PSTATE field for immediate move\n%P", p); + o1 |= v; + break; + + case 38: /* clrex [$imm] */ + o1 = opimm(p->as); + if(p->to.type == D_NONE) + o1 |= 0xF<<8; + else + o1 |= (p->to.offset & 0xF)<<8; + break; + + case 39: /* cbz R, rel */ + o1 = opirr(p->as); + o1 |= p->from.reg; + o1 |= brdist(p, 0, 19, 2) << 5; + break; + + case 40: /* tbz */ + o1 = opirr(p->as); + v = p->from.offset; + if(v < 0 || v > 63) + diag("illegal bit number\n%P", p); + o1 |= ((v&0x20)<<(31-5)) | ((v&0x1F)<<19); + o1 |= brdist(p, 0, 14, 2)<<5; + o1 |= p->reg; + break; + + case 41: /* eret, nop, others with no operands */ + o1 = op0(p->as); + break; + + case 42: /* bfm R,r,s,R */ + o1 = opbfm(p->as, p->from.offset, p->from3.offset, p->reg, p->to.reg); + break; + + case 43: /* bfm aliases */ + r = p->from.offset; + s = p->from3.offset; + rf = p->reg; + rt = p->to.reg; + if(rf == NREG) + rf = rt; + switch(p->as){ + case ABFI: o1 = opbfm(ABFM, 64-r, s-1, rf, rt); break; + case ABFIW: o1 = opbfm(ABFMW, 32-r, s-1, rf, rt); break; + case ABFXIL: o1 = opbfm(ABFM, r, r+s-1, rf, rt); break; + case ABFXILW: o1 = opbfm(ABFMW, r, r+s-1, rf, rt); break; + case ASBFIZ: o1 = opbfm(ASBFM, 64-r, s-1, rf, rt); break; + case ASBFIZW: o1 = opbfm(ASBFMW, 32-r, s-1, rf, rt); break; + case ASBFX: o1 = opbfm(ASBFM, r, r+s-1, rf, rt); break; + case ASBFXW: o1 = opbfm(ASBFMW, r, r+s-1, rf, rt); break; + case AUBFIZ: o1 = opbfm(AUBFM, 64-r, s-1, rf, rt); break; + case AUBFIZW: o1 = opbfm(AUBFMW, 32-r, s-1, rf, rt); break; + case AUBFX: o1 = opbfm(AUBFM, r, r+s-1, rf, rt); break; + case AUBFXW: o1 = opbfm(AUBFMW, r, r+s-1, rf, rt); break; + default: + diag("bad bfm alias\n%P", curp); + break; + } + break; + + case 44: /* extr $b, Rn, Rm, Rd */ + o1 = opextr(p->as, p->from.offset, p->from3.reg, p->reg, p->to.reg); + break; + + case 45: /* sxt/uxt[bhw] R,R; movT R,R -> sxtT R,R */ + rf = p->from.reg; + rt = p->to.reg; + as = p->as; + if(rf == REGZERO) + as = AMOVWU; /* clearer in disassembly */ + switch(as){ + case AMOVB: + case ASXTB: o1 = opbfm(ASBFM, 0, 7, rf, rt); break; + case AMOVH: + case ASXTH: o1 = opbfm(ASBFM, 0, 15, rf, rt); break; + case AMOVW: + case ASXTW: o1 = opbfm(ASBFM, 0, 31, rf, rt); break; + case AMOVBU: + case AUXTB: o1 = opbfm(AUBFM, 0, 7, rf, rt); break; + case AMOVHU: + case AUXTH: o1 = opbfm(AUBFM, 0, 15, rf, rt); break; + case AMOVWU: o1 = oprrr(as) | (rf<<16) | (REGZERO<<5) | rt; break; + case AUXTW: o1 = opbfm(AUBFM, 0, 31, rf, rt); break; + case ASXTBW: o1 = opbfm(ASBFMW, 0, 7, rf, rt); break; + case ASXTHW: o1 = opbfm(ASBFMW, 0, 15, rf, rt); break; + case AUXTBW: o1 = opbfm(AUBFMW, 0, 7, rf, rt); break; + case AUXTHW: o1 = opbfm(AUBFMW, 0, 15, rf, rt); break; + default: diag("bad sxt %A", as); break; + } + break; + + case 46: /* cls */ + o1 = opbit(p->as); + o1 |= p->from.reg<<5; + o1 |= p->to.reg; + break; + + case 47: /* movT R,V(R) -> strT (huge offset) */ + Hugestxr: + o1 = omovlit(AMOV, p, &p->to, REGTMP); + r = p->to.reg; + if(r == NREG) + r = o->param; + o2 = LD2STR(olsxrr(p->as, REGTMP, r, p->from.reg)); + o2 |= 7<<13; // REGTMP.SX + break; + + case 48: /* movT V(R), R -> ldrT (huge offset) */ + Hugeldxr: + o1 = omovlit(AMOV, p, &p->from, REGTMP); + r = p->from.reg; + if(r == NREG) + r = o->param; + o2 = olsxrr(p->as, REGTMP, r, p->to.reg); + o2 |= 7<<13; // REGTMP.SX + break; + + case 50: /* sys/sysl */ + o1 = opirr(p->as); + if((p->from.offset & ~SYSARG4(0x7, 0xF, 0xF, 0x7)) != 0) + diag("illegal SYS argument\n%P", p); + o1 |= p->from.offset; + if(p->to.type == D_REG) + o1 |= p->to.reg; + else if(p->reg != NREG) + o1 |= p->reg; + else + o1 |= 0x1F; + break; + + case 51: /* dmb */ + o1 = opirr(p->as); + if(p->from.type == D_CONST) + o1 |= (p->from.offset&0xF)<<8; + break; + + case 52: /* hint */ + o1 = opirr(p->as); + o1 |= (p->from.offset&0x7F)<<5; + break; + + case 53: /* and/or/eor... $bimmN, Rn, Rd -> op (N,r,s), Rn, Rd */ + as = p->as; + rt = p->to.reg; + r = p->reg; + if(r == NREG) + r = rt; + if(as == AMOV){ + as = AORR; + r = REGZERO; + }else if(as == AMOVW || as == AMOVWU){ + as = AORRW; + r = REGZERO; + } + o1 = opirr(as); + mask = findmask(p->from.offset); + if(mask == nil) + mask = findmask(p->from.offset | p->from.offset<<32); + if(mask == nil) + diag("invalid mask %#llux\n%P", p->from.offset, p); + switch(mask->e){ + case 2: o1 |= 0xF000; break; + case 4: o1 |= 0xE000; break; + case 8: o1 |= 0xC000; break; + case 16: o1 |= 0x8000; break; + case 64: o1 |= ((o1&S64)!=0)<<22; break; + } + o1 |= (mask->r<<16) | ((mask->s-1)<<10); + o1 |= (r<<5) | rt; + break; + + case 54: /* floating point arith */ + o1 = oprrr(p->as); + if(p->from.type == D_FCONST) { + rf = chipfloat(p->from.ieee); + if(rf < 0) + diag("invalid floating-point immediate\n%P", p); + rf = rf<<(13-5) | 1<<(12-5); + o1 &= ~(0x10<<10); + }else + rf = p->from.reg; + rt = p->to.reg; + r = p->reg; + if((o1 & (0x1F<<24)) == (0x1E<<24) && (o1 & (1<<11)) == 0){ /* monadic */ + r = rf; + rf = 0; + }else if(r == NREG) + r = rt; + o1 |= rf<<16 | r<<5 | rt; + break; + + case 55: /* fmovT Rn, Fd; fmovT Fn, Rd */ + o1 = opfmovr(p->as) | p->from.reg<<5 | p->to.reg; + if(p->to.type == D_FREG) + o1 |= 1<<16; + break; + + case 56: /* floating point compare */ + o1 = oprrr(p->as); + if(p->from.type == D_FCONST) { + if(p->from.ieee->h != 0 || p->from.ieee->l != 0) + diag("invalid floating-point immediate\n%P", p); + o1 |= 8; /* zero */ + rf = 0; + }else + rf = p->from.reg; + rt = p->reg; + o1 |= rf<<16 | rt<<5; + break; + + case 57: /* floating point conditional compare */ + o1 = oprrr(p->as); + cond = p->from.reg; + nzcv = p->to.offset; + if(nzcv & ~0xF) + diag("implausible condition\n%P", p); + rf = p->reg; + if(p->from3.type != D_FREG) + diag("illegal FCCMP\n%P", p); + rt = p->from3.reg; + o1 |= rf<<16 | cond<<12 | rt<<5 | nzcv; + break; + + case 58: /* ldxr */ + o1 = opload(p->as); + o1 |= 0x1F<<16; + o1 |= p->from.reg<<5; + if(p->reg != NREG) + o1 |= p->reg<<10; + else + o1 |= 0x1F<<10; + o1 |= p->to.reg; + break; + + case 59: /* stxr */ + o1 = opstore(p->as); + o1 |= 0x1F<<10; + o1 |= p->to.reg<<5; + if(p->reg != NREG) + o1 |= p->reg<<16; + else + o1 |= 0x1F<<16; + o1 |= p->from.reg; + break; + + case 60: /* adrp label,r */ + d = brdist(p, 12, 21, 0); + o1 = ADR(1, d, p->to.reg); + break; + + case 61: /* adr label, r */ + d = brdist(p, 0, 21, 0); + o1 = ADR(0, d, p->to.reg); + break; + + case 62: /* case Rv, Rt -> adr tab, REGTMP; movw REGTMP[R<<2], Rt; add Rt, REGTMP; br (REGTMP) */ + o1 = ADR(0, 4*4, REGTMP); /* adr 4(pc), REGTMP */ + o2 = (2<<30)|(7<<27)|(2<<22)|(1<<21)|(3<<13)|(1<<12)|(2<<10)|(p->from.reg<<16)|(REGTMP<<5)|p->to.reg; /* movw REGTMP[Rv<<2], Rt */ + o3 = oprrr(AADD) | (p->to.reg<<16) | (REGTMP<<5) | REGTMP; /* add Rt, REGTMP */ + o4 = (0x6b<<25)|(0x1F<<16)|(REGTMP<<5); /* br (REGTMP) */ + lastcase = p; + break; + + case 63: /* bcase */ + if(lastcase == nil){ + diag("missing CASE\n%P", p); + break; + } + if(p->cond != P) { + o1 = p->cond->pc - (lastcase->pc + 4*4); + if(dlm) + dynreloc(S, p->pc, 1); + } + break; + + /* reloc ops */ + case 64: /* movT R,addr */ + o1 = omovlit(AMOV, p, &p->to, REGTMP); + o2 = olsr12u(opstr12(p->as), 0, REGTMP, p->from.reg); + break; + + case 65: /* movT addr,R */ + o1 = omovlit(AMOV, p, &p->from, REGTMP); + o2 = olsr12u(opldr12(p->as), 0, REGTMP, p->to.reg); + break; + + case 66: /* movpT (R)O!,R,R; movpT O(R)!,R,R; movpT (R)O,R,R -> ldpT */ + o1 = opldrpp(p->as); + v = p->from.offset >> 2 + ((o1 & S64) != 0); + if(v < -128 || v > 127) + diag("offset out of range\n%P", p); + if(p->from.type == D_XPOST) + o1 |= 1<<23; + else if(p->from.type == D_XPRE) + o1 |= 3<<23; + else + o1 |= 2<<23; + o1 |= (v&0x7F)<<15 | p->from.reg<<5 | p->reg | p->to.reg<<10; + break; + + case 67: /* movpT R,R,(R)O!; movpT R,R,O(R)!; movpT R,R,O(R) -> stpT */ + o1 = LD2STR(opldrpp(p->as)); + v = p->to.offset >> 2 + ((o1 & S64) != 0); + if(v < -128 || v > 127) + diag("offset out of range\n%P", p); + if(p->to.type == D_XPOST) + o1 |= 1<<23; + else if(p->to.type == D_XPRE) + o1 |= 3<<23; + else + o1 |= 2<<23; + o1 |= (v&0x7F)<<15 | p->to.reg<<5 | p->from.reg | p->reg<<10; + break; + + case 68: /* movT R(R),R; movT R[R],R -> ldrT */ + v = p->from.offset; + o1 = olsxrr(p->as, v&31, p->from.reg, p->to.reg); + o1 |= ((v>>8)&7)<<13 | ((v>>16)&1)<<12; + break; + + case 69: /* movT R,R(R); movT R,R[R] -> strT */ + v = p->to.offset; + o1 = LD2STR(olsxrr(p->as, v&31, p->to.reg, p->from.reg)); + o1 |= ((v>>8)&7)<<13 | ((v>>16)&1)<<12; + break; + + case 70: /* fmadd/fmsub Rm,Rn,[Ra,]Rd */ + o1 = oprrr(p->as); + rf = p->from.reg; + rt = p->to.reg; + r = p->from3.reg; + ra = p->reg; + if(ra == NREG) + ra = rt; + o1 |= (rf<<16) | (ra<<10) | (r<<5) | rt; + break; + } + + if(debug['a'] > 1) + Bprint(&bso, "%2d ", o->type); + + v = p->pc; + switch(o->size) { + default: + if(debug['a']) + Bprint(&bso, " %.8lux:\t\t%P\n", v, p); + break; + case 4: + if(debug['a']) + Bprint(&bso, " %.8lux: %.8lux\t%P\n", v, o1, p); + lputl(o1); + break; + case 8: + if(debug['a']) + Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", v, o1, o2, p); + lputl(o1); + lputl(o2); + break; + case 12: + if(debug['a']) + Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux%P\n", v, o1, o2, o3, p); + lputl(o1); + lputl(o2); + lputl(o3); + break; + case 16: + if(debug['a']) + Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux%P\n", + v, o1, o2, o3, o4, p); + lputl(o1); + lputl(o2); + lputl(o3); + lputl(o4); + break; + case 20: + if(debug['a']) + Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux%P\n", + v, o1, o2, o3, o4, o5, p); + lputl(o1); + lputl(o2); + lputl(o3); + lputl(o4); + lputl(o5); + break; + } +} + +static long +opfmovr(int a) +{ + switch(a){ + case AFMOVS: return 0<<31 | 0x1e<<24 | 0<<22 | 1<<21 | 6<<16; + case AFMOVD: return 1<<31 | 0x1e<<24 | 1<<22 | 1<<21 | 6<<16; + default: + diag("bad fmov op\n%P", curp); + return 0; + } +} + +/* + * basic Rm op Rn -> Rd (using shifted register with 0) + * also op Rn -> Rt + * also Rm*Rn op Ra -> Rd + */ +static long +oprrr(int a) +{ + switch(a) { + case AADC: return S64 | 0<<30 | 0<<29 | 0xd0<<21 | 0<<10; + case AADCW: return S32 | 0<<30 | 0<<29 | 0xd0<<21 | 0<<10; + case AADCS: return S64 | 0<<30 | 1<<29 | 0xd0<<21 | 0<<10; + case AADCSW: return S32 | 0<<30 | 1<<29 | 0xd0<<21 | 0<<10; + + case ANGC: + case ASBC: return S64 | 1<<30 | 0<<29 | 0xd0<<21 | 0<<10; + case ANGCS: + case ASBCS: return S64 | 1<<30 | 1<<29 | 0xd0<<21 | 0<<10; + case ANGCW: + case ASBCW: return S32 | 1<<30 | 0<<29 | 0xd0<<21 | 0<<10; + case ANGCSW: + case ASBCSW: return S32 | 1<<30 | 1<<29 | 0xd0<<21 | 0<<10; + + case AADD: return S64 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case AADDW: return S32 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case ACMN: + case AADDS: return S64 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case ACMNW: + case AADDSW: return S32 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + + case ASUB: return S64 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case ASUBW: return S32 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case ACMP: + case ASUBS: return S64 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + case ACMPW: + case ASUBSW: return S32 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10; + + case AAND: return S64 | 0<<29 | 0xA<<24; + case AANDW: return S32 | 0<<29 | 0xA<<24; + case AMOV: + case AORR: return S64 | 1<<29 | 0xA<<24; +// case AMOVW: + case AMOVWU: + case AORRW: return S32 | 1<<29 | 0xA<<24; + case AEOR: return S64 | 2<<29 | 0xA<<24; + case AEORW: return S32 | 2<<29 | 0xA<<24; + case AANDS: return S64 | 3<<29 | 0xA<<24; + case AANDSW: return S32 | 3<<29 | 0xA<<24; + + case ABIC: return S64 | 0<<29 | 0xA<<24 | 1<<21; + case ABICW: return S32 | 0<<29 | 0xA<<24 | 1<<21; + case ABICS: return S64 | 3<<29 | 0xA<<24 | 1<<21; + case ABICSW: return S32 | 3<<29 | 0xA<<24 | 1<<21; + case AEON: return S64 | 2<<29 | 0xA<<24 | 1<<21; + case AEONW: return S32 | 2<<29 | 0xA<<24 | 1<<21; + case AMVN: + case AORN: return S64 | 1<<29 | 0xA<<24 | 1<<21; + case AMVNW: + case AORNW: return S32 | 1<<29 | 0xA<<24 | 1<<21; + + case AASR: return S64 | OPDP2(10); /* also ASRV */ + case AASRW: return S32 | OPDP2(10); + case ALSL: return S64 | OPDP2(8); + case ALSLW: return S32 | OPDP2(8); + case ALSR: return S64 | OPDP2(9); + case ALSRW: return S32 | OPDP2(9); + case AROR: return S64 | OPDP2(11); + case ARORW: return S32 | OPDP2(11); + + case ACCMN: return S64 | 0<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4; /* cond<<12 | nzcv<<0 */ + case ACCMNW: return S32 | 0<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4; + case ACCMP: return S64 | 1<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4; /* imm5<<16 | cond<<12 | nzcv<<0 */ + case ACCMPW: return S32 | 1<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4; + + case ACRC32B: return S32 | OPDP2(16); + case ACRC32H: return S32 | OPDP2(17); + case ACRC32W: return S32 | OPDP2(18); + case ACRC32X: return S64 | OPDP2(19); + case ACRC32CB: return S32 | OPDP2(20); + case ACRC32CH: return S32 | OPDP2(21); + case ACRC32CW: return S32 | OPDP2(22); + case ACRC32CX: return S64 | OPDP2(23); + + case ACSEL: return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACSELW: return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACSET: return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + case ACSETW: return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + case ACSETM: return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACSETMW: return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACINC: + case ACSINC: return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + case ACINCW: + case ACSINCW: return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + case ACINV: + case ACSINV: return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACINVW: + case ACSINVW: return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10; + case ACNEG: + case ACSNEG: return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + case ACNEGW: + case ACSNEGW: return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10; + + case AMUL: + case AMADD: return S64 | 0<<29 | 0x1B<<24 | 0<<21 | 0<<15; + case AMULW: + case AMADDW: return S32 | 0<<29 | 0x1B<<24 | 0<<21 | 0<<15; + case AMNEG: + case AMSUB: return S64 | 0<<29 | 0x1B<<24 | 0<<21 | 1<<15; + case AMNEGW: + case AMSUBW: return S32 | 0<<29 | 0x1B<<24 | 0<<21 | 1<<15; + + case AMRS: return SYSOP(1,2,0,0,0,0,0); + case AMSR: return SYSOP(0,2,0,0,0,0,0); + + case ANEG: return S64 | 1<<30 | 0<<29 | 0xB<<24 | 0<<21; + case ANEGW: return S32 | 1<<30 | 0<<29 | 0xB<<24 | 0<<21; + case ANEGS: return S64 | 1<<30 | 1<<29 | 0xB<<24 | 0<<21; + case ANEGSW: return S32 | 1<<30 | 1<<29 | 0xB<<24 | 0<<21; + + case AREM: + case ASDIV: return S64 | OPDP2(3); + case AREMW: + case ASDIVW: return S32 | OPDP2(3); + + case ASMULL: + case ASMADDL: return OPDP3(1, 0, 1, 0); + case ASMNEGL: + case ASMSUBL: return OPDP3(1, 0, 1, 1); + case ASMULH: return OPDP3(1, 0, 2, 0); + case AUMULL: + case AUMADDL: return OPDP3(1, 0, 5, 0); + case AUMNEGL: + case AUMSUBL: return OPDP3(1, 0, 5, 1); + case AUMULH: return OPDP3(1, 0, 6, 0); + + case AUREM: + case AUDIV: return S64 | OPDP2(2); + case AUREMW: + case AUDIVW: return S32 | OPDP2(2); + + case AAESE: return 0x4E<<24 | 2<<20 | 8<<16 | 4<<12 | 2<<10; + case AAESD: return 0x4E<<24 | 2<<20 | 8<<16 | 5<<12 | 2<<10; + case AAESMC: return 0x4E<<24 | 2<<20 | 8<<16 | 6<<12 | 2<<10; + case AAESIMC: return 0x4E<<24 | 2<<20 | 8<<16 | 7<<12 | 2<<10; + + case ASHA1C: return 0x5E<<24 | 0<<12; + case ASHA1P: return 0x5E<<24 | 1<<12; + case ASHA1M: return 0x5E<<24 | 2<<12; + case ASHA1SU0: return 0x5E<<24 | 3<<12; + case ASHA256H: return 0x5E<<24 | 4<<12; + case ASHA256H2: return 0x5E<<24 | 5<<12; + case ASHA256SU1: return 0x5E<<24 | 6<<12; + + case ASHA1H: return 0x5E<<24 | 2<<20 | 8<<16 | 0<<12 | 2<<10; + case ASHA1SU1: return 0x5E<<24 | 2<<20 | 8<<16 | 1<<12 | 2<<10; + case ASHA256SU0: return 0x5E<<24 | 2<<20 | 8<<16 | 2<<12 | 2<<10; + + case AFCVTZSD: return FPCVTI(1, 0, 1, 3, 0); + case AFCVTZSDW: return FPCVTI(0, 0, 1, 3, 0); + case AFCVTZSS: return FPCVTI(1, 0, 0, 3, 0); + case AFCVTZSSW: return FPCVTI(0, 0, 0, 3, 0); + + case AFCVTZUD: return FPCVTI(1, 0, 1, 3, 1); + case AFCVTZUDW: return FPCVTI(0, 0, 1, 3, 1); + case AFCVTZUS: return FPCVTI(1, 0, 0, 3, 1); + case AFCVTZUSW: return FPCVTI(0, 0, 0, 3, 1); + + case ASCVTFD: return FPCVTI(1, 0, 1, 0, 2); + case ASCVTFS: return FPCVTI(1, 0, 0, 0, 2); + case ASCVTFWD: return FPCVTI(0, 0, 1, 0, 2); + case ASCVTFWS: return FPCVTI(0, 0, 0, 0, 2); + + case AUCVTFD: return FPCVTI(1, 0, 1, 0, 3); + case AUCVTFS: return FPCVTI(1, 0, 0, 0, 3); + case AUCVTFWD: return FPCVTI(0, 0, 1, 0, 3); + case AUCVTFWS: return FPCVTI(0, 0, 0, 0, 3); + + case AFADDS: return FPOP2S(0, 0, 0, 2); + case AFADDD: return FPOP2S(0, 0, 1, 2); + case AFSUBS: return FPOP2S(0, 0, 0, 3); + case AFSUBD: return FPOP2S(0, 0, 1, 3); + case AFMULS: return FPOP2S(0, 0, 0, 0); + case AFMULD: return FPOP2S(0, 0, 1, 0); + case AFDIVS: return FPOP2S(0, 0, 0, 1); + case AFDIVD: return FPOP2S(0, 0, 1, 1); + case AFMAXS: return FPOP2S(0, 0, 0, 4); + case AFMINS: return FPOP2S(0, 0, 0, 5); + case AFMAXD: return FPOP2S(0, 0, 1, 4); + case AFMIND: return FPOP2S(0, 0, 1, 5); + case AFMAXNMS: return FPOP2S(0, 0, 0, 6); + case AFMAXNMD: return FPOP2S(0, 0, 1, 6); + case AFMINNMS: return FPOP2S(0, 0, 0, 7); + case AFMINNMD: return FPOP2S(0, 0, 1, 7); + case AFNMULS: return FPOP2S(0, 0, 0, 8); + case AFNMULD: return FPOP2S(0, 0, 1, 8); + + case AFMADDS: return FPOP3S(0, 0, 0); + case AFNMADDS: return FPOP3S(0, 0, 1); + case AFMADDD: return FPOP3S(1, 0, 0); + case AFNMADDD: return FPOP3S(1, 0, 1); + case AFMSUBS: return FPOP3S(0, 1, 0); + case AFNMSUBS: return FPOP3S(0, 1, 1); + case AFMSUBD: return FPOP3S(1, 1, 0); + case AFNMSUBD: return FPOP3S(1, 1, 1); + + case AFCMPS: return FPCMP(0, 0, 0, 0, 0); + case AFCMPD: return FPCMP(0, 0, 1, 0, 0); + case AFCMPES: return FPCMP(0, 0, 0, 0, 16); + case AFCMPED: return FPCMP(0, 0, 1, 0, 16); + + case AFCCMPS: return FPCCMP(0, 0, 0, 0); + case AFCCMPD: return FPCCMP(0, 0, 1, 0); + case AFCCMPES: return FPCCMP(0, 0, 0, 1); + case AFCCMPED: return FPCCMP(0, 0, 1, 1); + + case AFCSELS: return 0x1E<<24 | 0<<22 | 1<<21 | 3<<10; + case AFCSELD: return 0x1E<<24 | 1<<22 | 1<<21 | 3<<10; + + case AFMOVS: return FPOP1S(0, 0, 0, 0); + case AFABSS: return FPOP1S(0, 0, 0, 1); + case AFNEGS: return FPOP1S(0, 0, 0, 2); + case AFSQRTS: return FPOP1S(0, 0, 0, 3); + case AFCVTSD: return FPOP1S(0, 0, 0, 5); + case AFCVTSH: return FPOP1S(0, 0, 0, 7); + case AFRINTNS: return FPOP1S(0, 0, 0, 8); + case AFRINTPS: return FPOP1S(0, 0, 0, 9); + case AFRINTMS: return FPOP1S(0, 0, 0, 10); + case AFRINTZS: return FPOP1S(0, 0, 0, 11); + case AFRINTAS: return FPOP1S(0, 0, 0, 12); + case AFRINTXS: return FPOP1S(0, 0, 0, 14); + case AFRINTIS: return FPOP1S(0, 0, 0, 15); + + case AFMOVD: return FPOP1S(0, 0, 1, 0); + case AFABSD: return FPOP1S(0, 0, 1, 1); + case AFNEGD: return FPOP1S(0, 0, 1, 2); + case AFSQRTD: return FPOP1S(0, 0, 1, 3); + case AFCVTDS: return FPOP1S(0, 0, 1, 4); + case AFCVTDH: return FPOP1S(0, 0, 1, 7); + case AFRINTND: return FPOP1S(0, 0, 1, 8); + case AFRINTPD: return FPOP1S(0, 0, 1, 9); + case AFRINTMD: return FPOP1S(0, 0, 1, 10); + case AFRINTZD: return FPOP1S(0, 0, 1, 11); + case AFRINTAD: return FPOP1S(0, 0, 1, 12); + case AFRINTXD: return FPOP1S(0, 0, 1, 14); + case AFRINTID: return FPOP1S(0, 0, 1, 15); + case AFCVTHS: return FPOP1S(0, 0, 3, 4); + case AFCVTHD: return FPOP1S(0, 0, 3, 5); + + } + diag("bad rrr %d %A", a, a); + prasm(curp); + return 0; +} + +/* + * imm -> Rd + * imm op Rn -> Rd + */ +static long +opirr(int a) +{ + switch(a){ + + /* op $addcon, Rn, Rd */ + case AMOV: + case AADD: return S64 | 0<<30 | 0<<29 | 0x11<<24; + case ACMN: + case AADDS: return S64 | 0<<30 | 1<<29 | 0x11<<24; + case AMOVW: + case AADDW: return S32 | 0<<30 | 0<<29 | 0x11<<24; + case ACMNW: + case AADDSW: return S32 | 0<<30 | 1<<29 | 0x11<<24; + case ASUB: return S64 | 1<<30 | 0<<29 | 0x11<<24; + case ACMP: + case ASUBS: return S64 | 1<<30 | 1<<29 | 0x11<<24; + case ASUBW: return S32 | 1<<30 | 0<<29 | 0x11<<24; + case ACMPW: + case ASUBSW: return S32 | 1<<30 | 1<<29 | 0x11<<24; + + /* op $imm(SB), Rd; op label, Rd */ + case AADR: return 0<<31 | 0x10<<24; + case AADRP: return 1<<31 | 0x10<<24; + + /* op $bimm, Rn, Rd */ + case AAND: return S64 | 0<<29 | 0x24<<23; + case AANDW: return S32 | 0<<29 | 0x24<<23 | 0<<22; + case AORR: return S64 | 1<<29 | 0x24<<23; + case AORRW: return S32 | 1<<29 | 0x24<<23 | 0<<22; + case AEOR: return S64 | 2<<29 | 0x24<<23; + case AEORW: return S32 | 2<<29 | 0x24<<23 | 0<<22; + case AANDS: return S64 | 3<<29 | 0x24<<23; + case AANDSW: return S32 | 3<<29 | 0x24<<23 | 0<<22; + + case AASR: return S64 | 0<<29 | 0x26<<23; /* alias of SBFM */ + case AASRW: return S32 | 0<<29 | 0x26<<23 | 0<<22; + + /* op $width, $lsb, Rn, Rd */ + case ABFI: return S64 | 2<<29 | 0x26<<23 | 1<<22; /* alias of BFM */ + case ABFIW: return S32 | 2<<29 | 0x26<<23 | 0<<22; + + /* op $imms, $immr, Rn, Rd */ + case ABFM: return S64 | 1<<29 | 0x26<<23 | 1<<22; + case ABFMW: return S32 | 1<<29 | 0x26<<23 | 0<<22; + case ASBFM: return S64 | 0<<29 | 0x26<<23 | 1<<22; + case ASBFMW: return S32 | 0<<29 | 0x26<<23 | 0<<22; + case AUBFM: return S64 | 2<<29 | 0x26<<23 | 1<<22; + case AUBFMW: return S32 | 2<<29 | 0x26<<23 | 0<<22; + + case ABFXIL: return S64 | 1<<29 | 0x26<<23 | 1<<22; /* alias of BFM */ + case ABFXILW: return S32 | 1<<29 | 0x26<<23 | 0<<22; + + case AEXTR: return S64 | 0<<29 | 0x27<<23 | 1<<22 | 0<<21; + case AEXTRW: return S32 | 0<<29 | 0x27<<23 | 0<<22 | 0<<21; + + case ACBNZ: return S64 | 0x1A<<25 | 1<<24; + case ACBNZW: return S32 | 0x1A<<25 | 1<<24; + case ACBZ: return S64 | 0x1A<<25 | 0<<24; + case ACBZW: return S32 | 0x1A<<25 | 0<<24; + + case ACCMN: return S64 | 0<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4; /* imm5<<16 | cond<<12 | nzcv<<0 */ + case ACCMNW: return S32 | 0<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4; + case ACCMP: return S64 | 1<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4; /* imm5<<16 | cond<<12 | nzcv<<0 */ + case ACCMPW: return S32 | 1<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4; + + case AMOVK: return S64 | 3<<29 | 0x25<<23; + case AMOVKW: return S32 | 3<<29 | 0x25<<23; + + case AMOVN: return S64 | 0<<29 | 0x25<<23; + case AMOVNW: return S32 | 0<<29 | 0x25<<23; + case AMOVZ: return S64 | 2<<29 | 0x25<<23; + case AMOVZW: return S32 | 2<<29 | 0x25<<23; + + case AMSR: return SYSOP(0,0,0,4,0,0,0x1F); /* MSR (immediate) */ + + case AAT: + case ADC: + case AIC: + case ATLBI: + case ASYS: return SYSOP(0,1,0,0,0,0,0); + case ASYSL: return SYSOP(1,1,0,0,0,0,0); + + case ATBZ: return 0x36<<24; + case ATBNZ: return 0x37<<24; + + case ADSB: return SYSOP(0,0,3,3,0,4,0x1F); + case ADMB: return SYSOP(0,0,3,3,0,5,0x1F); + case AISB: return SYSOP(0,0,3,3,0,6,0x1F); + case AHINT: return SYSOP(0,0,3,2,0,0,0x1F); + + } + diag("bad irr %A", a); + prasm(curp); + return 0; +} + +/* + * bit operations + */ +#define OPBIT(x) (1<<30 | 0<<29 | 0xD6<<21 | 0<<16 | (x)<<10) + +static long +opbit(int a) +{ + switch(a){ + case ACLS: return S64 | OPBIT(5); + case ACLSW: return S32 | OPBIT(5); + case ACLZ: return S64 | OPBIT(4); + case ACLZW: return S32 | OPBIT(4); + case ARBIT: return S64 | OPBIT(0); + case ARBITW: return S32 | OPBIT(0); + case AREV: return S64 | OPBIT(3); + case AREVW: return S32 | OPBIT(2); + case AREV16: return S64 | OPBIT(1); + case AREV16W: return S32 | OPBIT(1); + case AREV32: return S64 | OPBIT(2); + default: + diag("bad bit op\n%P", curp); + return 0; + } +} + +/* + * add/subtract extended register + */ +static long +opxrrr(int a) +{ + switch(a) { + case AADD: return S64 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_64; + case AADDW: return S32 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_32; + case ACMN: + case AADDS: return S64 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_64; + case ACMNW: + case AADDSW: return S32 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_32; + + case ASUB: return S64 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_64; + case ASUBW: return S32 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_32; + case ACMP: + case ASUBS: return S64 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_64; + case ACMPW: + case ASUBSW: return S32 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | LSL0_32; + + } + diag("bad opxrrr %A\n%P", a, curp); + return 0; +} + +static long +opimm(int a) +{ + switch(a){ + case ASVC: return 0xD4<<24 | 0<<21 | 1; /* imm16<<5 */ + case AHVC: return 0xD4<<24 | 0<<21 | 2; + case ASMC: return 0xD4<<24 | 0<<21 | 3; + case ABRK: return 0xD4<<24 | 1<<21 | 0; + case AHLT: return 0xD4<<24 | 2<<21 | 0; + case ADCPS1: return 0xD4<<24 | 5<<21 | 1; + case ADCPS2: return 0xD4<<24 | 5<<21 | 2; + case ADCPS3: return 0xD4<<24 | 5<<21 | 3; + + case ACLREX: return SYSOP(0,0,3,3,0,2,0x1F); + } + diag("bad imm %A", a); + prasm(curp); + return 0; +} + +static vlong +brdist(Prog *p, int preshift, int flen, int shift) +{ + vlong v, t; + Sym *s; + + v = 0; + if(p->cond == UP) { + s = p->to.sym; + if(s->type != SUNDEF) + diag("bad branch sym type"); + v = (uvlong)s->value >> (Roffset-2); + dynreloc(s, p->pc, 0); /* TO DO */ + } + else if(p->cond != P) + v = (p->cond->pc>>preshift) - (pc>>preshift); + if((v & ((1<>= shift; + t = (vlong)1 << (flen-1); + if(v < -t || v >= t) + diag("branch too far\n%P", p); + return v & ((t<<1)-1); +} + +/* + * pc-relative branches + */ +static long +opbra(int a) +{ + switch(a) { + case ABEQ: return OPBcc(0x0); + case ABNE: return OPBcc(0x1); + case ABCS: return OPBcc(0x2); + case ABHS: return OPBcc(0x2); + case ABCC: return OPBcc(0x3); + case ABLO: return OPBcc(0x3); + case ABMI: return OPBcc(0x4); + case ABPL: return OPBcc(0x5); + case ABVS: return OPBcc(0x6); + case ABVC: return OPBcc(0x7); + case ABHI: return OPBcc(0x8); + case ABLS: return OPBcc(0x9); + case ABGE: return OPBcc(0xa); + case ABLT: return OPBcc(0xb); + case ABGT: return OPBcc(0xc); + case ABLE: return OPBcc(0xd); /* imm19<<5 | cond */ + case AB: return 0<<31 | 5<<26; /* imm26 */ + case ABL: return 1<<31 | 5<<26; + } + diag("bad bra %A", a); + prasm(curp); + return 0; +} + +static long +opbrr(int a) +{ + switch(a){ + case ABL: return OPBLR(1); /* BLR */ + case AB: return OPBLR(0); /* BR */ + case ARET: return OPBLR(2); /* RET */ + } + diag("bad brr %A", a); + prasm(curp); + return 0; +} + +static long +op0(int a) +{ + switch(a){ + case ADRPS: return 0x6B<<25 | 5<<21 | 0x1F<<16 | 0x1F<<5; + case AERET: return 0x6B<<25 | 4<<21 | 0x1F<<16 | 0<<10 | 0x1F<<5; + case ANOP: return SYSHINT(0); + case AYIELD: return SYSHINT(1); + case AWFE: return SYSHINT(2); + case AWFI: return SYSHINT(3); + case ASEV: return SYSHINT(4); + case ASEVL: return SYSHINT(5); + } + diag("bad op0 %A", a); + prasm(curp); + return 0; +} + +/* + * register offset + */ +static long +opload(int a) +{ + switch(a){ + case ALDAR: return LDSTX(3,1,1,0,1) | 0x1F<<10; + case ALDARW: return LDSTX(2,1,1,0,1) | 0x1F<<10; + case ALDARH: return LDSTX(1,1,1,0,1) | 0x1F<<10; + case ALDARB: return LDSTX(0,1,1,0,1) | 0x1F<<10; + + case ALDAXP: return LDSTX(3,0,1,1,1); + case ALDAXPW: return LDSTX(2,0,1,1,1); + + case ALDAXR: return LDSTX(3,0,1,0,1) | 0x1F<<10; + case ALDAXRW: return LDSTX(2,0,1,0,1) | 0x1F<<10; + case ALDAXRH: return LDSTX(1,0,1,0,1) | 0x1F<<10; + case ALDAXRB: return LDSTX(0,0,1,0,1) | 0x1F<<10; + + case ALDXR: return LDSTX(3,0,1,0,0) | 0x1F<<10; + case ALDXRW: return LDSTX(2,0,1,0,0) | 0x1F<<10; + case ALDXRH: return LDSTX(1,0,1,0,0) | 0x1F<<10; + case ALDXRB: return LDSTX(0,0,1,0,0) | 0x1F<<10; + + case ALDXP: return LDSTX(3,0,1,1,0); + case ALDXPW: return LDSTX(2,0,1,1,0); + + case AMOVNP: return S64 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + case AMOVNPW: return S32 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + } + diag("bad opload %A\n%P", a, curp); + return 0; +} + +static long +opstore(int a) +{ + switch(a){ + case ASTLR: return LDSTX(3,1,0,0,1) | 0x1F<<10; + case ASTLRW: return LDSTX(2,1,0,0,1) | 0x1F<<10; + case ASTLRH: return LDSTX(1,1,0,0,1) | 0x1F<<10; + case ASTLRB: return LDSTX(0,1,0,0,1) | 0x1F<<10; + + case ASTLXP: return LDSTX(3,0,0,1,1); + case ASTLXPW: return LDSTX(2,0,0,1,1); + + case ASTLXR: return LDSTX(3,0,0,0,1) | 0x1F<<10; + case ASTLXRW: return LDSTX(2,0,0,0,1) | 0x1F<<10; + case ASTLXRH: return LDSTX(1,0,0,0,1) | 0x1F<<10; + case ASTLXRB: return LDSTX(0,0,0,0,1) | 0x1F<<10; + + case ASTXR: return LDSTX(3,0,0,0,0) | 0x1F<<10; + case ASTXRW: return LDSTX(2,0,0,0,0) | 0x1F<<10; + case ASTXRH: return LDSTX(1,0,0,0,0) | 0x1F<<10; + case ASTXRB: return LDSTX(0,0,0,0,0) | 0x1F<<10; + + case ASTXP: return LDSTX(3,0,0,1,0); + case ASTXPW: return LDSTX(2,0,0,1,0); + + case AMOVNP: return S64 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + case AMOVNPW: return S32 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + } + diag("bad opstore %A\n%P", a, curp); + return 0; +} + +/* + * load/store register (unsigned immediate) C3.3.13 + * these produce 64-bit values (when there's an option) + */ + +static long +olsr12u(long o, long v, int b, int r) +{ + if(v < 0 || v >= (1<<12)) + diag("offset out of range: %ld\n%P", v, curp); + o |= (v&0xFFF)<<10; + o |= b << 5; + o |= r; + return o; +} + +static long +opldr12(int a) +{ + switch(a){ + case AMOV: return LDSTR12U(3, 0, 1); /* imm12<<10 | Rn<<5 | Rt */ + case AMOVW: return LDSTR12U(2, 0, 2); + case AMOVWU: return LDSTR12U(2, 0, 1); + case AMOVH: return LDSTR12U(1, 0, 2); + case AMOVHU: return LDSTR12U(1, 0, 1); + case AMOVB: return LDSTR12U(0, 0, 2); + case AMOVBU: return LDSTR12U(0, 0, 1); + case AFMOVS: return LDSTR12U(2, 1, 1); + case AFMOVD: return LDSTR12U(3, 1, 1); + } + diag("bad opldr12 %A\n%P", a, curp); + return 0; +} + +static long +opstr12(int a) +{ + return LD2STR(opldr12(a)); +} + +/* + * load/store register (unscaled immediate) C3.3.12 + */ + +static long +olsr9s(long o, long v, int b, int r) +{ + if(v < -256 || v > 255) + diag("offset out of range: %ld\n%P", v, curp); + o |= (v&0x1FF)<<12; + o |= b << 5; + o |= r; + return o; +} + +static long +opldr9(int a) +{ + switch(a){ + case AMOV: return LDSTR9S(3, 0, 1); /* simm9<<12 | Rn<<5 | Rt */ + case AMOVW: return LDSTR9S(2, 0, 2); + case AMOVWU: return LDSTR9S(2, 0, 1); + case AMOVH: return LDSTR9S(1, 0, 2); + case AMOVHU: return LDSTR9S(1, 0, 1); + case AMOVB: return LDSTR9S(0, 0, 2); + case AMOVBU: return LDSTR9S(0, 0, 1); + case AFMOVS: return LDSTR9S(2, 1, 1); + case AFMOVD: return LDSTR9S(3, 1, 1); + } + diag("bad opldr9 %A\n%P", a, curp); + return 0; +} + +static long +opstr9(int a) +{ + return LD2STR(opldr9(a)); +} + +static long +opldrpp(int a) +{ + switch(a){ + case AMOV: return 3<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22; /* simm9<<12 | Rn<<5 | Rt */ + case AMOVW: return 2<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22; + case AMOVWU: return 2<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22; + case AMOVH: return 1<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22; + case AMOVHU: return 1<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22; + case AMOVB: return 0<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22; + case AMOVBU: return 0<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22; + case AFMOVS: return 2<<30 | 7<<27 | 1<<26 | 0<<24 | 1<<22; + case AFMOVD: return 3<<30 | 7<<27 | 1<<26 | 0<<24 | 1<<22; + case AMOVPW: return 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; /* simm7<<15 | Rt2<<10 | Rn<<5 | Rt */ + case AMOVPSW: return 1<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + case AMOVP: return 2<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22; + case AMOVPS: return 0<<30 | 5<<27 | 1<<26 | 0<<23 | 1<<22; + case AMOVPD: return 1<<30 | 5<<27 | 1<<26 | 0<<23 | 1<<22; + } + diag("bad opldr %A\n%P", a, curp); + return 0; +} + +/* + * load/store register (extended register) + */ +static long +olsxrr(int a, int b, int c, int d) +{ + return opldrpp(a) | 1<<21 | b<<16 | 2<<10 | c<<5 | d; +} + +static long +oaddi(long o1, long v, int r, int rt) +{ + if((v & 0xFFF000) != 0){ + v >>= 12; + o1 |= 1<<22; + } + o1 |= ((v & 0xFFF) << 10) | (r<<5) | rt; + return o1; +} + +/* + * load a literal value into dr + */ +static long +omovlit(int as, Prog *p, Adr *a, int dr) +{ + long v, o1; + int w, fp; + + if(p->cond == nil){ /* not in literal pool */ + aclass(a); + /* TO DO: could be clever, and use general constant builder */ + o1 = opirr(AADD); + v = instoffset; + if(v != 0 && (v & 0xFFF) == 0){ + v >>= 12; + o1 |= 1<<22; /* shift, by 12 */ + } + if(v < 0 || v > 0xFFF) + diag("literal out of range\n%P", p); + o1 |= ((v& 0xFFF) << 10) | (REGZERO<<5) | dr; + }else{ + fp = 0; + w = 0; /* default: 32 bit, unsigned */ + switch(as){ + case AFMOVS: + fp = 1; + break; + case AFMOVD: + fp = 1; + w = 1; /* 64 bit simd&fp */ + break; + case AMOV: + if(p->cond->as == ADWORD) + w = 1; /* 64 bit */ + else if(p->cond->to.offset < 0) + w = 2; /* sign extend */ + break; + case AMOVB: + case AMOVH: + case AMOVW: + w = 2; /* 32 bit, sign-extended to 64 */ + break; + } + v = brdist(p, 0, 19, 2); + o1 = (w<<30)|(fp<<26)|(3<<27); + o1 |= (v&0x7FFFF)<<5; + o1 |= dr; + } + return o1; +} + +static long +opbfm(int a, int r, int s, int rf, int rt) +{ + long o, c; + + o = opirr(a); + if((o & (1<<31)) == 0) + c = 32; + else + c = 64; + if(r < 0 || r >= c) + diag("illegal bit number\n%P", curp); + o |= (r&0x3F)<<16; + if(s < 0 || s >= c) + diag("illegal bit number\n%P", curp); + o |= (s&0x3F)<<10; + o |= (rf<<5) | rt; + return o; +} + +static long +opextr(int a, long v, int rn, int rm, int rt) +{ + long o, c; + + o = opirr(a); + c = (o & (1<<31)) != 0? 63: 31; + if(v < 0 || v > c) + diag("illegal bit number\n%P", curp); + o |= v<<10; + o |= rn << 5; + o |= rm << 16; + o |= rt; + return o; +} + +/* + * size in log2(bytes) + */ +static int +movesize(int a) +{ + switch(a){ + case AMOV: + return 3; + case AMOVW: + case AMOVWU: + return 2; + case AMOVH: + case AMOVHU: + return 1; + case AMOVB: + case AMOVBU: + return 0; + case AFMOVS: + return 2; + case AFMOVD: + return 3; + default: + return -1; + } +} + +/* + * SIMD + */ --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/bits.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,5359 @@ +#include "l.h" + +static Mask bitmasks[] = { + 1, 64, 0, 0x00000000000001LL, + 1, 64, 63, 0x00000000000002LL, + 2, 64, 0, 0x00000000000003LL, + 1, 64, 62, 0x00000000000004LL, + 2, 64, 63, 0x00000000000006LL, + 3, 64, 0, 0x00000000000007LL, + 1, 64, 61, 0x00000000000008LL, + 2, 64, 62, 0x0000000000000cLL, + 3, 64, 63, 0x0000000000000eLL, + 4, 64, 0, 0x0000000000000fLL, + 1, 64, 60, 0x00000000000010LL, + 2, 64, 61, 0x00000000000018LL, + 3, 64, 62, 0x0000000000001cLL, + 4, 64, 63, 0x0000000000001eLL, + 5, 64, 0, 0x0000000000001fLL, + 1, 64, 59, 0x00000000000020LL, + 2, 64, 60, 0x00000000000030LL, + 3, 64, 61, 0x00000000000038LL, + 4, 64, 62, 0x0000000000003cLL, + 5, 64, 63, 0x0000000000003eLL, + 6, 64, 0, 0x0000000000003fLL, + 1, 64, 58, 0x00000000000040LL, + 2, 64, 59, 0x00000000000060LL, + 3, 64, 60, 0x00000000000070LL, + 4, 64, 61, 0x00000000000078LL, + 5, 64, 62, 0x0000000000007cLL, + 6, 64, 63, 0x0000000000007eLL, + 7, 64, 0, 0x0000000000007fLL, + 1, 64, 57, 0x00000000000080LL, + 2, 64, 58, 0x000000000000c0LL, + 3, 64, 59, 0x000000000000e0LL, + 4, 64, 60, 0x000000000000f0LL, + 5, 64, 61, 0x000000000000f8LL, + 6, 64, 62, 0x000000000000fcLL, + 7, 64, 63, 0x000000000000feLL, + 8, 64, 0, 0x000000000000ffLL, + 1, 64, 56, 0x00000000000100LL, + 2, 64, 57, 0x00000000000180LL, + 3, 64, 58, 0x000000000001c0LL, + 4, 64, 59, 0x000000000001e0LL, + 5, 64, 60, 0x000000000001f0LL, + 6, 64, 61, 0x000000000001f8LL, + 7, 64, 62, 0x000000000001fcLL, + 8, 64, 63, 0x000000000001feLL, + 9, 64, 0, 0x000000000001ffLL, + 1, 64, 55, 0x00000000000200LL, + 2, 64, 56, 0x00000000000300LL, + 3, 64, 57, 0x00000000000380LL, + 4, 64, 58, 0x000000000003c0LL, + 5, 64, 59, 0x000000000003e0LL, + 6, 64, 60, 0x000000000003f0LL, + 7, 64, 61, 0x000000000003f8LL, + 8, 64, 62, 0x000000000003fcLL, + 9, 64, 63, 0x000000000003feLL, + 10, 64, 0, 0x000000000003ffLL, + 1, 64, 54, 0x00000000000400LL, + 2, 64, 55, 0x00000000000600LL, + 3, 64, 56, 0x00000000000700LL, + 4, 64, 57, 0x00000000000780LL, + 5, 64, 58, 0x000000000007c0LL, + 6, 64, 59, 0x000000000007e0LL, + 7, 64, 60, 0x000000000007f0LL, + 8, 64, 61, 0x000000000007f8LL, + 9, 64, 62, 0x000000000007fcLL, + 10, 64, 63, 0x000000000007feLL, + 11, 64, 0, 0x000000000007ffLL, + 1, 64, 53, 0x00000000000800LL, + 2, 64, 54, 0x00000000000c00LL, + 3, 64, 55, 0x00000000000e00LL, + 4, 64, 56, 0x00000000000f00LL, + 5, 64, 57, 0x00000000000f80LL, + 6, 64, 58, 0x00000000000fc0LL, + 7, 64, 59, 0x00000000000fe0LL, + 8, 64, 60, 0x00000000000ff0LL, + 9, 64, 61, 0x00000000000ff8LL, + 10, 64, 62, 0x00000000000ffcLL, + 11, 64, 63, 0x00000000000ffeLL, + 12, 64, 0, 0x00000000000fffLL, + 1, 64, 52, 0x00000000001000LL, + 2, 64, 53, 0x00000000001800LL, + 3, 64, 54, 0x00000000001c00LL, + 4, 64, 55, 0x00000000001e00LL, + 5, 64, 56, 0x00000000001f00LL, + 6, 64, 57, 0x00000000001f80LL, + 7, 64, 58, 0x00000000001fc0LL, + 8, 64, 59, 0x00000000001fe0LL, + 9, 64, 60, 0x00000000001ff0LL, + 10, 64, 61, 0x00000000001ff8LL, + 11, 64, 62, 0x00000000001ffcLL, + 12, 64, 63, 0x00000000001ffeLL, + 13, 64, 0, 0x00000000001fffLL, + 1, 64, 51, 0x00000000002000LL, + 2, 64, 52, 0x00000000003000LL, + 3, 64, 53, 0x00000000003800LL, + 4, 64, 54, 0x00000000003c00LL, + 5, 64, 55, 0x00000000003e00LL, + 6, 64, 56, 0x00000000003f00LL, + 7, 64, 57, 0x00000000003f80LL, + 8, 64, 58, 0x00000000003fc0LL, + 9, 64, 59, 0x00000000003fe0LL, + 10, 64, 60, 0x00000000003ff0LL, + 11, 64, 61, 0x00000000003ff8LL, + 12, 64, 62, 0x00000000003ffcLL, + 13, 64, 63, 0x00000000003ffeLL, + 14, 64, 0, 0x00000000003fffLL, + 1, 64, 50, 0x00000000004000LL, + 2, 64, 51, 0x00000000006000LL, + 3, 64, 52, 0x00000000007000LL, + 4, 64, 53, 0x00000000007800LL, + 5, 64, 54, 0x00000000007c00LL, + 6, 64, 55, 0x00000000007e00LL, + 7, 64, 56, 0x00000000007f00LL, + 8, 64, 57, 0x00000000007f80LL, + 9, 64, 58, 0x00000000007fc0LL, + 10, 64, 59, 0x00000000007fe0LL, + 11, 64, 60, 0x00000000007ff0LL, + 12, 64, 61, 0x00000000007ff8LL, + 13, 64, 62, 0x00000000007ffcLL, + 14, 64, 63, 0x00000000007ffeLL, + 15, 64, 0, 0x00000000007fffLL, + 1, 64, 49, 0x00000000008000LL, + 2, 64, 50, 0x0000000000c000LL, + 3, 64, 51, 0x0000000000e000LL, + 4, 64, 52, 0x0000000000f000LL, + 5, 64, 53, 0x0000000000f800LL, + 6, 64, 54, 0x0000000000fc00LL, + 7, 64, 55, 0x0000000000fe00LL, + 8, 64, 56, 0x0000000000ff00LL, + 9, 64, 57, 0x0000000000ff80LL, + 10, 64, 58, 0x0000000000ffc0LL, + 11, 64, 59, 0x0000000000ffe0LL, + 12, 64, 60, 0x0000000000fff0LL, + 13, 64, 61, 0x0000000000fff8LL, + 14, 64, 62, 0x0000000000fffcLL, + 15, 64, 63, 0x0000000000fffeLL, + 16, 64, 0, 0x0000000000ffffLL, + 1, 64, 48, 0x00000000010000LL, + 2, 64, 49, 0x00000000018000LL, + 3, 64, 50, 0x0000000001c000LL, + 4, 64, 51, 0x0000000001e000LL, + 5, 64, 52, 0x0000000001f000LL, + 6, 64, 53, 0x0000000001f800LL, + 7, 64, 54, 0x0000000001fc00LL, + 8, 64, 55, 0x0000000001fe00LL, + 9, 64, 56, 0x0000000001ff00LL, + 10, 64, 57, 0x0000000001ff80LL, + 11, 64, 58, 0x0000000001ffc0LL, + 12, 64, 59, 0x0000000001ffe0LL, + 13, 64, 60, 0x0000000001fff0LL, + 14, 64, 61, 0x0000000001fff8LL, + 15, 64, 62, 0x0000000001fffcLL, + 16, 64, 63, 0x0000000001fffeLL, + 17, 64, 0, 0x0000000001ffffLL, + 1, 64, 47, 0x00000000020000LL, + 2, 64, 48, 0x00000000030000LL, + 3, 64, 49, 0x00000000038000LL, + 4, 64, 50, 0x0000000003c000LL, + 5, 64, 51, 0x0000000003e000LL, + 6, 64, 52, 0x0000000003f000LL, + 7, 64, 53, 0x0000000003f800LL, + 8, 64, 54, 0x0000000003fc00LL, + 9, 64, 55, 0x0000000003fe00LL, + 10, 64, 56, 0x0000000003ff00LL, + 11, 64, 57, 0x0000000003ff80LL, + 12, 64, 58, 0x0000000003ffc0LL, + 13, 64, 59, 0x0000000003ffe0LL, + 14, 64, 60, 0x0000000003fff0LL, + 15, 64, 61, 0x0000000003fff8LL, + 16, 64, 62, 0x0000000003fffcLL, + 17, 64, 63, 0x0000000003fffeLL, + 18, 64, 0, 0x0000000003ffffLL, + 1, 64, 46, 0x00000000040000LL, + 2, 64, 47, 0x00000000060000LL, + 3, 64, 48, 0x00000000070000LL, + 4, 64, 49, 0x00000000078000LL, + 5, 64, 50, 0x0000000007c000LL, + 6, 64, 51, 0x0000000007e000LL, + 7, 64, 52, 0x0000000007f000LL, + 8, 64, 53, 0x0000000007f800LL, + 9, 64, 54, 0x0000000007fc00LL, + 10, 64, 55, 0x0000000007fe00LL, + 11, 64, 56, 0x0000000007ff00LL, + 12, 64, 57, 0x0000000007ff80LL, + 13, 64, 58, 0x0000000007ffc0LL, + 14, 64, 59, 0x0000000007ffe0LL, + 15, 64, 60, 0x0000000007fff0LL, + 16, 64, 61, 0x0000000007fff8LL, + 17, 64, 62, 0x0000000007fffcLL, + 18, 64, 63, 0x0000000007fffeLL, + 19, 64, 0, 0x0000000007ffffLL, + 1, 64, 45, 0x00000000080000LL, + 2, 64, 46, 0x000000000c0000LL, + 3, 64, 47, 0x000000000e0000LL, + 4, 64, 48, 0x000000000f0000LL, + 5, 64, 49, 0x000000000f8000LL, + 6, 64, 50, 0x000000000fc000LL, + 7, 64, 51, 0x000000000fe000LL, + 8, 64, 52, 0x000000000ff000LL, + 9, 64, 53, 0x000000000ff800LL, + 10, 64, 54, 0x000000000ffc00LL, + 11, 64, 55, 0x000000000ffe00LL, + 12, 64, 56, 0x000000000fff00LL, + 13, 64, 57, 0x000000000fff80LL, + 14, 64, 58, 0x000000000fffc0LL, + 15, 64, 59, 0x000000000fffe0LL, + 16, 64, 60, 0x000000000ffff0LL, + 17, 64, 61, 0x000000000ffff8LL, + 18, 64, 62, 0x000000000ffffcLL, + 19, 64, 63, 0x000000000ffffeLL, + 20, 64, 0, 0x000000000fffffLL, + 1, 64, 44, 0x00000000100000LL, + 2, 64, 45, 0x00000000180000LL, + 3, 64, 46, 0x000000001c0000LL, + 4, 64, 47, 0x000000001e0000LL, + 5, 64, 48, 0x000000001f0000LL, + 6, 64, 49, 0x000000001f8000LL, + 7, 64, 50, 0x000000001fc000LL, + 8, 64, 51, 0x000000001fe000LL, + 9, 64, 52, 0x000000001ff000LL, + 10, 64, 53, 0x000000001ff800LL, + 11, 64, 54, 0x000000001ffc00LL, + 12, 64, 55, 0x000000001ffe00LL, + 13, 64, 56, 0x000000001fff00LL, + 14, 64, 57, 0x000000001fff80LL, + 15, 64, 58, 0x000000001fffc0LL, + 16, 64, 59, 0x000000001fffe0LL, + 17, 64, 60, 0x000000001ffff0LL, + 18, 64, 61, 0x000000001ffff8LL, + 19, 64, 62, 0x000000001ffffcLL, + 20, 64, 63, 0x000000001ffffeLL, + 21, 64, 0, 0x000000001fffffLL, + 1, 64, 43, 0x00000000200000LL, + 2, 64, 44, 0x00000000300000LL, + 3, 64, 45, 0x00000000380000LL, + 4, 64, 46, 0x000000003c0000LL, + 5, 64, 47, 0x000000003e0000LL, + 6, 64, 48, 0x000000003f0000LL, + 7, 64, 49, 0x000000003f8000LL, + 8, 64, 50, 0x000000003fc000LL, + 9, 64, 51, 0x000000003fe000LL, + 10, 64, 52, 0x000000003ff000LL, + 11, 64, 53, 0x000000003ff800LL, + 12, 64, 54, 0x000000003ffc00LL, + 13, 64, 55, 0x000000003ffe00LL, + 14, 64, 56, 0x000000003fff00LL, + 15, 64, 57, 0x000000003fff80LL, + 16, 64, 58, 0x000000003fffc0LL, + 17, 64, 59, 0x000000003fffe0LL, + 18, 64, 60, 0x000000003ffff0LL, + 19, 64, 61, 0x000000003ffff8LL, + 20, 64, 62, 0x000000003ffffcLL, + 21, 64, 63, 0x000000003ffffeLL, + 22, 64, 0, 0x000000003fffffLL, + 1, 64, 42, 0x00000000400000LL, + 2, 64, 43, 0x00000000600000LL, + 3, 64, 44, 0x00000000700000LL, + 4, 64, 45, 0x00000000780000LL, + 5, 64, 46, 0x000000007c0000LL, + 6, 64, 47, 0x000000007e0000LL, + 7, 64, 48, 0x000000007f0000LL, + 8, 64, 49, 0x000000007f8000LL, + 9, 64, 50, 0x000000007fc000LL, + 10, 64, 51, 0x000000007fe000LL, + 11, 64, 52, 0x000000007ff000LL, + 12, 64, 53, 0x000000007ff800LL, + 13, 64, 54, 0x000000007ffc00LL, + 14, 64, 55, 0x000000007ffe00LL, + 15, 64, 56, 0x000000007fff00LL, + 16, 64, 57, 0x000000007fff80LL, + 17, 64, 58, 0x000000007fffc0LL, + 18, 64, 59, 0x000000007fffe0LL, + 19, 64, 60, 0x000000007ffff0LL, + 20, 64, 61, 0x000000007ffff8LL, + 21, 64, 62, 0x000000007ffffcLL, + 22, 64, 63, 0x000000007ffffeLL, + 23, 64, 0, 0x000000007fffffLL, + 1, 64, 41, 0x00000000800000LL, + 2, 64, 42, 0x00000000c00000LL, + 3, 64, 43, 0x00000000e00000LL, + 4, 64, 44, 0x00000000f00000LL, + 5, 64, 45, 0x00000000f80000LL, + 6, 64, 46, 0x00000000fc0000LL, + 7, 64, 47, 0x00000000fe0000LL, + 8, 64, 48, 0x00000000ff0000LL, + 9, 64, 49, 0x00000000ff8000LL, + 10, 64, 50, 0x00000000ffc000LL, + 11, 64, 51, 0x00000000ffe000LL, + 12, 64, 52, 0x00000000fff000LL, + 13, 64, 53, 0x00000000fff800LL, + 14, 64, 54, 0x00000000fffc00LL, + 15, 64, 55, 0x00000000fffe00LL, + 16, 64, 56, 0x00000000ffff00LL, + 17, 64, 57, 0x00000000ffff80LL, + 18, 64, 58, 0x00000000ffffc0LL, + 19, 64, 59, 0x00000000ffffe0LL, + 20, 64, 60, 0x00000000fffff0LL, + 21, 64, 61, 0x00000000fffff8LL, + 22, 64, 62, 0x00000000fffffcLL, + 23, 64, 63, 0x00000000fffffeLL, + 24, 64, 0, 0x00000000ffffffLL, + 1, 64, 40, 0x00000001000000LL, + 2, 64, 41, 0x00000001800000LL, + 3, 64, 42, 0x00000001c00000LL, + 4, 64, 43, 0x00000001e00000LL, + 5, 64, 44, 0x00000001f00000LL, + 6, 64, 45, 0x00000001f80000LL, + 7, 64, 46, 0x00000001fc0000LL, + 8, 64, 47, 0x00000001fe0000LL, + 9, 64, 48, 0x00000001ff0000LL, + 10, 64, 49, 0x00000001ff8000LL, + 11, 64, 50, 0x00000001ffc000LL, + 12, 64, 51, 0x00000001ffe000LL, + 13, 64, 52, 0x00000001fff000LL, + 14, 64, 53, 0x00000001fff800LL, + 15, 64, 54, 0x00000001fffc00LL, + 16, 64, 55, 0x00000001fffe00LL, + 17, 64, 56, 0x00000001ffff00LL, + 18, 64, 57, 0x00000001ffff80LL, + 19, 64, 58, 0x00000001ffffc0LL, + 20, 64, 59, 0x00000001ffffe0LL, + 21, 64, 60, 0x00000001fffff0LL, + 22, 64, 61, 0x00000001fffff8LL, + 23, 64, 62, 0x00000001fffffcLL, + 24, 64, 63, 0x00000001fffffeLL, + 25, 64, 0, 0x00000001ffffffLL, + 1, 64, 39, 0x00000002000000LL, + 2, 64, 40, 0x00000003000000LL, + 3, 64, 41, 0x00000003800000LL, + 4, 64, 42, 0x00000003c00000LL, + 5, 64, 43, 0x00000003e00000LL, + 6, 64, 44, 0x00000003f00000LL, + 7, 64, 45, 0x00000003f80000LL, + 8, 64, 46, 0x00000003fc0000LL, + 9, 64, 47, 0x00000003fe0000LL, + 10, 64, 48, 0x00000003ff0000LL, + 11, 64, 49, 0x00000003ff8000LL, + 12, 64, 50, 0x00000003ffc000LL, + 13, 64, 51, 0x00000003ffe000LL, + 14, 64, 52, 0x00000003fff000LL, + 15, 64, 53, 0x00000003fff800LL, + 16, 64, 54, 0x00000003fffc00LL, + 17, 64, 55, 0x00000003fffe00LL, + 18, 64, 56, 0x00000003ffff00LL, + 19, 64, 57, 0x00000003ffff80LL, + 20, 64, 58, 0x00000003ffffc0LL, + 21, 64, 59, 0x00000003ffffe0LL, + 22, 64, 60, 0x00000003fffff0LL, + 23, 64, 61, 0x00000003fffff8LL, + 24, 64, 62, 0x00000003fffffcLL, + 25, 64, 63, 0x00000003fffffeLL, + 26, 64, 0, 0x00000003ffffffLL, + 1, 64, 38, 0x00000004000000LL, + 2, 64, 39, 0x00000006000000LL, + 3, 64, 40, 0x00000007000000LL, + 4, 64, 41, 0x00000007800000LL, + 5, 64, 42, 0x00000007c00000LL, + 6, 64, 43, 0x00000007e00000LL, + 7, 64, 44, 0x00000007f00000LL, + 8, 64, 45, 0x00000007f80000LL, + 9, 64, 46, 0x00000007fc0000LL, + 10, 64, 47, 0x00000007fe0000LL, + 11, 64, 48, 0x00000007ff0000LL, + 12, 64, 49, 0x00000007ff8000LL, + 13, 64, 50, 0x00000007ffc000LL, + 14, 64, 51, 0x00000007ffe000LL, + 15, 64, 52, 0x00000007fff000LL, + 16, 64, 53, 0x00000007fff800LL, + 17, 64, 54, 0x00000007fffc00LL, + 18, 64, 55, 0x00000007fffe00LL, + 19, 64, 56, 0x00000007ffff00LL, + 20, 64, 57, 0x00000007ffff80LL, + 21, 64, 58, 0x00000007ffffc0LL, + 22, 64, 59, 0x00000007ffffe0LL, + 23, 64, 60, 0x00000007fffff0LL, + 24, 64, 61, 0x00000007fffff8LL, + 25, 64, 62, 0x00000007fffffcLL, + 26, 64, 63, 0x00000007fffffeLL, + 27, 64, 0, 0x00000007ffffffLL, + 1, 64, 37, 0x00000008000000LL, + 2, 64, 38, 0x0000000c000000LL, + 3, 64, 39, 0x0000000e000000LL, + 4, 64, 40, 0x0000000f000000LL, + 5, 64, 41, 0x0000000f800000LL, + 6, 64, 42, 0x0000000fc00000LL, + 7, 64, 43, 0x0000000fe00000LL, + 8, 64, 44, 0x0000000ff00000LL, + 9, 64, 45, 0x0000000ff80000LL, + 10, 64, 46, 0x0000000ffc0000LL, + 11, 64, 47, 0x0000000ffe0000LL, + 12, 64, 48, 0x0000000fff0000LL, + 13, 64, 49, 0x0000000fff8000LL, + 14, 64, 50, 0x0000000fffc000LL, + 15, 64, 51, 0x0000000fffe000LL, + 16, 64, 52, 0x0000000ffff000LL, + 17, 64, 53, 0x0000000ffff800LL, + 18, 64, 54, 0x0000000ffffc00LL, + 19, 64, 55, 0x0000000ffffe00LL, + 20, 64, 56, 0x0000000fffff00LL, + 21, 64, 57, 0x0000000fffff80LL, + 22, 64, 58, 0x0000000fffffc0LL, + 23, 64, 59, 0x0000000fffffe0LL, + 24, 64, 60, 0x0000000ffffff0LL, + 25, 64, 61, 0x0000000ffffff8LL, + 26, 64, 62, 0x0000000ffffffcLL, + 27, 64, 63, 0x0000000ffffffeLL, + 28, 64, 0, 0x0000000fffffffLL, + 1, 64, 36, 0x00000010000000LL, + 2, 64, 37, 0x00000018000000LL, + 3, 64, 38, 0x0000001c000000LL, + 4, 64, 39, 0x0000001e000000LL, + 5, 64, 40, 0x0000001f000000LL, + 6, 64, 41, 0x0000001f800000LL, + 7, 64, 42, 0x0000001fc00000LL, + 8, 64, 43, 0x0000001fe00000LL, + 9, 64, 44, 0x0000001ff00000LL, + 10, 64, 45, 0x0000001ff80000LL, + 11, 64, 46, 0x0000001ffc0000LL, + 12, 64, 47, 0x0000001ffe0000LL, + 13, 64, 48, 0x0000001fff0000LL, + 14, 64, 49, 0x0000001fff8000LL, + 15, 64, 50, 0x0000001fffc000LL, + 16, 64, 51, 0x0000001fffe000LL, + 17, 64, 52, 0x0000001ffff000LL, + 18, 64, 53, 0x0000001ffff800LL, + 19, 64, 54, 0x0000001ffffc00LL, + 20, 64, 55, 0x0000001ffffe00LL, + 21, 64, 56, 0x0000001fffff00LL, + 22, 64, 57, 0x0000001fffff80LL, + 23, 64, 58, 0x0000001fffffc0LL, + 24, 64, 59, 0x0000001fffffe0LL, + 25, 64, 60, 0x0000001ffffff0LL, + 26, 64, 61, 0x0000001ffffff8LL, + 27, 64, 62, 0x0000001ffffffcLL, + 28, 64, 63, 0x0000001ffffffeLL, + 29, 64, 0, 0x0000001fffffffLL, + 1, 64, 35, 0x00000020000000LL, + 2, 64, 36, 0x00000030000000LL, + 3, 64, 37, 0x00000038000000LL, + 4, 64, 38, 0x0000003c000000LL, + 5, 64, 39, 0x0000003e000000LL, + 6, 64, 40, 0x0000003f000000LL, + 7, 64, 41, 0x0000003f800000LL, + 8, 64, 42, 0x0000003fc00000LL, + 9, 64, 43, 0x0000003fe00000LL, + 10, 64, 44, 0x0000003ff00000LL, + 11, 64, 45, 0x0000003ff80000LL, + 12, 64, 46, 0x0000003ffc0000LL, + 13, 64, 47, 0x0000003ffe0000LL, + 14, 64, 48, 0x0000003fff0000LL, + 15, 64, 49, 0x0000003fff8000LL, + 16, 64, 50, 0x0000003fffc000LL, + 17, 64, 51, 0x0000003fffe000LL, + 18, 64, 52, 0x0000003ffff000LL, + 19, 64, 53, 0x0000003ffff800LL, + 20, 64, 54, 0x0000003ffffc00LL, + 21, 64, 55, 0x0000003ffffe00LL, + 22, 64, 56, 0x0000003fffff00LL, + 23, 64, 57, 0x0000003fffff80LL, + 24, 64, 58, 0x0000003fffffc0LL, + 25, 64, 59, 0x0000003fffffe0LL, + 26, 64, 60, 0x0000003ffffff0LL, + 27, 64, 61, 0x0000003ffffff8LL, + 28, 64, 62, 0x0000003ffffffcLL, + 29, 64, 63, 0x0000003ffffffeLL, + 30, 64, 0, 0x0000003fffffffLL, + 1, 64, 34, 0x00000040000000LL, + 2, 64, 35, 0x00000060000000LL, + 3, 64, 36, 0x00000070000000LL, + 4, 64, 37, 0x00000078000000LL, + 5, 64, 38, 0x0000007c000000LL, + 6, 64, 39, 0x0000007e000000LL, + 7, 64, 40, 0x0000007f000000LL, + 8, 64, 41, 0x0000007f800000LL, + 9, 64, 42, 0x0000007fc00000LL, + 10, 64, 43, 0x0000007fe00000LL, + 11, 64, 44, 0x0000007ff00000LL, + 12, 64, 45, 0x0000007ff80000LL, + 13, 64, 46, 0x0000007ffc0000LL, + 14, 64, 47, 0x0000007ffe0000LL, + 15, 64, 48, 0x0000007fff0000LL, + 16, 64, 49, 0x0000007fff8000LL, + 17, 64, 50, 0x0000007fffc000LL, + 18, 64, 51, 0x0000007fffe000LL, + 19, 64, 52, 0x0000007ffff000LL, + 20, 64, 53, 0x0000007ffff800LL, + 21, 64, 54, 0x0000007ffffc00LL, + 22, 64, 55, 0x0000007ffffe00LL, + 23, 64, 56, 0x0000007fffff00LL, + 24, 64, 57, 0x0000007fffff80LL, + 25, 64, 58, 0x0000007fffffc0LL, + 26, 64, 59, 0x0000007fffffe0LL, + 27, 64, 60, 0x0000007ffffff0LL, + 28, 64, 61, 0x0000007ffffff8LL, + 29, 64, 62, 0x0000007ffffffcLL, + 30, 64, 63, 0x0000007ffffffeLL, + 31, 64, 0, 0x0000007fffffffLL, + 1, 64, 33, 0x00000080000000LL, + 2, 64, 34, 0x000000c0000000LL, + 3, 64, 35, 0x000000e0000000LL, + 4, 64, 36, 0x000000f0000000LL, + 5, 64, 37, 0x000000f8000000LL, + 6, 64, 38, 0x000000fc000000LL, + 7, 64, 39, 0x000000fe000000LL, + 8, 64, 40, 0x000000ff000000LL, + 9, 64, 41, 0x000000ff800000LL, + 10, 64, 42, 0x000000ffc00000LL, + 11, 64, 43, 0x000000ffe00000LL, + 12, 64, 44, 0x000000fff00000LL, + 13, 64, 45, 0x000000fff80000LL, + 14, 64, 46, 0x000000fffc0000LL, + 15, 64, 47, 0x000000fffe0000LL, + 16, 64, 48, 0x000000ffff0000LL, + 17, 64, 49, 0x000000ffff8000LL, + 18, 64, 50, 0x000000ffffc000LL, + 19, 64, 51, 0x000000ffffe000LL, + 20, 64, 52, 0x000000fffff000LL, + 21, 64, 53, 0x000000fffff800LL, + 22, 64, 54, 0x000000fffffc00LL, + 23, 64, 55, 0x000000fffffe00LL, + 24, 64, 56, 0x000000ffffff00LL, + 25, 64, 57, 0x000000ffffff80LL, + 26, 64, 58, 0x000000ffffffc0LL, + 27, 64, 59, 0x000000ffffffe0LL, + 28, 64, 60, 0x000000fffffff0LL, + 29, 64, 61, 0x000000fffffff8LL, + 30, 64, 62, 0x000000fffffffcLL, + 31, 64, 63, 0x000000fffffffeLL, + 32, 64, 0, 0x000000ffffffffLL, + 1, 64, 32, 0x00000100000000LL, + 1, 32, 0, 0x00000100000001LL, + 2, 64, 33, 0x00000180000000LL, + 3, 64, 34, 0x000001c0000000LL, + 4, 64, 35, 0x000001e0000000LL, + 5, 64, 36, 0x000001f0000000LL, + 6, 64, 37, 0x000001f8000000LL, + 7, 64, 38, 0x000001fc000000LL, + 8, 64, 39, 0x000001fe000000LL, + 9, 64, 40, 0x000001ff000000LL, + 10, 64, 41, 0x000001ff800000LL, + 11, 64, 42, 0x000001ffc00000LL, + 12, 64, 43, 0x000001ffe00000LL, + 13, 64, 44, 0x000001fff00000LL, + 14, 64, 45, 0x000001fff80000LL, + 15, 64, 46, 0x000001fffc0000LL, + 16, 64, 47, 0x000001fffe0000LL, + 17, 64, 48, 0x000001ffff0000LL, + 18, 64, 49, 0x000001ffff8000LL, + 19, 64, 50, 0x000001ffffc000LL, + 20, 64, 51, 0x000001ffffe000LL, + 21, 64, 52, 0x000001fffff000LL, + 22, 64, 53, 0x000001fffff800LL, + 23, 64, 54, 0x000001fffffc00LL, + 24, 64, 55, 0x000001fffffe00LL, + 25, 64, 56, 0x000001ffffff00LL, + 26, 64, 57, 0x000001ffffff80LL, + 27, 64, 58, 0x000001ffffffc0LL, + 28, 64, 59, 0x000001ffffffe0LL, + 29, 64, 60, 0x000001fffffff0LL, + 30, 64, 61, 0x000001fffffff8LL, + 31, 64, 62, 0x000001fffffffcLL, + 32, 64, 63, 0x000001fffffffeLL, + 33, 64, 0, 0x000001ffffffffLL, + 1, 64, 31, 0x00000200000000LL, + 1, 32, 31, 0x00000200000002LL, + 2, 64, 32, 0x00000300000000LL, + 2, 32, 0, 0x00000300000003LL, + 3, 64, 33, 0x00000380000000LL, + 4, 64, 34, 0x000003c0000000LL, + 5, 64, 35, 0x000003e0000000LL, + 6, 64, 36, 0x000003f0000000LL, + 7, 64, 37, 0x000003f8000000LL, + 8, 64, 38, 0x000003fc000000LL, + 9, 64, 39, 0x000003fe000000LL, + 10, 64, 40, 0x000003ff000000LL, + 11, 64, 41, 0x000003ff800000LL, + 12, 64, 42, 0x000003ffc00000LL, + 13, 64, 43, 0x000003ffe00000LL, + 14, 64, 44, 0x000003fff00000LL, + 15, 64, 45, 0x000003fff80000LL, + 16, 64, 46, 0x000003fffc0000LL, + 17, 64, 47, 0x000003fffe0000LL, + 18, 64, 48, 0x000003ffff0000LL, + 19, 64, 49, 0x000003ffff8000LL, + 20, 64, 50, 0x000003ffffc000LL, + 21, 64, 51, 0x000003ffffe000LL, + 22, 64, 52, 0x000003fffff000LL, + 23, 64, 53, 0x000003fffff800LL, + 24, 64, 54, 0x000003fffffc00LL, + 25, 64, 55, 0x000003fffffe00LL, + 26, 64, 56, 0x000003ffffff00LL, + 27, 64, 57, 0x000003ffffff80LL, + 28, 64, 58, 0x000003ffffffc0LL, + 29, 64, 59, 0x000003ffffffe0LL, + 30, 64, 60, 0x000003fffffff0LL, + 31, 64, 61, 0x000003fffffff8LL, + 32, 64, 62, 0x000003fffffffcLL, + 33, 64, 63, 0x000003fffffffeLL, + 34, 64, 0, 0x000003ffffffffLL, + 1, 64, 30, 0x00000400000000LL, + 1, 32, 30, 0x00000400000004LL, + 2, 64, 31, 0x00000600000000LL, + 2, 32, 31, 0x00000600000006LL, + 3, 64, 32, 0x00000700000000LL, + 3, 32, 0, 0x00000700000007LL, + 4, 64, 33, 0x00000780000000LL, + 5, 64, 34, 0x000007c0000000LL, + 6, 64, 35, 0x000007e0000000LL, + 7, 64, 36, 0x000007f0000000LL, + 8, 64, 37, 0x000007f8000000LL, + 9, 64, 38, 0x000007fc000000LL, + 10, 64, 39, 0x000007fe000000LL, + 11, 64, 40, 0x000007ff000000LL, + 12, 64, 41, 0x000007ff800000LL, + 13, 64, 42, 0x000007ffc00000LL, + 14, 64, 43, 0x000007ffe00000LL, + 15, 64, 44, 0x000007fff00000LL, + 16, 64, 45, 0x000007fff80000LL, + 17, 64, 46, 0x000007fffc0000LL, + 18, 64, 47, 0x000007fffe0000LL, + 19, 64, 48, 0x000007ffff0000LL, + 20, 64, 49, 0x000007ffff8000LL, + 21, 64, 50, 0x000007ffffc000LL, + 22, 64, 51, 0x000007ffffe000LL, + 23, 64, 52, 0x000007fffff000LL, + 24, 64, 53, 0x000007fffff800LL, + 25, 64, 54, 0x000007fffffc00LL, + 26, 64, 55, 0x000007fffffe00LL, + 27, 64, 56, 0x000007ffffff00LL, + 28, 64, 57, 0x000007ffffff80LL, + 29, 64, 58, 0x000007ffffffc0LL, + 30, 64, 59, 0x000007ffffffe0LL, + 31, 64, 60, 0x000007fffffff0LL, + 32, 64, 61, 0x000007fffffff8LL, + 33, 64, 62, 0x000007fffffffcLL, + 34, 64, 63, 0x000007fffffffeLL, + 35, 64, 0, 0x000007ffffffffLL, + 1, 64, 29, 0x00000800000000LL, + 1, 32, 29, 0x00000800000008LL, + 2, 64, 30, 0x00000c00000000LL, + 2, 32, 30, 0x00000c0000000cLL, + 3, 64, 31, 0x00000e00000000LL, + 3, 32, 31, 0x00000e0000000eLL, + 4, 64, 32, 0x00000f00000000LL, + 4, 32, 0, 0x00000f0000000fLL, + 5, 64, 33, 0x00000f80000000LL, + 6, 64, 34, 0x00000fc0000000LL, + 7, 64, 35, 0x00000fe0000000LL, + 8, 64, 36, 0x00000ff0000000LL, + 9, 64, 37, 0x00000ff8000000LL, + 10, 64, 38, 0x00000ffc000000LL, + 11, 64, 39, 0x00000ffe000000LL, + 12, 64, 40, 0x00000fff000000LL, + 13, 64, 41, 0x00000fff800000LL, + 14, 64, 42, 0x00000fffc00000LL, + 15, 64, 43, 0x00000fffe00000LL, + 16, 64, 44, 0x00000ffff00000LL, + 17, 64, 45, 0x00000ffff80000LL, + 18, 64, 46, 0x00000ffffc0000LL, + 19, 64, 47, 0x00000ffffe0000LL, + 20, 64, 48, 0x00000fffff0000LL, + 21, 64, 49, 0x00000fffff8000LL, + 22, 64, 50, 0x00000fffffc000LL, + 23, 64, 51, 0x00000fffffe000LL, + 24, 64, 52, 0x00000ffffff000LL, + 25, 64, 53, 0x00000ffffff800LL, + 26, 64, 54, 0x00000ffffffc00LL, + 27, 64, 55, 0x00000ffffffe00LL, + 28, 64, 56, 0x00000fffffff00LL, + 29, 64, 57, 0x00000fffffff80LL, + 30, 64, 58, 0x00000fffffffc0LL, + 31, 64, 59, 0x00000fffffffe0LL, + 32, 64, 60, 0x00000ffffffff0LL, + 33, 64, 61, 0x00000ffffffff8LL, + 34, 64, 62, 0x00000ffffffffcLL, + 35, 64, 63, 0x00000ffffffffeLL, + 36, 64, 0, 0x00000fffffffffLL, + 1, 64, 28, 0x00001000000000LL, + 1, 32, 28, 0x00001000000010LL, + 2, 64, 29, 0x00001800000000LL, + 2, 32, 29, 0x00001800000018LL, + 3, 64, 30, 0x00001c00000000LL, + 3, 32, 30, 0x00001c0000001cLL, + 4, 64, 31, 0x00001e00000000LL, + 4, 32, 31, 0x00001e0000001eLL, + 5, 64, 32, 0x00001f00000000LL, + 5, 32, 0, 0x00001f0000001fLL, + 6, 64, 33, 0x00001f80000000LL, + 7, 64, 34, 0x00001fc0000000LL, + 8, 64, 35, 0x00001fe0000000LL, + 9, 64, 36, 0x00001ff0000000LL, + 10, 64, 37, 0x00001ff8000000LL, + 11, 64, 38, 0x00001ffc000000LL, + 12, 64, 39, 0x00001ffe000000LL, + 13, 64, 40, 0x00001fff000000LL, + 14, 64, 41, 0x00001fff800000LL, + 15, 64, 42, 0x00001fffc00000LL, + 16, 64, 43, 0x00001fffe00000LL, + 17, 64, 44, 0x00001ffff00000LL, + 18, 64, 45, 0x00001ffff80000LL, + 19, 64, 46, 0x00001ffffc0000LL, + 20, 64, 47, 0x00001ffffe0000LL, + 21, 64, 48, 0x00001fffff0000LL, + 22, 64, 49, 0x00001fffff8000LL, + 23, 64, 50, 0x00001fffffc000LL, + 24, 64, 51, 0x00001fffffe000LL, + 25, 64, 52, 0x00001ffffff000LL, + 26, 64, 53, 0x00001ffffff800LL, + 27, 64, 54, 0x00001ffffffc00LL, + 28, 64, 55, 0x00001ffffffe00LL, + 29, 64, 56, 0x00001fffffff00LL, + 30, 64, 57, 0x00001fffffff80LL, + 31, 64, 58, 0x00001fffffffc0LL, + 32, 64, 59, 0x00001fffffffe0LL, + 33, 64, 60, 0x00001ffffffff0LL, + 34, 64, 61, 0x00001ffffffff8LL, + 35, 64, 62, 0x00001ffffffffcLL, + 36, 64, 63, 0x00001ffffffffeLL, + 37, 64, 0, 0x00001fffffffffLL, + 1, 64, 27, 0x00002000000000LL, + 1, 32, 27, 0x00002000000020LL, + 2, 64, 28, 0x00003000000000LL, + 2, 32, 28, 0x00003000000030LL, + 3, 64, 29, 0x00003800000000LL, + 3, 32, 29, 0x00003800000038LL, + 4, 64, 30, 0x00003c00000000LL, + 4, 32, 30, 0x00003c0000003cLL, + 5, 64, 31, 0x00003e00000000LL, + 5, 32, 31, 0x00003e0000003eLL, + 6, 64, 32, 0x00003f00000000LL, + 6, 32, 0, 0x00003f0000003fLL, + 7, 64, 33, 0x00003f80000000LL, + 8, 64, 34, 0x00003fc0000000LL, + 9, 64, 35, 0x00003fe0000000LL, + 10, 64, 36, 0x00003ff0000000LL, + 11, 64, 37, 0x00003ff8000000LL, + 12, 64, 38, 0x00003ffc000000LL, + 13, 64, 39, 0x00003ffe000000LL, + 14, 64, 40, 0x00003fff000000LL, + 15, 64, 41, 0x00003fff800000LL, + 16, 64, 42, 0x00003fffc00000LL, + 17, 64, 43, 0x00003fffe00000LL, + 18, 64, 44, 0x00003ffff00000LL, + 19, 64, 45, 0x00003ffff80000LL, + 20, 64, 46, 0x00003ffffc0000LL, + 21, 64, 47, 0x00003ffffe0000LL, + 22, 64, 48, 0x00003fffff0000LL, + 23, 64, 49, 0x00003fffff8000LL, + 24, 64, 50, 0x00003fffffc000LL, + 25, 64, 51, 0x00003fffffe000LL, + 26, 64, 52, 0x00003ffffff000LL, + 27, 64, 53, 0x00003ffffff800LL, + 28, 64, 54, 0x00003ffffffc00LL, + 29, 64, 55, 0x00003ffffffe00LL, + 30, 64, 56, 0x00003fffffff00LL, + 31, 64, 57, 0x00003fffffff80LL, + 32, 64, 58, 0x00003fffffffc0LL, + 33, 64, 59, 0x00003fffffffe0LL, + 34, 64, 60, 0x00003ffffffff0LL, + 35, 64, 61, 0x00003ffffffff8LL, + 36, 64, 62, 0x00003ffffffffcLL, + 37, 64, 63, 0x00003ffffffffeLL, + 38, 64, 0, 0x00003fffffffffLL, + 1, 64, 26, 0x00004000000000LL, + 1, 32, 26, 0x00004000000040LL, + 2, 64, 27, 0x00006000000000LL, + 2, 32, 27, 0x00006000000060LL, + 3, 64, 28, 0x00007000000000LL, + 3, 32, 28, 0x00007000000070LL, + 4, 64, 29, 0x00007800000000LL, + 4, 32, 29, 0x00007800000078LL, + 5, 64, 30, 0x00007c00000000LL, + 5, 32, 30, 0x00007c0000007cLL, + 6, 64, 31, 0x00007e00000000LL, + 6, 32, 31, 0x00007e0000007eLL, + 7, 64, 32, 0x00007f00000000LL, + 7, 32, 0, 0x00007f0000007fLL, + 8, 64, 33, 0x00007f80000000LL, + 9, 64, 34, 0x00007fc0000000LL, + 10, 64, 35, 0x00007fe0000000LL, + 11, 64, 36, 0x00007ff0000000LL, + 12, 64, 37, 0x00007ff8000000LL, + 13, 64, 38, 0x00007ffc000000LL, + 14, 64, 39, 0x00007ffe000000LL, + 15, 64, 40, 0x00007fff000000LL, + 16, 64, 41, 0x00007fff800000LL, + 17, 64, 42, 0x00007fffc00000LL, + 18, 64, 43, 0x00007fffe00000LL, + 19, 64, 44, 0x00007ffff00000LL, + 20, 64, 45, 0x00007ffff80000LL, + 21, 64, 46, 0x00007ffffc0000LL, + 22, 64, 47, 0x00007ffffe0000LL, + 23, 64, 48, 0x00007fffff0000LL, + 24, 64, 49, 0x00007fffff8000LL, + 25, 64, 50, 0x00007fffffc000LL, + 26, 64, 51, 0x00007fffffe000LL, + 27, 64, 52, 0x00007ffffff000LL, + 28, 64, 53, 0x00007ffffff800LL, + 29, 64, 54, 0x00007ffffffc00LL, + 30, 64, 55, 0x00007ffffffe00LL, + 31, 64, 56, 0x00007fffffff00LL, + 32, 64, 57, 0x00007fffffff80LL, + 33, 64, 58, 0x00007fffffffc0LL, + 34, 64, 59, 0x00007fffffffe0LL, + 35, 64, 60, 0x00007ffffffff0LL, + 36, 64, 61, 0x00007ffffffff8LL, + 37, 64, 62, 0x00007ffffffffcLL, + 38, 64, 63, 0x00007ffffffffeLL, + 39, 64, 0, 0x00007fffffffffLL, + 1, 64, 25, 0x00008000000000LL, + 1, 32, 25, 0x00008000000080LL, + 2, 64, 26, 0x0000c000000000LL, + 2, 32, 26, 0x0000c0000000c0LL, + 3, 64, 27, 0x0000e000000000LL, + 3, 32, 27, 0x0000e0000000e0LL, + 4, 64, 28, 0x0000f000000000LL, + 4, 32, 28, 0x0000f0000000f0LL, + 5, 64, 29, 0x0000f800000000LL, + 5, 32, 29, 0x0000f8000000f8LL, + 6, 64, 30, 0x0000fc00000000LL, + 6, 32, 30, 0x0000fc000000fcLL, + 7, 64, 31, 0x0000fe00000000LL, + 7, 32, 31, 0x0000fe000000feLL, + 8, 64, 32, 0x0000ff00000000LL, + 8, 32, 0, 0x0000ff000000ffLL, + 9, 64, 33, 0x0000ff80000000LL, + 10, 64, 34, 0x0000ffc0000000LL, + 11, 64, 35, 0x0000ffe0000000LL, + 12, 64, 36, 0x0000fff0000000LL, + 13, 64, 37, 0x0000fff8000000LL, + 14, 64, 38, 0x0000fffc000000LL, + 15, 64, 39, 0x0000fffe000000LL, + 16, 64, 40, 0x0000ffff000000LL, + 17, 64, 41, 0x0000ffff800000LL, + 18, 64, 42, 0x0000ffffc00000LL, + 19, 64, 43, 0x0000ffffe00000LL, + 20, 64, 44, 0x0000fffff00000LL, + 21, 64, 45, 0x0000fffff80000LL, + 22, 64, 46, 0x0000fffffc0000LL, + 23, 64, 47, 0x0000fffffe0000LL, + 24, 64, 48, 0x0000ffffff0000LL, + 25, 64, 49, 0x0000ffffff8000LL, + 26, 64, 50, 0x0000ffffffc000LL, + 27, 64, 51, 0x0000ffffffe000LL, + 28, 64, 52, 0x0000fffffff000LL, + 29, 64, 53, 0x0000fffffff800LL, + 30, 64, 54, 0x0000fffffffc00LL, + 31, 64, 55, 0x0000fffffffe00LL, + 32, 64, 56, 0x0000ffffffff00LL, + 33, 64, 57, 0x0000ffffffff80LL, + 34, 64, 58, 0x0000ffffffffc0LL, + 35, 64, 59, 0x0000ffffffffe0LL, + 36, 64, 60, 0x0000fffffffff0LL, + 37, 64, 61, 0x0000fffffffff8LL, + 38, 64, 62, 0x0000fffffffffcLL, + 39, 64, 63, 0x0000fffffffffeLL, + 40, 64, 0, 0x0000ffffffffffLL, + 1, 64, 24, 0x00010000000000LL, + 1, 32, 24, 0x00010000000100LL, + 2, 64, 25, 0x00018000000000LL, + 2, 32, 25, 0x00018000000180LL, + 3, 64, 26, 0x0001c000000000LL, + 3, 32, 26, 0x0001c0000001c0LL, + 4, 64, 27, 0x0001e000000000LL, + 4, 32, 27, 0x0001e0000001e0LL, + 5, 64, 28, 0x0001f000000000LL, + 5, 32, 28, 0x0001f0000001f0LL, + 6, 64, 29, 0x0001f800000000LL, + 6, 32, 29, 0x0001f8000001f8LL, + 7, 64, 30, 0x0001fc00000000LL, + 7, 32, 30, 0x0001fc000001fcLL, + 8, 64, 31, 0x0001fe00000000LL, + 8, 32, 31, 0x0001fe000001feLL, + 9, 64, 32, 0x0001ff00000000LL, + 9, 32, 0, 0x0001ff000001ffLL, + 10, 64, 33, 0x0001ff80000000LL, + 11, 64, 34, 0x0001ffc0000000LL, + 12, 64, 35, 0x0001ffe0000000LL, + 13, 64, 36, 0x0001fff0000000LL, + 14, 64, 37, 0x0001fff8000000LL, + 15, 64, 38, 0x0001fffc000000LL, + 16, 64, 39, 0x0001fffe000000LL, + 17, 64, 40, 0x0001ffff000000LL, + 18, 64, 41, 0x0001ffff800000LL, + 19, 64, 42, 0x0001ffffc00000LL, + 20, 64, 43, 0x0001ffffe00000LL, + 21, 64, 44, 0x0001fffff00000LL, + 22, 64, 45, 0x0001fffff80000LL, + 23, 64, 46, 0x0001fffffc0000LL, + 24, 64, 47, 0x0001fffffe0000LL, + 25, 64, 48, 0x0001ffffff0000LL, + 26, 64, 49, 0x0001ffffff8000LL, + 27, 64, 50, 0x0001ffffffc000LL, + 28, 64, 51, 0x0001ffffffe000LL, + 29, 64, 52, 0x0001fffffff000LL, + 30, 64, 53, 0x0001fffffff800LL, + 31, 64, 54, 0x0001fffffffc00LL, + 32, 64, 55, 0x0001fffffffe00LL, + 33, 64, 56, 0x0001ffffffff00LL, + 34, 64, 57, 0x0001ffffffff80LL, + 35, 64, 58, 0x0001ffffffffc0LL, + 36, 64, 59, 0x0001ffffffffe0LL, + 37, 64, 60, 0x0001fffffffff0LL, + 38, 64, 61, 0x0001fffffffff8LL, + 39, 64, 62, 0x0001fffffffffcLL, + 40, 64, 63, 0x0001fffffffffeLL, + 41, 64, 0, 0x0001ffffffffffLL, + 1, 64, 23, 0x00020000000000LL, + 1, 32, 23, 0x00020000000200LL, + 2, 64, 24, 0x00030000000000LL, + 2, 32, 24, 0x00030000000300LL, + 3, 64, 25, 0x00038000000000LL, + 3, 32, 25, 0x00038000000380LL, + 4, 64, 26, 0x0003c000000000LL, + 4, 32, 26, 0x0003c0000003c0LL, + 5, 64, 27, 0x0003e000000000LL, + 5, 32, 27, 0x0003e0000003e0LL, + 6, 64, 28, 0x0003f000000000LL, + 6, 32, 28, 0x0003f0000003f0LL, + 7, 64, 29, 0x0003f800000000LL, + 7, 32, 29, 0x0003f8000003f8LL, + 8, 64, 30, 0x0003fc00000000LL, + 8, 32, 30, 0x0003fc000003fcLL, + 9, 64, 31, 0x0003fe00000000LL, + 9, 32, 31, 0x0003fe000003feLL, + 10, 64, 32, 0x0003ff00000000LL, + 10, 32, 0, 0x0003ff000003ffLL, + 11, 64, 33, 0x0003ff80000000LL, + 12, 64, 34, 0x0003ffc0000000LL, + 13, 64, 35, 0x0003ffe0000000LL, + 14, 64, 36, 0x0003fff0000000LL, + 15, 64, 37, 0x0003fff8000000LL, + 16, 64, 38, 0x0003fffc000000LL, + 17, 64, 39, 0x0003fffe000000LL, + 18, 64, 40, 0x0003ffff000000LL, + 19, 64, 41, 0x0003ffff800000LL, + 20, 64, 42, 0x0003ffffc00000LL, + 21, 64, 43, 0x0003ffffe00000LL, + 22, 64, 44, 0x0003fffff00000LL, + 23, 64, 45, 0x0003fffff80000LL, + 24, 64, 46, 0x0003fffffc0000LL, + 25, 64, 47, 0x0003fffffe0000LL, + 26, 64, 48, 0x0003ffffff0000LL, + 27, 64, 49, 0x0003ffffff8000LL, + 28, 64, 50, 0x0003ffffffc000LL, + 29, 64, 51, 0x0003ffffffe000LL, + 30, 64, 52, 0x0003fffffff000LL, + 31, 64, 53, 0x0003fffffff800LL, + 32, 64, 54, 0x0003fffffffc00LL, + 33, 64, 55, 0x0003fffffffe00LL, + 34, 64, 56, 0x0003ffffffff00LL, + 35, 64, 57, 0x0003ffffffff80LL, + 36, 64, 58, 0x0003ffffffffc0LL, + 37, 64, 59, 0x0003ffffffffe0LL, + 38, 64, 60, 0x0003fffffffff0LL, + 39, 64, 61, 0x0003fffffffff8LL, + 40, 64, 62, 0x0003fffffffffcLL, + 41, 64, 63, 0x0003fffffffffeLL, + 42, 64, 0, 0x0003ffffffffffLL, + 1, 64, 22, 0x00040000000000LL, + 1, 32, 22, 0x00040000000400LL, + 2, 64, 23, 0x00060000000000LL, + 2, 32, 23, 0x00060000000600LL, + 3, 64, 24, 0x00070000000000LL, + 3, 32, 24, 0x00070000000700LL, + 4, 64, 25, 0x00078000000000LL, + 4, 32, 25, 0x00078000000780LL, + 5, 64, 26, 0x0007c000000000LL, + 5, 32, 26, 0x0007c0000007c0LL, + 6, 64, 27, 0x0007e000000000LL, + 6, 32, 27, 0x0007e0000007e0LL, + 7, 64, 28, 0x0007f000000000LL, + 7, 32, 28, 0x0007f0000007f0LL, + 8, 64, 29, 0x0007f800000000LL, + 8, 32, 29, 0x0007f8000007f8LL, + 9, 64, 30, 0x0007fc00000000LL, + 9, 32, 30, 0x0007fc000007fcLL, + 10, 64, 31, 0x0007fe00000000LL, + 10, 32, 31, 0x0007fe000007feLL, + 11, 64, 32, 0x0007ff00000000LL, + 11, 32, 0, 0x0007ff000007ffLL, + 12, 64, 33, 0x0007ff80000000LL, + 13, 64, 34, 0x0007ffc0000000LL, + 14, 64, 35, 0x0007ffe0000000LL, + 15, 64, 36, 0x0007fff0000000LL, + 16, 64, 37, 0x0007fff8000000LL, + 17, 64, 38, 0x0007fffc000000LL, + 18, 64, 39, 0x0007fffe000000LL, + 19, 64, 40, 0x0007ffff000000LL, + 20, 64, 41, 0x0007ffff800000LL, + 21, 64, 42, 0x0007ffffc00000LL, + 22, 64, 43, 0x0007ffffe00000LL, + 23, 64, 44, 0x0007fffff00000LL, + 24, 64, 45, 0x0007fffff80000LL, + 25, 64, 46, 0x0007fffffc0000LL, + 26, 64, 47, 0x0007fffffe0000LL, + 27, 64, 48, 0x0007ffffff0000LL, + 28, 64, 49, 0x0007ffffff8000LL, + 29, 64, 50, 0x0007ffffffc000LL, + 30, 64, 51, 0x0007ffffffe000LL, + 31, 64, 52, 0x0007fffffff000LL, + 32, 64, 53, 0x0007fffffff800LL, + 33, 64, 54, 0x0007fffffffc00LL, + 34, 64, 55, 0x0007fffffffe00LL, + 35, 64, 56, 0x0007ffffffff00LL, + 36, 64, 57, 0x0007ffffffff80LL, + 37, 64, 58, 0x0007ffffffffc0LL, + 38, 64, 59, 0x0007ffffffffe0LL, + 39, 64, 60, 0x0007fffffffff0LL, + 40, 64, 61, 0x0007fffffffff8LL, + 41, 64, 62, 0x0007fffffffffcLL, + 42, 64, 63, 0x0007fffffffffeLL, + 43, 64, 0, 0x0007ffffffffffLL, + 1, 64, 21, 0x00080000000000LL, + 1, 32, 21, 0x00080000000800LL, + 2, 64, 22, 0x000c0000000000LL, + 2, 32, 22, 0x000c0000000c00LL, + 3, 64, 23, 0x000e0000000000LL, + 3, 32, 23, 0x000e0000000e00LL, + 4, 64, 24, 0x000f0000000000LL, + 4, 32, 24, 0x000f0000000f00LL, + 5, 64, 25, 0x000f8000000000LL, + 5, 32, 25, 0x000f8000000f80LL, + 6, 64, 26, 0x000fc000000000LL, + 6, 32, 26, 0x000fc000000fc0LL, + 7, 64, 27, 0x000fe000000000LL, + 7, 32, 27, 0x000fe000000fe0LL, + 8, 64, 28, 0x000ff000000000LL, + 8, 32, 28, 0x000ff000000ff0LL, + 9, 64, 29, 0x000ff800000000LL, + 9, 32, 29, 0x000ff800000ff8LL, + 10, 64, 30, 0x000ffc00000000LL, + 10, 32, 30, 0x000ffc00000ffcLL, + 11, 64, 31, 0x000ffe00000000LL, + 11, 32, 31, 0x000ffe00000ffeLL, + 12, 64, 32, 0x000fff00000000LL, + 12, 32, 0, 0x000fff00000fffLL, + 13, 64, 33, 0x000fff80000000LL, + 14, 64, 34, 0x000fffc0000000LL, + 15, 64, 35, 0x000fffe0000000LL, + 16, 64, 36, 0x000ffff0000000LL, + 17, 64, 37, 0x000ffff8000000LL, + 18, 64, 38, 0x000ffffc000000LL, + 19, 64, 39, 0x000ffffe000000LL, + 20, 64, 40, 0x000fffff000000LL, + 21, 64, 41, 0x000fffff800000LL, + 22, 64, 42, 0x000fffffc00000LL, + 23, 64, 43, 0x000fffffe00000LL, + 24, 64, 44, 0x000ffffff00000LL, + 25, 64, 45, 0x000ffffff80000LL, + 26, 64, 46, 0x000ffffffc0000LL, + 27, 64, 47, 0x000ffffffe0000LL, + 28, 64, 48, 0x000fffffff0000LL, + 29, 64, 49, 0x000fffffff8000LL, + 30, 64, 50, 0x000fffffffc000LL, + 31, 64, 51, 0x000fffffffe000LL, + 32, 64, 52, 0x000ffffffff000LL, + 33, 64, 53, 0x000ffffffff800LL, + 34, 64, 54, 0x000ffffffffc00LL, + 35, 64, 55, 0x000ffffffffe00LL, + 36, 64, 56, 0x000fffffffff00LL, + 37, 64, 57, 0x000fffffffff80LL, + 38, 64, 58, 0x000fffffffffc0LL, + 39, 64, 59, 0x000fffffffffe0LL, + 40, 64, 60, 0x000ffffffffff0LL, + 41, 64, 61, 0x000ffffffffff8LL, + 42, 64, 62, 0x000ffffffffffcLL, + 43, 64, 63, 0x000ffffffffffeLL, + 44, 64, 0, 0x000fffffffffffLL, + 1, 64, 20, 0x00100000000000LL, + 1, 32, 20, 0x00100000001000LL, + 2, 64, 21, 0x00180000000000LL, + 2, 32, 21, 0x00180000001800LL, + 3, 64, 22, 0x001c0000000000LL, + 3, 32, 22, 0x001c0000001c00LL, + 4, 64, 23, 0x001e0000000000LL, + 4, 32, 23, 0x001e0000001e00LL, + 5, 64, 24, 0x001f0000000000LL, + 5, 32, 24, 0x001f0000001f00LL, + 6, 64, 25, 0x001f8000000000LL, + 6, 32, 25, 0x001f8000001f80LL, + 7, 64, 26, 0x001fc000000000LL, + 7, 32, 26, 0x001fc000001fc0LL, + 8, 64, 27, 0x001fe000000000LL, + 8, 32, 27, 0x001fe000001fe0LL, + 9, 64, 28, 0x001ff000000000LL, + 9, 32, 28, 0x001ff000001ff0LL, + 10, 64, 29, 0x001ff800000000LL, + 10, 32, 29, 0x001ff800001ff8LL, + 11, 64, 30, 0x001ffc00000000LL, + 11, 32, 30, 0x001ffc00001ffcLL, + 12, 64, 31, 0x001ffe00000000LL, + 12, 32, 31, 0x001ffe00001ffeLL, + 13, 64, 32, 0x001fff00000000LL, + 13, 32, 0, 0x001fff00001fffLL, + 14, 64, 33, 0x001fff80000000LL, + 15, 64, 34, 0x001fffc0000000LL, + 16, 64, 35, 0x001fffe0000000LL, + 17, 64, 36, 0x001ffff0000000LL, + 18, 64, 37, 0x001ffff8000000LL, + 19, 64, 38, 0x001ffffc000000LL, + 20, 64, 39, 0x001ffffe000000LL, + 21, 64, 40, 0x001fffff000000LL, + 22, 64, 41, 0x001fffff800000LL, + 23, 64, 42, 0x001fffffc00000LL, + 24, 64, 43, 0x001fffffe00000LL, + 25, 64, 44, 0x001ffffff00000LL, + 26, 64, 45, 0x001ffffff80000LL, + 27, 64, 46, 0x001ffffffc0000LL, + 28, 64, 47, 0x001ffffffe0000LL, + 29, 64, 48, 0x001fffffff0000LL, + 30, 64, 49, 0x001fffffff8000LL, + 31, 64, 50, 0x001fffffffc000LL, + 32, 64, 51, 0x001fffffffe000LL, + 33, 64, 52, 0x001ffffffff000LL, + 34, 64, 53, 0x001ffffffff800LL, + 35, 64, 54, 0x001ffffffffc00LL, + 36, 64, 55, 0x001ffffffffe00LL, + 37, 64, 56, 0x001fffffffff00LL, + 38, 64, 57, 0x001fffffffff80LL, + 39, 64, 58, 0x001fffffffffc0LL, + 40, 64, 59, 0x001fffffffffe0LL, + 41, 64, 60, 0x001ffffffffff0LL, + 42, 64, 61, 0x001ffffffffff8LL, + 43, 64, 62, 0x001ffffffffffcLL, + 44, 64, 63, 0x001ffffffffffeLL, + 45, 64, 0, 0x001fffffffffffLL, + 1, 64, 19, 0x00200000000000LL, + 1, 32, 19, 0x00200000002000LL, + 2, 64, 20, 0x00300000000000LL, + 2, 32, 20, 0x00300000003000LL, + 3, 64, 21, 0x00380000000000LL, + 3, 32, 21, 0x00380000003800LL, + 4, 64, 22, 0x003c0000000000LL, + 4, 32, 22, 0x003c0000003c00LL, + 5, 64, 23, 0x003e0000000000LL, + 5, 32, 23, 0x003e0000003e00LL, + 6, 64, 24, 0x003f0000000000LL, + 6, 32, 24, 0x003f0000003f00LL, + 7, 64, 25, 0x003f8000000000LL, + 7, 32, 25, 0x003f8000003f80LL, + 8, 64, 26, 0x003fc000000000LL, + 8, 32, 26, 0x003fc000003fc0LL, + 9, 64, 27, 0x003fe000000000LL, + 9, 32, 27, 0x003fe000003fe0LL, + 10, 64, 28, 0x003ff000000000LL, + 10, 32, 28, 0x003ff000003ff0LL, + 11, 64, 29, 0x003ff800000000LL, + 11, 32, 29, 0x003ff800003ff8LL, + 12, 64, 30, 0x003ffc00000000LL, + 12, 32, 30, 0x003ffc00003ffcLL, + 13, 64, 31, 0x003ffe00000000LL, + 13, 32, 31, 0x003ffe00003ffeLL, + 14, 64, 32, 0x003fff00000000LL, + 14, 32, 0, 0x003fff00003fffLL, + 15, 64, 33, 0x003fff80000000LL, + 16, 64, 34, 0x003fffc0000000LL, + 17, 64, 35, 0x003fffe0000000LL, + 18, 64, 36, 0x003ffff0000000LL, + 19, 64, 37, 0x003ffff8000000LL, + 20, 64, 38, 0x003ffffc000000LL, + 21, 64, 39, 0x003ffffe000000LL, + 22, 64, 40, 0x003fffff000000LL, + 23, 64, 41, 0x003fffff800000LL, + 24, 64, 42, 0x003fffffc00000LL, + 25, 64, 43, 0x003fffffe00000LL, + 26, 64, 44, 0x003ffffff00000LL, + 27, 64, 45, 0x003ffffff80000LL, + 28, 64, 46, 0x003ffffffc0000LL, + 29, 64, 47, 0x003ffffffe0000LL, + 30, 64, 48, 0x003fffffff0000LL, + 31, 64, 49, 0x003fffffff8000LL, + 32, 64, 50, 0x003fffffffc000LL, + 33, 64, 51, 0x003fffffffe000LL, + 34, 64, 52, 0x003ffffffff000LL, + 35, 64, 53, 0x003ffffffff800LL, + 36, 64, 54, 0x003ffffffffc00LL, + 37, 64, 55, 0x003ffffffffe00LL, + 38, 64, 56, 0x003fffffffff00LL, + 39, 64, 57, 0x003fffffffff80LL, + 40, 64, 58, 0x003fffffffffc0LL, + 41, 64, 59, 0x003fffffffffe0LL, + 42, 64, 60, 0x003ffffffffff0LL, + 43, 64, 61, 0x003ffffffffff8LL, + 44, 64, 62, 0x003ffffffffffcLL, + 45, 64, 63, 0x003ffffffffffeLL, + 46, 64, 0, 0x003fffffffffffLL, + 1, 64, 18, 0x00400000000000LL, + 1, 32, 18, 0x00400000004000LL, + 2, 64, 19, 0x00600000000000LL, + 2, 32, 19, 0x00600000006000LL, + 3, 64, 20, 0x00700000000000LL, + 3, 32, 20, 0x00700000007000LL, + 4, 64, 21, 0x00780000000000LL, + 4, 32, 21, 0x00780000007800LL, + 5, 64, 22, 0x007c0000000000LL, + 5, 32, 22, 0x007c0000007c00LL, + 6, 64, 23, 0x007e0000000000LL, + 6, 32, 23, 0x007e0000007e00LL, + 7, 64, 24, 0x007f0000000000LL, + 7, 32, 24, 0x007f0000007f00LL, + 8, 64, 25, 0x007f8000000000LL, + 8, 32, 25, 0x007f8000007f80LL, + 9, 64, 26, 0x007fc000000000LL, + 9, 32, 26, 0x007fc000007fc0LL, + 10, 64, 27, 0x007fe000000000LL, + 10, 32, 27, 0x007fe000007fe0LL, + 11, 64, 28, 0x007ff000000000LL, + 11, 32, 28, 0x007ff000007ff0LL, + 12, 64, 29, 0x007ff800000000LL, + 12, 32, 29, 0x007ff800007ff8LL, + 13, 64, 30, 0x007ffc00000000LL, + 13, 32, 30, 0x007ffc00007ffcLL, + 14, 64, 31, 0x007ffe00000000LL, + 14, 32, 31, 0x007ffe00007ffeLL, + 15, 64, 32, 0x007fff00000000LL, + 15, 32, 0, 0x007fff00007fffLL, + 16, 64, 33, 0x007fff80000000LL, + 17, 64, 34, 0x007fffc0000000LL, + 18, 64, 35, 0x007fffe0000000LL, + 19, 64, 36, 0x007ffff0000000LL, + 20, 64, 37, 0x007ffff8000000LL, + 21, 64, 38, 0x007ffffc000000LL, + 22, 64, 39, 0x007ffffe000000LL, + 23, 64, 40, 0x007fffff000000LL, + 24, 64, 41, 0x007fffff800000LL, + 25, 64, 42, 0x007fffffc00000LL, + 26, 64, 43, 0x007fffffe00000LL, + 27, 64, 44, 0x007ffffff00000LL, + 28, 64, 45, 0x007ffffff80000LL, + 29, 64, 46, 0x007ffffffc0000LL, + 30, 64, 47, 0x007ffffffe0000LL, + 31, 64, 48, 0x007fffffff0000LL, + 32, 64, 49, 0x007fffffff8000LL, + 33, 64, 50, 0x007fffffffc000LL, + 34, 64, 51, 0x007fffffffe000LL, + 35, 64, 52, 0x007ffffffff000LL, + 36, 64, 53, 0x007ffffffff800LL, + 37, 64, 54, 0x007ffffffffc00LL, + 38, 64, 55, 0x007ffffffffe00LL, + 39, 64, 56, 0x007fffffffff00LL, + 40, 64, 57, 0x007fffffffff80LL, + 41, 64, 58, 0x007fffffffffc0LL, + 42, 64, 59, 0x007fffffffffe0LL, + 43, 64, 60, 0x007ffffffffff0LL, + 44, 64, 61, 0x007ffffffffff8LL, + 45, 64, 62, 0x007ffffffffffcLL, + 46, 64, 63, 0x007ffffffffffeLL, + 47, 64, 0, 0x007fffffffffffLL, + 1, 64, 17, 0x00800000000000LL, + 1, 32, 17, 0x00800000008000LL, + 2, 64, 18, 0x00c00000000000LL, + 2, 32, 18, 0x00c0000000c000LL, + 3, 64, 19, 0x00e00000000000LL, + 3, 32, 19, 0x00e0000000e000LL, + 4, 64, 20, 0x00f00000000000LL, + 4, 32, 20, 0x00f0000000f000LL, + 5, 64, 21, 0x00f80000000000LL, + 5, 32, 21, 0x00f8000000f800LL, + 6, 64, 22, 0x00fc0000000000LL, + 6, 32, 22, 0x00fc000000fc00LL, + 7, 64, 23, 0x00fe0000000000LL, + 7, 32, 23, 0x00fe000000fe00LL, + 8, 64, 24, 0x00ff0000000000LL, + 8, 32, 24, 0x00ff000000ff00LL, + 9, 64, 25, 0x00ff8000000000LL, + 9, 32, 25, 0x00ff800000ff80LL, + 10, 64, 26, 0x00ffc000000000LL, + 10, 32, 26, 0x00ffc00000ffc0LL, + 11, 64, 27, 0x00ffe000000000LL, + 11, 32, 27, 0x00ffe00000ffe0LL, + 12, 64, 28, 0x00fff000000000LL, + 12, 32, 28, 0x00fff00000fff0LL, + 13, 64, 29, 0x00fff800000000LL, + 13, 32, 29, 0x00fff80000fff8LL, + 14, 64, 30, 0x00fffc00000000LL, + 14, 32, 30, 0x00fffc0000fffcLL, + 15, 64, 31, 0x00fffe00000000LL, + 15, 32, 31, 0x00fffe0000fffeLL, + 16, 64, 32, 0x00ffff00000000LL, + 16, 32, 0, 0x00ffff0000ffffLL, + 17, 64, 33, 0x00ffff80000000LL, + 18, 64, 34, 0x00ffffc0000000LL, + 19, 64, 35, 0x00ffffe0000000LL, + 20, 64, 36, 0x00fffff0000000LL, + 21, 64, 37, 0x00fffff8000000LL, + 22, 64, 38, 0x00fffffc000000LL, + 23, 64, 39, 0x00fffffe000000LL, + 24, 64, 40, 0x00ffffff000000LL, + 25, 64, 41, 0x00ffffff800000LL, + 26, 64, 42, 0x00ffffffc00000LL, + 27, 64, 43, 0x00ffffffe00000LL, + 28, 64, 44, 0x00fffffff00000LL, + 29, 64, 45, 0x00fffffff80000LL, + 30, 64, 46, 0x00fffffffc0000LL, + 31, 64, 47, 0x00fffffffe0000LL, + 32, 64, 48, 0x00ffffffff0000LL, + 33, 64, 49, 0x00ffffffff8000LL, + 34, 64, 50, 0x00ffffffffc000LL, + 35, 64, 51, 0x00ffffffffe000LL, + 36, 64, 52, 0x00fffffffff000LL, + 37, 64, 53, 0x00fffffffff800LL, + 38, 64, 54, 0x00fffffffffc00LL, + 39, 64, 55, 0x00fffffffffe00LL, + 40, 64, 56, 0x00ffffffffff00LL, + 41, 64, 57, 0x00ffffffffff80LL, + 42, 64, 58, 0x00ffffffffffc0LL, + 43, 64, 59, 0x00ffffffffffe0LL, + 44, 64, 60, 0x00fffffffffff0LL, + 45, 64, 61, 0x00fffffffffff8LL, + 46, 64, 62, 0x00fffffffffffcLL, + 47, 64, 63, 0x00fffffffffffeLL, + 48, 64, 0, 0x00ffffffffffffLL, + 1, 64, 16, 0x01000000000000LL, + 1, 32, 16, 0x01000000010000LL, + 1, 16, 0, 0x01000100010001LL, + 2, 64, 17, 0x01800000000000LL, + 2, 32, 17, 0x01800000018000LL, + 3, 64, 18, 0x01c00000000000LL, + 3, 32, 18, 0x01c0000001c000LL, + 4, 64, 19, 0x01e00000000000LL, + 4, 32, 19, 0x01e0000001e000LL, + 5, 64, 20, 0x01f00000000000LL, + 5, 32, 20, 0x01f0000001f000LL, + 6, 64, 21, 0x01f80000000000LL, + 6, 32, 21, 0x01f8000001f800LL, + 7, 64, 22, 0x01fc0000000000LL, + 7, 32, 22, 0x01fc000001fc00LL, + 8, 64, 23, 0x01fe0000000000LL, + 8, 32, 23, 0x01fe000001fe00LL, + 9, 64, 24, 0x01ff0000000000LL, + 9, 32, 24, 0x01ff000001ff00LL, + 10, 64, 25, 0x01ff8000000000LL, + 10, 32, 25, 0x01ff800001ff80LL, + 11, 64, 26, 0x01ffc000000000LL, + 11, 32, 26, 0x01ffc00001ffc0LL, + 12, 64, 27, 0x01ffe000000000LL, + 12, 32, 27, 0x01ffe00001ffe0LL, + 13, 64, 28, 0x01fff000000000LL, + 13, 32, 28, 0x01fff00001fff0LL, + 14, 64, 29, 0x01fff800000000LL, + 14, 32, 29, 0x01fff80001fff8LL, + 15, 64, 30, 0x01fffc00000000LL, + 15, 32, 30, 0x01fffc0001fffcLL, + 16, 64, 31, 0x01fffe00000000LL, + 16, 32, 31, 0x01fffe0001fffeLL, + 17, 64, 32, 0x01ffff00000000LL, + 17, 32, 0, 0x01ffff0001ffffLL, + 18, 64, 33, 0x01ffff80000000LL, + 19, 64, 34, 0x01ffffc0000000LL, + 20, 64, 35, 0x01ffffe0000000LL, + 21, 64, 36, 0x01fffff0000000LL, + 22, 64, 37, 0x01fffff8000000LL, + 23, 64, 38, 0x01fffffc000000LL, + 24, 64, 39, 0x01fffffe000000LL, + 25, 64, 40, 0x01ffffff000000LL, + 26, 64, 41, 0x01ffffff800000LL, + 27, 64, 42, 0x01ffffffc00000LL, + 28, 64, 43, 0x01ffffffe00000LL, + 29, 64, 44, 0x01fffffff00000LL, + 30, 64, 45, 0x01fffffff80000LL, + 31, 64, 46, 0x01fffffffc0000LL, + 32, 64, 47, 0x01fffffffe0000LL, + 33, 64, 48, 0x01ffffffff0000LL, + 34, 64, 49, 0x01ffffffff8000LL, + 35, 64, 50, 0x01ffffffffc000LL, + 36, 64, 51, 0x01ffffffffe000LL, + 37, 64, 52, 0x01fffffffff000LL, + 38, 64, 53, 0x01fffffffff800LL, + 39, 64, 54, 0x01fffffffffc00LL, + 40, 64, 55, 0x01fffffffffe00LL, + 41, 64, 56, 0x01ffffffffff00LL, + 42, 64, 57, 0x01ffffffffff80LL, + 43, 64, 58, 0x01ffffffffffc0LL, + 44, 64, 59, 0x01ffffffffffe0LL, + 45, 64, 60, 0x01fffffffffff0LL, + 46, 64, 61, 0x01fffffffffff8LL, + 47, 64, 62, 0x01fffffffffffcLL, + 48, 64, 63, 0x01fffffffffffeLL, + 49, 64, 0, 0x01ffffffffffffLL, + 1, 64, 15, 0x02000000000000LL, + 1, 32, 15, 0x02000000020000LL, + 1, 16, 15, 0x02000200020002LL, + 2, 64, 16, 0x03000000000000LL, + 2, 32, 16, 0x03000000030000LL, + 2, 16, 0, 0x03000300030003LL, + 3, 64, 17, 0x03800000000000LL, + 3, 32, 17, 0x03800000038000LL, + 4, 64, 18, 0x03c00000000000LL, + 4, 32, 18, 0x03c0000003c000LL, + 5, 64, 19, 0x03e00000000000LL, + 5, 32, 19, 0x03e0000003e000LL, + 6, 64, 20, 0x03f00000000000LL, + 6, 32, 20, 0x03f0000003f000LL, + 7, 64, 21, 0x03f80000000000LL, + 7, 32, 21, 0x03f8000003f800LL, + 8, 64, 22, 0x03fc0000000000LL, + 8, 32, 22, 0x03fc000003fc00LL, + 9, 64, 23, 0x03fe0000000000LL, + 9, 32, 23, 0x03fe000003fe00LL, + 10, 64, 24, 0x03ff0000000000LL, + 10, 32, 24, 0x03ff000003ff00LL, + 11, 64, 25, 0x03ff8000000000LL, + 11, 32, 25, 0x03ff800003ff80LL, + 12, 64, 26, 0x03ffc000000000LL, + 12, 32, 26, 0x03ffc00003ffc0LL, + 13, 64, 27, 0x03ffe000000000LL, + 13, 32, 27, 0x03ffe00003ffe0LL, + 14, 64, 28, 0x03fff000000000LL, + 14, 32, 28, 0x03fff00003fff0LL, + 15, 64, 29, 0x03fff800000000LL, + 15, 32, 29, 0x03fff80003fff8LL, + 16, 64, 30, 0x03fffc00000000LL, + 16, 32, 30, 0x03fffc0003fffcLL, + 17, 64, 31, 0x03fffe00000000LL, + 17, 32, 31, 0x03fffe0003fffeLL, + 18, 64, 32, 0x03ffff00000000LL, + 18, 32, 0, 0x03ffff0003ffffLL, + 19, 64, 33, 0x03ffff80000000LL, + 20, 64, 34, 0x03ffffc0000000LL, + 21, 64, 35, 0x03ffffe0000000LL, + 22, 64, 36, 0x03fffff0000000LL, + 23, 64, 37, 0x03fffff8000000LL, + 24, 64, 38, 0x03fffffc000000LL, + 25, 64, 39, 0x03fffffe000000LL, + 26, 64, 40, 0x03ffffff000000LL, + 27, 64, 41, 0x03ffffff800000LL, + 28, 64, 42, 0x03ffffffc00000LL, + 29, 64, 43, 0x03ffffffe00000LL, + 30, 64, 44, 0x03fffffff00000LL, + 31, 64, 45, 0x03fffffff80000LL, + 32, 64, 46, 0x03fffffffc0000LL, + 33, 64, 47, 0x03fffffffe0000LL, + 34, 64, 48, 0x03ffffffff0000LL, + 35, 64, 49, 0x03ffffffff8000LL, + 36, 64, 50, 0x03ffffffffc000LL, + 37, 64, 51, 0x03ffffffffe000LL, + 38, 64, 52, 0x03fffffffff000LL, + 39, 64, 53, 0x03fffffffff800LL, + 40, 64, 54, 0x03fffffffffc00LL, + 41, 64, 55, 0x03fffffffffe00LL, + 42, 64, 56, 0x03ffffffffff00LL, + 43, 64, 57, 0x03ffffffffff80LL, + 44, 64, 58, 0x03ffffffffffc0LL, + 45, 64, 59, 0x03ffffffffffe0LL, + 46, 64, 60, 0x03fffffffffff0LL, + 47, 64, 61, 0x03fffffffffff8LL, + 48, 64, 62, 0x03fffffffffffcLL, + 49, 64, 63, 0x03fffffffffffeLL, + 50, 64, 0, 0x03ffffffffffffLL, + 1, 64, 14, 0x04000000000000LL, + 1, 32, 14, 0x04000000040000LL, + 1, 16, 14, 0x04000400040004LL, + 2, 64, 15, 0x06000000000000LL, + 2, 32, 15, 0x06000000060000LL, + 2, 16, 15, 0x06000600060006LL, + 3, 64, 16, 0x07000000000000LL, + 3, 32, 16, 0x07000000070000LL, + 3, 16, 0, 0x07000700070007LL, + 4, 64, 17, 0x07800000000000LL, + 4, 32, 17, 0x07800000078000LL, + 5, 64, 18, 0x07c00000000000LL, + 5, 32, 18, 0x07c0000007c000LL, + 6, 64, 19, 0x07e00000000000LL, + 6, 32, 19, 0x07e0000007e000LL, + 7, 64, 20, 0x07f00000000000LL, + 7, 32, 20, 0x07f0000007f000LL, + 8, 64, 21, 0x07f80000000000LL, + 8, 32, 21, 0x07f8000007f800LL, + 9, 64, 22, 0x07fc0000000000LL, + 9, 32, 22, 0x07fc000007fc00LL, + 10, 64, 23, 0x07fe0000000000LL, + 10, 32, 23, 0x07fe000007fe00LL, + 11, 64, 24, 0x07ff0000000000LL, + 11, 32, 24, 0x07ff000007ff00LL, + 12, 64, 25, 0x07ff8000000000LL, + 12, 32, 25, 0x07ff800007ff80LL, + 13, 64, 26, 0x07ffc000000000LL, + 13, 32, 26, 0x07ffc00007ffc0LL, + 14, 64, 27, 0x07ffe000000000LL, + 14, 32, 27, 0x07ffe00007ffe0LL, + 15, 64, 28, 0x07fff000000000LL, + 15, 32, 28, 0x07fff00007fff0LL, + 16, 64, 29, 0x07fff800000000LL, + 16, 32, 29, 0x07fff80007fff8LL, + 17, 64, 30, 0x07fffc00000000LL, + 17, 32, 30, 0x07fffc0007fffcLL, + 18, 64, 31, 0x07fffe00000000LL, + 18, 32, 31, 0x07fffe0007fffeLL, + 19, 64, 32, 0x07ffff00000000LL, + 19, 32, 0, 0x07ffff0007ffffLL, + 20, 64, 33, 0x07ffff80000000LL, + 21, 64, 34, 0x07ffffc0000000LL, + 22, 64, 35, 0x07ffffe0000000LL, + 23, 64, 36, 0x07fffff0000000LL, + 24, 64, 37, 0x07fffff8000000LL, + 25, 64, 38, 0x07fffffc000000LL, + 26, 64, 39, 0x07fffffe000000LL, + 27, 64, 40, 0x07ffffff000000LL, + 28, 64, 41, 0x07ffffff800000LL, + 29, 64, 42, 0x07ffffffc00000LL, + 30, 64, 43, 0x07ffffffe00000LL, + 31, 64, 44, 0x07fffffff00000LL, + 32, 64, 45, 0x07fffffff80000LL, + 33, 64, 46, 0x07fffffffc0000LL, + 34, 64, 47, 0x07fffffffe0000LL, + 35, 64, 48, 0x07ffffffff0000LL, + 36, 64, 49, 0x07ffffffff8000LL, + 37, 64, 50, 0x07ffffffffc000LL, + 38, 64, 51, 0x07ffffffffe000LL, + 39, 64, 52, 0x07fffffffff000LL, + 40, 64, 53, 0x07fffffffff800LL, + 41, 64, 54, 0x07fffffffffc00LL, + 42, 64, 55, 0x07fffffffffe00LL, + 43, 64, 56, 0x07ffffffffff00LL, + 44, 64, 57, 0x07ffffffffff80LL, + 45, 64, 58, 0x07ffffffffffc0LL, + 46, 64, 59, 0x07ffffffffffe0LL, + 47, 64, 60, 0x07fffffffffff0LL, + 48, 64, 61, 0x07fffffffffff8LL, + 49, 64, 62, 0x07fffffffffffcLL, + 50, 64, 63, 0x07fffffffffffeLL, + 51, 64, 0, 0x07ffffffffffffLL, + 1, 64, 13, 0x08000000000000LL, + 1, 32, 13, 0x08000000080000LL, + 1, 16, 13, 0x08000800080008LL, + 2, 64, 14, 0x0c000000000000LL, + 2, 32, 14, 0x0c0000000c0000LL, + 2, 16, 14, 0x0c000c000c000cLL, + 3, 64, 15, 0x0e000000000000LL, + 3, 32, 15, 0x0e0000000e0000LL, + 3, 16, 15, 0x0e000e000e000eLL, + 4, 64, 16, 0x0f000000000000LL, + 4, 32, 16, 0x0f0000000f0000LL, + 4, 16, 0, 0x0f000f000f000fLL, + 5, 64, 17, 0x0f800000000000LL, + 5, 32, 17, 0x0f8000000f8000LL, + 6, 64, 18, 0x0fc00000000000LL, + 6, 32, 18, 0x0fc000000fc000LL, + 7, 64, 19, 0x0fe00000000000LL, + 7, 32, 19, 0x0fe000000fe000LL, + 8, 64, 20, 0x0ff00000000000LL, + 8, 32, 20, 0x0ff000000ff000LL, + 9, 64, 21, 0x0ff80000000000LL, + 9, 32, 21, 0x0ff800000ff800LL, + 10, 64, 22, 0x0ffc0000000000LL, + 10, 32, 22, 0x0ffc00000ffc00LL, + 11, 64, 23, 0x0ffe0000000000LL, + 11, 32, 23, 0x0ffe00000ffe00LL, + 12, 64, 24, 0x0fff0000000000LL, + 12, 32, 24, 0x0fff00000fff00LL, + 13, 64, 25, 0x0fff8000000000LL, + 13, 32, 25, 0x0fff80000fff80LL, + 14, 64, 26, 0x0fffc000000000LL, + 14, 32, 26, 0x0fffc0000fffc0LL, + 15, 64, 27, 0x0fffe000000000LL, + 15, 32, 27, 0x0fffe0000fffe0LL, + 16, 64, 28, 0x0ffff000000000LL, + 16, 32, 28, 0x0ffff0000ffff0LL, + 17, 64, 29, 0x0ffff800000000LL, + 17, 32, 29, 0x0ffff8000ffff8LL, + 18, 64, 30, 0x0ffffc00000000LL, + 18, 32, 30, 0x0ffffc000ffffcLL, + 19, 64, 31, 0x0ffffe00000000LL, + 19, 32, 31, 0x0ffffe000ffffeLL, + 20, 64, 32, 0x0fffff00000000LL, + 20, 32, 0, 0x0fffff000fffffLL, + 21, 64, 33, 0x0fffff80000000LL, + 22, 64, 34, 0x0fffffc0000000LL, + 23, 64, 35, 0x0fffffe0000000LL, + 24, 64, 36, 0x0ffffff0000000LL, + 25, 64, 37, 0x0ffffff8000000LL, + 26, 64, 38, 0x0ffffffc000000LL, + 27, 64, 39, 0x0ffffffe000000LL, + 28, 64, 40, 0x0fffffff000000LL, + 29, 64, 41, 0x0fffffff800000LL, + 30, 64, 42, 0x0fffffffc00000LL, + 31, 64, 43, 0x0fffffffe00000LL, + 32, 64, 44, 0x0ffffffff00000LL, + 33, 64, 45, 0x0ffffffff80000LL, + 34, 64, 46, 0x0ffffffffc0000LL, + 35, 64, 47, 0x0ffffffffe0000LL, + 36, 64, 48, 0x0fffffffff0000LL, + 37, 64, 49, 0x0fffffffff8000LL, + 38, 64, 50, 0x0fffffffffc000LL, + 39, 64, 51, 0x0fffffffffe000LL, + 40, 64, 52, 0x0ffffffffff000LL, + 41, 64, 53, 0x0ffffffffff800LL, + 42, 64, 54, 0x0ffffffffffc00LL, + 43, 64, 55, 0x0ffffffffffe00LL, + 44, 64, 56, 0x0fffffffffff00LL, + 45, 64, 57, 0x0fffffffffff80LL, + 46, 64, 58, 0x0fffffffffffc0LL, + 47, 64, 59, 0x0fffffffffffe0LL, + 48, 64, 60, 0x0ffffffffffff0LL, + 49, 64, 61, 0x0ffffffffffff8LL, + 50, 64, 62, 0x0ffffffffffffcLL, + 51, 64, 63, 0x0ffffffffffffeLL, + 52, 64, 0, 0x0fffffffffffffLL, + 1, 64, 12, 0x10000000000000LL, + 1, 32, 12, 0x10000000100000LL, + 1, 16, 12, 0x10001000100010LL, + 2, 64, 13, 0x18000000000000LL, + 2, 32, 13, 0x18000000180000LL, + 2, 16, 13, 0x18001800180018LL, + 3, 64, 14, 0x1c000000000000LL, + 3, 32, 14, 0x1c0000001c0000LL, + 3, 16, 14, 0x1c001c001c001cLL, + 4, 64, 15, 0x1e000000000000LL, + 4, 32, 15, 0x1e0000001e0000LL, + 4, 16, 15, 0x1e001e001e001eLL, + 5, 64, 16, 0x1f000000000000LL, + 5, 32, 16, 0x1f0000001f0000LL, + 5, 16, 0, 0x1f001f001f001fLL, + 6, 64, 17, 0x1f800000000000LL, + 6, 32, 17, 0x1f8000001f8000LL, + 7, 64, 18, 0x1fc00000000000LL, + 7, 32, 18, 0x1fc000001fc000LL, + 8, 64, 19, 0x1fe00000000000LL, + 8, 32, 19, 0x1fe000001fe000LL, + 9, 64, 20, 0x1ff00000000000LL, + 9, 32, 20, 0x1ff000001ff000LL, + 10, 64, 21, 0x1ff80000000000LL, + 10, 32, 21, 0x1ff800001ff800LL, + 11, 64, 22, 0x1ffc0000000000LL, + 11, 32, 22, 0x1ffc00001ffc00LL, + 12, 64, 23, 0x1ffe0000000000LL, + 12, 32, 23, 0x1ffe00001ffe00LL, + 13, 64, 24, 0x1fff0000000000LL, + 13, 32, 24, 0x1fff00001fff00LL, + 14, 64, 25, 0x1fff8000000000LL, + 14, 32, 25, 0x1fff80001fff80LL, + 15, 64, 26, 0x1fffc000000000LL, + 15, 32, 26, 0x1fffc0001fffc0LL, + 16, 64, 27, 0x1fffe000000000LL, + 16, 32, 27, 0x1fffe0001fffe0LL, + 17, 64, 28, 0x1ffff000000000LL, + 17, 32, 28, 0x1ffff0001ffff0LL, + 18, 64, 29, 0x1ffff800000000LL, + 18, 32, 29, 0x1ffff8001ffff8LL, + 19, 64, 30, 0x1ffffc00000000LL, + 19, 32, 30, 0x1ffffc001ffffcLL, + 20, 64, 31, 0x1ffffe00000000LL, + 20, 32, 31, 0x1ffffe001ffffeLL, + 21, 64, 32, 0x1fffff00000000LL, + 21, 32, 0, 0x1fffff001fffffLL, + 22, 64, 33, 0x1fffff80000000LL, + 23, 64, 34, 0x1fffffc0000000LL, + 24, 64, 35, 0x1fffffe0000000LL, + 25, 64, 36, 0x1ffffff0000000LL, + 26, 64, 37, 0x1ffffff8000000LL, + 27, 64, 38, 0x1ffffffc000000LL, + 28, 64, 39, 0x1ffffffe000000LL, + 29, 64, 40, 0x1fffffff000000LL, + 30, 64, 41, 0x1fffffff800000LL, + 31, 64, 42, 0x1fffffffc00000LL, + 32, 64, 43, 0x1fffffffe00000LL, + 33, 64, 44, 0x1ffffffff00000LL, + 34, 64, 45, 0x1ffffffff80000LL, + 35, 64, 46, 0x1ffffffffc0000LL, + 36, 64, 47, 0x1ffffffffe0000LL, + 37, 64, 48, 0x1fffffffff0000LL, + 38, 64, 49, 0x1fffffffff8000LL, + 39, 64, 50, 0x1fffffffffc000LL, + 40, 64, 51, 0x1fffffffffe000LL, + 41, 64, 52, 0x1ffffffffff000LL, + 42, 64, 53, 0x1ffffffffff800LL, + 43, 64, 54, 0x1ffffffffffc00LL, + 44, 64, 55, 0x1ffffffffffe00LL, + 45, 64, 56, 0x1fffffffffff00LL, + 46, 64, 57, 0x1fffffffffff80LL, + 47, 64, 58, 0x1fffffffffffc0LL, + 48, 64, 59, 0x1fffffffffffe0LL, + 49, 64, 60, 0x1ffffffffffff0LL, + 50, 64, 61, 0x1ffffffffffff8LL, + 51, 64, 62, 0x1ffffffffffffcLL, + 52, 64, 63, 0x1ffffffffffffeLL, + 53, 64, 0, 0x1fffffffffffffLL, + 1, 64, 11, 0x20000000000000LL, + 1, 32, 11, 0x20000000200000LL, + 1, 16, 11, 0x20002000200020LL, + 2, 64, 12, 0x30000000000000LL, + 2, 32, 12, 0x30000000300000LL, + 2, 16, 12, 0x30003000300030LL, + 3, 64, 13, 0x38000000000000LL, + 3, 32, 13, 0x38000000380000LL, + 3, 16, 13, 0x38003800380038LL, + 4, 64, 14, 0x3c000000000000LL, + 4, 32, 14, 0x3c0000003c0000LL, + 4, 16, 14, 0x3c003c003c003cLL, + 5, 64, 15, 0x3e000000000000LL, + 5, 32, 15, 0x3e0000003e0000LL, + 5, 16, 15, 0x3e003e003e003eLL, + 6, 64, 16, 0x3f000000000000LL, + 6, 32, 16, 0x3f0000003f0000LL, + 6, 16, 0, 0x3f003f003f003fLL, + 7, 64, 17, 0x3f800000000000LL, + 7, 32, 17, 0x3f8000003f8000LL, + 8, 64, 18, 0x3fc00000000000LL, + 8, 32, 18, 0x3fc000003fc000LL, + 9, 64, 19, 0x3fe00000000000LL, + 9, 32, 19, 0x3fe000003fe000LL, + 10, 64, 20, 0x3ff00000000000LL, + 10, 32, 20, 0x3ff000003ff000LL, + 11, 64, 21, 0x3ff80000000000LL, + 11, 32, 21, 0x3ff800003ff800LL, + 12, 64, 22, 0x3ffc0000000000LL, + 12, 32, 22, 0x3ffc00003ffc00LL, + 13, 64, 23, 0x3ffe0000000000LL, + 13, 32, 23, 0x3ffe00003ffe00LL, + 14, 64, 24, 0x3fff0000000000LL, + 14, 32, 24, 0x3fff00003fff00LL, + 15, 64, 25, 0x3fff8000000000LL, + 15, 32, 25, 0x3fff80003fff80LL, + 16, 64, 26, 0x3fffc000000000LL, + 16, 32, 26, 0x3fffc0003fffc0LL, + 17, 64, 27, 0x3fffe000000000LL, + 17, 32, 27, 0x3fffe0003fffe0LL, + 18, 64, 28, 0x3ffff000000000LL, + 18, 32, 28, 0x3ffff0003ffff0LL, + 19, 64, 29, 0x3ffff800000000LL, + 19, 32, 29, 0x3ffff8003ffff8LL, + 20, 64, 30, 0x3ffffc00000000LL, + 20, 32, 30, 0x3ffffc003ffffcLL, + 21, 64, 31, 0x3ffffe00000000LL, + 21, 32, 31, 0x3ffffe003ffffeLL, + 22, 64, 32, 0x3fffff00000000LL, + 22, 32, 0, 0x3fffff003fffffLL, + 23, 64, 33, 0x3fffff80000000LL, + 24, 64, 34, 0x3fffffc0000000LL, + 25, 64, 35, 0x3fffffe0000000LL, + 26, 64, 36, 0x3ffffff0000000LL, + 27, 64, 37, 0x3ffffff8000000LL, + 28, 64, 38, 0x3ffffffc000000LL, + 29, 64, 39, 0x3ffffffe000000LL, + 30, 64, 40, 0x3fffffff000000LL, + 31, 64, 41, 0x3fffffff800000LL, + 32, 64, 42, 0x3fffffffc00000LL, + 33, 64, 43, 0x3fffffffe00000LL, + 34, 64, 44, 0x3ffffffff00000LL, + 35, 64, 45, 0x3ffffffff80000LL, + 36, 64, 46, 0x3ffffffffc0000LL, + 37, 64, 47, 0x3ffffffffe0000LL, + 38, 64, 48, 0x3fffffffff0000LL, + 39, 64, 49, 0x3fffffffff8000LL, + 40, 64, 50, 0x3fffffffffc000LL, + 41, 64, 51, 0x3fffffffffe000LL, + 42, 64, 52, 0x3ffffffffff000LL, + 43, 64, 53, 0x3ffffffffff800LL, + 44, 64, 54, 0x3ffffffffffc00LL, + 45, 64, 55, 0x3ffffffffffe00LL, + 46, 64, 56, 0x3fffffffffff00LL, + 47, 64, 57, 0x3fffffffffff80LL, + 48, 64, 58, 0x3fffffffffffc0LL, + 49, 64, 59, 0x3fffffffffffe0LL, + 50, 64, 60, 0x3ffffffffffff0LL, + 51, 64, 61, 0x3ffffffffffff8LL, + 52, 64, 62, 0x3ffffffffffffcLL, + 53, 64, 63, 0x3ffffffffffffeLL, + 54, 64, 0, 0x3fffffffffffffLL, + 1, 64, 10, 0x40000000000000LL, + 1, 32, 10, 0x40000000400000LL, + 1, 16, 10, 0x40004000400040LL, + 2, 64, 11, 0x60000000000000LL, + 2, 32, 11, 0x60000000600000LL, + 2, 16, 11, 0x60006000600060LL, + 3, 64, 12, 0x70000000000000LL, + 3, 32, 12, 0x70000000700000LL, + 3, 16, 12, 0x70007000700070LL, + 4, 64, 13, 0x78000000000000LL, + 4, 32, 13, 0x78000000780000LL, + 4, 16, 13, 0x78007800780078LL, + 5, 64, 14, 0x7c000000000000LL, + 5, 32, 14, 0x7c0000007c0000LL, + 5, 16, 14, 0x7c007c007c007cLL, + 6, 64, 15, 0x7e000000000000LL, + 6, 32, 15, 0x7e0000007e0000LL, + 6, 16, 15, 0x7e007e007e007eLL, + 7, 64, 16, 0x7f000000000000LL, + 7, 32, 16, 0x7f0000007f0000LL, + 7, 16, 0, 0x7f007f007f007fLL, + 8, 64, 17, 0x7f800000000000LL, + 8, 32, 17, 0x7f8000007f8000LL, + 9, 64, 18, 0x7fc00000000000LL, + 9, 32, 18, 0x7fc000007fc000LL, + 10, 64, 19, 0x7fe00000000000LL, + 10, 32, 19, 0x7fe000007fe000LL, + 11, 64, 20, 0x7ff00000000000LL, + 11, 32, 20, 0x7ff000007ff000LL, + 12, 64, 21, 0x7ff80000000000LL, + 12, 32, 21, 0x7ff800007ff800LL, + 13, 64, 22, 0x7ffc0000000000LL, + 13, 32, 22, 0x7ffc00007ffc00LL, + 14, 64, 23, 0x7ffe0000000000LL, + 14, 32, 23, 0x7ffe00007ffe00LL, + 15, 64, 24, 0x7fff0000000000LL, + 15, 32, 24, 0x7fff00007fff00LL, + 16, 64, 25, 0x7fff8000000000LL, + 16, 32, 25, 0x7fff80007fff80LL, + 17, 64, 26, 0x7fffc000000000LL, + 17, 32, 26, 0x7fffc0007fffc0LL, + 18, 64, 27, 0x7fffe000000000LL, + 18, 32, 27, 0x7fffe0007fffe0LL, + 19, 64, 28, 0x7ffff000000000LL, + 19, 32, 28, 0x7ffff0007ffff0LL, + 20, 64, 29, 0x7ffff800000000LL, + 20, 32, 29, 0x7ffff8007ffff8LL, + 21, 64, 30, 0x7ffffc00000000LL, + 21, 32, 30, 0x7ffffc007ffffcLL, + 22, 64, 31, 0x7ffffe00000000LL, + 22, 32, 31, 0x7ffffe007ffffeLL, + 23, 64, 32, 0x7fffff00000000LL, + 23, 32, 0, 0x7fffff007fffffLL, + 24, 64, 33, 0x7fffff80000000LL, + 25, 64, 34, 0x7fffffc0000000LL, + 26, 64, 35, 0x7fffffe0000000LL, + 27, 64, 36, 0x7ffffff0000000LL, + 28, 64, 37, 0x7ffffff8000000LL, + 29, 64, 38, 0x7ffffffc000000LL, + 30, 64, 39, 0x7ffffffe000000LL, + 31, 64, 40, 0x7fffffff000000LL, + 32, 64, 41, 0x7fffffff800000LL, + 33, 64, 42, 0x7fffffffc00000LL, + 34, 64, 43, 0x7fffffffe00000LL, + 35, 64, 44, 0x7ffffffff00000LL, + 36, 64, 45, 0x7ffffffff80000LL, + 37, 64, 46, 0x7ffffffffc0000LL, + 38, 64, 47, 0x7ffffffffe0000LL, + 39, 64, 48, 0x7fffffffff0000LL, + 40, 64, 49, 0x7fffffffff8000LL, + 41, 64, 50, 0x7fffffffffc000LL, + 42, 64, 51, 0x7fffffffffe000LL, + 43, 64, 52, 0x7ffffffffff000LL, + 44, 64, 53, 0x7ffffffffff800LL, + 45, 64, 54, 0x7ffffffffffc00LL, + 46, 64, 55, 0x7ffffffffffe00LL, + 47, 64, 56, 0x7fffffffffff00LL, + 48, 64, 57, 0x7fffffffffff80LL, + 49, 64, 58, 0x7fffffffffffc0LL, + 50, 64, 59, 0x7fffffffffffe0LL, + 51, 64, 60, 0x7ffffffffffff0LL, + 52, 64, 61, 0x7ffffffffffff8LL, + 53, 64, 62, 0x7ffffffffffffcLL, + 54, 64, 63, 0x7ffffffffffffeLL, + 55, 64, 0, 0x7fffffffffffffLL, + 1, 64, 9, 0x80000000000000LL, + 1, 32, 9, 0x80000000800000LL, + 1, 16, 9, 0x80008000800080LL, + 2, 64, 10, 0xc0000000000000LL, + 2, 32, 10, 0xc0000000c00000LL, + 2, 16, 10, 0xc000c000c000c0LL, + 3, 64, 11, 0xe0000000000000LL, + 3, 32, 11, 0xe0000000e00000LL, + 3, 16, 11, 0xe000e000e000e0LL, + 4, 64, 12, 0xf0000000000000LL, + 4, 32, 12, 0xf0000000f00000LL, + 4, 16, 12, 0xf000f000f000f0LL, + 5, 64, 13, 0xf8000000000000LL, + 5, 32, 13, 0xf8000000f80000LL, + 5, 16, 13, 0xf800f800f800f8LL, + 6, 64, 14, 0xfc000000000000LL, + 6, 32, 14, 0xfc000000fc0000LL, + 6, 16, 14, 0xfc00fc00fc00fcLL, + 7, 64, 15, 0xfe000000000000LL, + 7, 32, 15, 0xfe000000fe0000LL, + 7, 16, 15, 0xfe00fe00fe00feLL, + 8, 64, 16, 0xff000000000000LL, + 8, 32, 16, 0xff000000ff0000LL, + 8, 16, 0, 0xff00ff00ff00ffLL, + 9, 64, 17, 0xff800000000000LL, + 9, 32, 17, 0xff800000ff8000LL, + 10, 64, 18, 0xffc00000000000LL, + 10, 32, 18, 0xffc00000ffc000LL, + 11, 64, 19, 0xffe00000000000LL, + 11, 32, 19, 0xffe00000ffe000LL, + 12, 64, 20, 0xfff00000000000LL, + 12, 32, 20, 0xfff00000fff000LL, + 13, 64, 21, 0xfff80000000000LL, + 13, 32, 21, 0xfff80000fff800LL, + 14, 64, 22, 0xfffc0000000000LL, + 14, 32, 22, 0xfffc0000fffc00LL, + 15, 64, 23, 0xfffe0000000000LL, + 15, 32, 23, 0xfffe0000fffe00LL, + 16, 64, 24, 0xffff0000000000LL, + 16, 32, 24, 0xffff0000ffff00LL, + 17, 64, 25, 0xffff8000000000LL, + 17, 32, 25, 0xffff8000ffff80LL, + 18, 64, 26, 0xffffc000000000LL, + 18, 32, 26, 0xffffc000ffffc0LL, + 19, 64, 27, 0xffffe000000000LL, + 19, 32, 27, 0xffffe000ffffe0LL, + 20, 64, 28, 0xfffff000000000LL, + 20, 32, 28, 0xfffff000fffff0LL, + 21, 64, 29, 0xfffff800000000LL, + 21, 32, 29, 0xfffff800fffff8LL, + 22, 64, 30, 0xfffffc00000000LL, + 22, 32, 30, 0xfffffc00fffffcLL, + 23, 64, 31, 0xfffffe00000000LL, + 23, 32, 31, 0xfffffe00fffffeLL, + 24, 64, 32, 0xffffff00000000LL, + 24, 32, 0, 0xffffff00ffffffLL, + 25, 64, 33, 0xffffff80000000LL, + 26, 64, 34, 0xffffffc0000000LL, + 27, 64, 35, 0xffffffe0000000LL, + 28, 64, 36, 0xfffffff0000000LL, + 29, 64, 37, 0xfffffff8000000LL, + 30, 64, 38, 0xfffffffc000000LL, + 31, 64, 39, 0xfffffffe000000LL, + 32, 64, 40, 0xffffffff000000LL, + 33, 64, 41, 0xffffffff800000LL, + 34, 64, 42, 0xffffffffc00000LL, + 35, 64, 43, 0xffffffffe00000LL, + 36, 64, 44, 0xfffffffff00000LL, + 37, 64, 45, 0xfffffffff80000LL, + 38, 64, 46, 0xfffffffffc0000LL, + 39, 64, 47, 0xfffffffffe0000LL, + 40, 64, 48, 0xffffffffff0000LL, + 41, 64, 49, 0xffffffffff8000LL, + 42, 64, 50, 0xffffffffffc000LL, + 43, 64, 51, 0xffffffffffe000LL, + 44, 64, 52, 0xfffffffffff000LL, + 45, 64, 53, 0xfffffffffff800LL, + 46, 64, 54, 0xfffffffffffc00LL, + 47, 64, 55, 0xfffffffffffe00LL, + 48, 64, 56, 0xffffffffffff00LL, + 49, 64, 57, 0xffffffffffff80LL, + 50, 64, 58, 0xffffffffffffc0LL, + 51, 64, 59, 0xffffffffffffe0LL, + 52, 64, 60, 0xfffffffffffff0LL, + 53, 64, 61, 0xfffffffffffff8LL, + 54, 64, 62, 0xfffffffffffffcLL, + 55, 64, 63, 0xfffffffffffffeLL, + 56, 64, 0, 0xffffffffffffffLL, + 1, 64, 8, 0x100000000000000LL, + 1, 32, 8, 0x100000001000000LL, + 1, 16, 8, 0x100010001000100LL, + 1, 8, 0, 0x101010101010101LL, + 2, 64, 9, 0x180000000000000LL, + 2, 32, 9, 0x180000001800000LL, + 2, 16, 9, 0x180018001800180LL, + 3, 64, 10, 0x1c0000000000000LL, + 3, 32, 10, 0x1c0000001c00000LL, + 3, 16, 10, 0x1c001c001c001c0LL, + 4, 64, 11, 0x1e0000000000000LL, + 4, 32, 11, 0x1e0000001e00000LL, + 4, 16, 11, 0x1e001e001e001e0LL, + 5, 64, 12, 0x1f0000000000000LL, + 5, 32, 12, 0x1f0000001f00000LL, + 5, 16, 12, 0x1f001f001f001f0LL, + 6, 64, 13, 0x1f8000000000000LL, + 6, 32, 13, 0x1f8000001f80000LL, + 6, 16, 13, 0x1f801f801f801f8LL, + 7, 64, 14, 0x1fc000000000000LL, + 7, 32, 14, 0x1fc000001fc0000LL, + 7, 16, 14, 0x1fc01fc01fc01fcLL, + 8, 64, 15, 0x1fe000000000000LL, + 8, 32, 15, 0x1fe000001fe0000LL, + 8, 16, 15, 0x1fe01fe01fe01feLL, + 9, 64, 16, 0x1ff000000000000LL, + 9, 32, 16, 0x1ff000001ff0000LL, + 9, 16, 0, 0x1ff01ff01ff01ffLL, + 10, 64, 17, 0x1ff800000000000LL, + 10, 32, 17, 0x1ff800001ff8000LL, + 11, 64, 18, 0x1ffc00000000000LL, + 11, 32, 18, 0x1ffc00001ffc000LL, + 12, 64, 19, 0x1ffe00000000000LL, + 12, 32, 19, 0x1ffe00001ffe000LL, + 13, 64, 20, 0x1fff00000000000LL, + 13, 32, 20, 0x1fff00001fff000LL, + 14, 64, 21, 0x1fff80000000000LL, + 14, 32, 21, 0x1fff80001fff800LL, + 15, 64, 22, 0x1fffc0000000000LL, + 15, 32, 22, 0x1fffc0001fffc00LL, + 16, 64, 23, 0x1fffe0000000000LL, + 16, 32, 23, 0x1fffe0001fffe00LL, + 17, 64, 24, 0x1ffff0000000000LL, + 17, 32, 24, 0x1ffff0001ffff00LL, + 18, 64, 25, 0x1ffff8000000000LL, + 18, 32, 25, 0x1ffff8001ffff80LL, + 19, 64, 26, 0x1ffffc000000000LL, + 19, 32, 26, 0x1ffffc001ffffc0LL, + 20, 64, 27, 0x1ffffe000000000LL, + 20, 32, 27, 0x1ffffe001ffffe0LL, + 21, 64, 28, 0x1fffff000000000LL, + 21, 32, 28, 0x1fffff001fffff0LL, + 22, 64, 29, 0x1fffff800000000LL, + 22, 32, 29, 0x1fffff801fffff8LL, + 23, 64, 30, 0x1fffffc00000000LL, + 23, 32, 30, 0x1fffffc01fffffcLL, + 24, 64, 31, 0x1fffffe00000000LL, + 24, 32, 31, 0x1fffffe01fffffeLL, + 25, 64, 32, 0x1ffffff00000000LL, + 25, 32, 0, 0x1ffffff01ffffffLL, + 26, 64, 33, 0x1ffffff80000000LL, + 27, 64, 34, 0x1ffffffc0000000LL, + 28, 64, 35, 0x1ffffffe0000000LL, + 29, 64, 36, 0x1fffffff0000000LL, + 30, 64, 37, 0x1fffffff8000000LL, + 31, 64, 38, 0x1fffffffc000000LL, + 32, 64, 39, 0x1fffffffe000000LL, + 33, 64, 40, 0x1ffffffff000000LL, + 34, 64, 41, 0x1ffffffff800000LL, + 35, 64, 42, 0x1ffffffffc00000LL, + 36, 64, 43, 0x1ffffffffe00000LL, + 37, 64, 44, 0x1fffffffff00000LL, + 38, 64, 45, 0x1fffffffff80000LL, + 39, 64, 46, 0x1fffffffffc0000LL, + 40, 64, 47, 0x1fffffffffe0000LL, + 41, 64, 48, 0x1ffffffffff0000LL, + 42, 64, 49, 0x1ffffffffff8000LL, + 43, 64, 50, 0x1ffffffffffc000LL, + 44, 64, 51, 0x1ffffffffffe000LL, + 45, 64, 52, 0x1fffffffffff000LL, + 46, 64, 53, 0x1fffffffffff800LL, + 47, 64, 54, 0x1fffffffffffc00LL, + 48, 64, 55, 0x1fffffffffffe00LL, + 49, 64, 56, 0x1ffffffffffff00LL, + 50, 64, 57, 0x1ffffffffffff80LL, + 51, 64, 58, 0x1ffffffffffffc0LL, + 52, 64, 59, 0x1ffffffffffffe0LL, + 53, 64, 60, 0x1fffffffffffff0LL, + 54, 64, 61, 0x1fffffffffffff8LL, + 55, 64, 62, 0x1fffffffffffffcLL, + 56, 64, 63, 0x1fffffffffffffeLL, + 57, 64, 0, 0x1ffffffffffffffLL, + 1, 64, 7, 0x200000000000000LL, + 1, 32, 7, 0x200000002000000LL, + 1, 16, 7, 0x200020002000200LL, + 1, 8, 7, 0x202020202020202LL, + 2, 64, 8, 0x300000000000000LL, + 2, 32, 8, 0x300000003000000LL, + 2, 16, 8, 0x300030003000300LL, + 2, 8, 0, 0x303030303030303LL, + 3, 64, 9, 0x380000000000000LL, + 3, 32, 9, 0x380000003800000LL, + 3, 16, 9, 0x380038003800380LL, + 4, 64, 10, 0x3c0000000000000LL, + 4, 32, 10, 0x3c0000003c00000LL, + 4, 16, 10, 0x3c003c003c003c0LL, + 5, 64, 11, 0x3e0000000000000LL, + 5, 32, 11, 0x3e0000003e00000LL, + 5, 16, 11, 0x3e003e003e003e0LL, + 6, 64, 12, 0x3f0000000000000LL, + 6, 32, 12, 0x3f0000003f00000LL, + 6, 16, 12, 0x3f003f003f003f0LL, + 7, 64, 13, 0x3f8000000000000LL, + 7, 32, 13, 0x3f8000003f80000LL, + 7, 16, 13, 0x3f803f803f803f8LL, + 8, 64, 14, 0x3fc000000000000LL, + 8, 32, 14, 0x3fc000003fc0000LL, + 8, 16, 14, 0x3fc03fc03fc03fcLL, + 9, 64, 15, 0x3fe000000000000LL, + 9, 32, 15, 0x3fe000003fe0000LL, + 9, 16, 15, 0x3fe03fe03fe03feLL, + 10, 64, 16, 0x3ff000000000000LL, + 10, 32, 16, 0x3ff000003ff0000LL, + 10, 16, 0, 0x3ff03ff03ff03ffLL, + 11, 64, 17, 0x3ff800000000000LL, + 11, 32, 17, 0x3ff800003ff8000LL, + 12, 64, 18, 0x3ffc00000000000LL, + 12, 32, 18, 0x3ffc00003ffc000LL, + 13, 64, 19, 0x3ffe00000000000LL, + 13, 32, 19, 0x3ffe00003ffe000LL, + 14, 64, 20, 0x3fff00000000000LL, + 14, 32, 20, 0x3fff00003fff000LL, + 15, 64, 21, 0x3fff80000000000LL, + 15, 32, 21, 0x3fff80003fff800LL, + 16, 64, 22, 0x3fffc0000000000LL, + 16, 32, 22, 0x3fffc0003fffc00LL, + 17, 64, 23, 0x3fffe0000000000LL, + 17, 32, 23, 0x3fffe0003fffe00LL, + 18, 64, 24, 0x3ffff0000000000LL, + 18, 32, 24, 0x3ffff0003ffff00LL, + 19, 64, 25, 0x3ffff8000000000LL, + 19, 32, 25, 0x3ffff8003ffff80LL, + 20, 64, 26, 0x3ffffc000000000LL, + 20, 32, 26, 0x3ffffc003ffffc0LL, + 21, 64, 27, 0x3ffffe000000000LL, + 21, 32, 27, 0x3ffffe003ffffe0LL, + 22, 64, 28, 0x3fffff000000000LL, + 22, 32, 28, 0x3fffff003fffff0LL, + 23, 64, 29, 0x3fffff800000000LL, + 23, 32, 29, 0x3fffff803fffff8LL, + 24, 64, 30, 0x3fffffc00000000LL, + 24, 32, 30, 0x3fffffc03fffffcLL, + 25, 64, 31, 0x3fffffe00000000LL, + 25, 32, 31, 0x3fffffe03fffffeLL, + 26, 64, 32, 0x3ffffff00000000LL, + 26, 32, 0, 0x3ffffff03ffffffLL, + 27, 64, 33, 0x3ffffff80000000LL, + 28, 64, 34, 0x3ffffffc0000000LL, + 29, 64, 35, 0x3ffffffe0000000LL, + 30, 64, 36, 0x3fffffff0000000LL, + 31, 64, 37, 0x3fffffff8000000LL, + 32, 64, 38, 0x3fffffffc000000LL, + 33, 64, 39, 0x3fffffffe000000LL, + 34, 64, 40, 0x3ffffffff000000LL, + 35, 64, 41, 0x3ffffffff800000LL, + 36, 64, 42, 0x3ffffffffc00000LL, + 37, 64, 43, 0x3ffffffffe00000LL, + 38, 64, 44, 0x3fffffffff00000LL, + 39, 64, 45, 0x3fffffffff80000LL, + 40, 64, 46, 0x3fffffffffc0000LL, + 41, 64, 47, 0x3fffffffffe0000LL, + 42, 64, 48, 0x3ffffffffff0000LL, + 43, 64, 49, 0x3ffffffffff8000LL, + 44, 64, 50, 0x3ffffffffffc000LL, + 45, 64, 51, 0x3ffffffffffe000LL, + 46, 64, 52, 0x3fffffffffff000LL, + 47, 64, 53, 0x3fffffffffff800LL, + 48, 64, 54, 0x3fffffffffffc00LL, + 49, 64, 55, 0x3fffffffffffe00LL, + 50, 64, 56, 0x3ffffffffffff00LL, + 51, 64, 57, 0x3ffffffffffff80LL, + 52, 64, 58, 0x3ffffffffffffc0LL, + 53, 64, 59, 0x3ffffffffffffe0LL, + 54, 64, 60, 0x3fffffffffffff0LL, + 55, 64, 61, 0x3fffffffffffff8LL, + 56, 64, 62, 0x3fffffffffffffcLL, + 57, 64, 63, 0x3fffffffffffffeLL, + 58, 64, 0, 0x3ffffffffffffffLL, + 1, 64, 6, 0x400000000000000LL, + 1, 32, 6, 0x400000004000000LL, + 1, 16, 6, 0x400040004000400LL, + 1, 8, 6, 0x404040404040404LL, + 2, 64, 7, 0x600000000000000LL, + 2, 32, 7, 0x600000006000000LL, + 2, 16, 7, 0x600060006000600LL, + 2, 8, 7, 0x606060606060606LL, + 3, 64, 8, 0x700000000000000LL, + 3, 32, 8, 0x700000007000000LL, + 3, 16, 8, 0x700070007000700LL, + 3, 8, 0, 0x707070707070707LL, + 4, 64, 9, 0x780000000000000LL, + 4, 32, 9, 0x780000007800000LL, + 4, 16, 9, 0x780078007800780LL, + 5, 64, 10, 0x7c0000000000000LL, + 5, 32, 10, 0x7c0000007c00000LL, + 5, 16, 10, 0x7c007c007c007c0LL, + 6, 64, 11, 0x7e0000000000000LL, + 6, 32, 11, 0x7e0000007e00000LL, + 6, 16, 11, 0x7e007e007e007e0LL, + 7, 64, 12, 0x7f0000000000000LL, + 7, 32, 12, 0x7f0000007f00000LL, + 7, 16, 12, 0x7f007f007f007f0LL, + 8, 64, 13, 0x7f8000000000000LL, + 8, 32, 13, 0x7f8000007f80000LL, + 8, 16, 13, 0x7f807f807f807f8LL, + 9, 64, 14, 0x7fc000000000000LL, + 9, 32, 14, 0x7fc000007fc0000LL, + 9, 16, 14, 0x7fc07fc07fc07fcLL, + 10, 64, 15, 0x7fe000000000000LL, + 10, 32, 15, 0x7fe000007fe0000LL, + 10, 16, 15, 0x7fe07fe07fe07feLL, + 11, 64, 16, 0x7ff000000000000LL, + 11, 32, 16, 0x7ff000007ff0000LL, + 11, 16, 0, 0x7ff07ff07ff07ffLL, + 12, 64, 17, 0x7ff800000000000LL, + 12, 32, 17, 0x7ff800007ff8000LL, + 13, 64, 18, 0x7ffc00000000000LL, + 13, 32, 18, 0x7ffc00007ffc000LL, + 14, 64, 19, 0x7ffe00000000000LL, + 14, 32, 19, 0x7ffe00007ffe000LL, + 15, 64, 20, 0x7fff00000000000LL, + 15, 32, 20, 0x7fff00007fff000LL, + 16, 64, 21, 0x7fff80000000000LL, + 16, 32, 21, 0x7fff80007fff800LL, + 17, 64, 22, 0x7fffc0000000000LL, + 17, 32, 22, 0x7fffc0007fffc00LL, + 18, 64, 23, 0x7fffe0000000000LL, + 18, 32, 23, 0x7fffe0007fffe00LL, + 19, 64, 24, 0x7ffff0000000000LL, + 19, 32, 24, 0x7ffff0007ffff00LL, + 20, 64, 25, 0x7ffff8000000000LL, + 20, 32, 25, 0x7ffff8007ffff80LL, + 21, 64, 26, 0x7ffffc000000000LL, + 21, 32, 26, 0x7ffffc007ffffc0LL, + 22, 64, 27, 0x7ffffe000000000LL, + 22, 32, 27, 0x7ffffe007ffffe0LL, + 23, 64, 28, 0x7fffff000000000LL, + 23, 32, 28, 0x7fffff007fffff0LL, + 24, 64, 29, 0x7fffff800000000LL, + 24, 32, 29, 0x7fffff807fffff8LL, + 25, 64, 30, 0x7fffffc00000000LL, + 25, 32, 30, 0x7fffffc07fffffcLL, + 26, 64, 31, 0x7fffffe00000000LL, + 26, 32, 31, 0x7fffffe07fffffeLL, + 27, 64, 32, 0x7ffffff00000000LL, + 27, 32, 0, 0x7ffffff07ffffffLL, + 28, 64, 33, 0x7ffffff80000000LL, + 29, 64, 34, 0x7ffffffc0000000LL, + 30, 64, 35, 0x7ffffffe0000000LL, + 31, 64, 36, 0x7fffffff0000000LL, + 32, 64, 37, 0x7fffffff8000000LL, + 33, 64, 38, 0x7fffffffc000000LL, + 34, 64, 39, 0x7fffffffe000000LL, + 35, 64, 40, 0x7ffffffff000000LL, + 36, 64, 41, 0x7ffffffff800000LL, + 37, 64, 42, 0x7ffffffffc00000LL, + 38, 64, 43, 0x7ffffffffe00000LL, + 39, 64, 44, 0x7fffffffff00000LL, + 40, 64, 45, 0x7fffffffff80000LL, + 41, 64, 46, 0x7fffffffffc0000LL, + 42, 64, 47, 0x7fffffffffe0000LL, + 43, 64, 48, 0x7ffffffffff0000LL, + 44, 64, 49, 0x7ffffffffff8000LL, + 45, 64, 50, 0x7ffffffffffc000LL, + 46, 64, 51, 0x7ffffffffffe000LL, + 47, 64, 52, 0x7fffffffffff000LL, + 48, 64, 53, 0x7fffffffffff800LL, + 49, 64, 54, 0x7fffffffffffc00LL, + 50, 64, 55, 0x7fffffffffffe00LL, + 51, 64, 56, 0x7ffffffffffff00LL, + 52, 64, 57, 0x7ffffffffffff80LL, + 53, 64, 58, 0x7ffffffffffffc0LL, + 54, 64, 59, 0x7ffffffffffffe0LL, + 55, 64, 60, 0x7fffffffffffff0LL, + 56, 64, 61, 0x7fffffffffffff8LL, + 57, 64, 62, 0x7fffffffffffffcLL, + 58, 64, 63, 0x7fffffffffffffeLL, + 59, 64, 0, 0x7ffffffffffffffLL, + 1, 64, 5, 0x800000000000000LL, + 1, 32, 5, 0x800000008000000LL, + 1, 16, 5, 0x800080008000800LL, + 1, 8, 5, 0x808080808080808LL, + 2, 64, 6, 0xc00000000000000LL, + 2, 32, 6, 0xc0000000c000000LL, + 2, 16, 6, 0xc000c000c000c00LL, + 2, 8, 6, 0xc0c0c0c0c0c0c0cLL, + 3, 64, 7, 0xe00000000000000LL, + 3, 32, 7, 0xe0000000e000000LL, + 3, 16, 7, 0xe000e000e000e00LL, + 3, 8, 7, 0xe0e0e0e0e0e0e0eLL, + 4, 64, 8, 0xf00000000000000LL, + 4, 32, 8, 0xf0000000f000000LL, + 4, 16, 8, 0xf000f000f000f00LL, + 4, 8, 0, 0xf0f0f0f0f0f0f0fLL, + 5, 64, 9, 0xf80000000000000LL, + 5, 32, 9, 0xf8000000f800000LL, + 5, 16, 9, 0xf800f800f800f80LL, + 6, 64, 10, 0xfc0000000000000LL, + 6, 32, 10, 0xfc000000fc00000LL, + 6, 16, 10, 0xfc00fc00fc00fc0LL, + 7, 64, 11, 0xfe0000000000000LL, + 7, 32, 11, 0xfe000000fe00000LL, + 7, 16, 11, 0xfe00fe00fe00fe0LL, + 8, 64, 12, 0xff0000000000000LL, + 8, 32, 12, 0xff000000ff00000LL, + 8, 16, 12, 0xff00ff00ff00ff0LL, + 9, 64, 13, 0xff8000000000000LL, + 9, 32, 13, 0xff800000ff80000LL, + 9, 16, 13, 0xff80ff80ff80ff8LL, + 10, 64, 14, 0xffc000000000000LL, + 10, 32, 14, 0xffc00000ffc0000LL, + 10, 16, 14, 0xffc0ffc0ffc0ffcLL, + 11, 64, 15, 0xffe000000000000LL, + 11, 32, 15, 0xffe00000ffe0000LL, + 11, 16, 15, 0xffe0ffe0ffe0ffeLL, + 12, 64, 16, 0xfff000000000000LL, + 12, 32, 16, 0xfff00000fff0000LL, + 12, 16, 0, 0xfff0fff0fff0fffLL, + 13, 64, 17, 0xfff800000000000LL, + 13, 32, 17, 0xfff80000fff8000LL, + 14, 64, 18, 0xfffc00000000000LL, + 14, 32, 18, 0xfffc0000fffc000LL, + 15, 64, 19, 0xfffe00000000000LL, + 15, 32, 19, 0xfffe0000fffe000LL, + 16, 64, 20, 0xffff00000000000LL, + 16, 32, 20, 0xffff0000ffff000LL, + 17, 64, 21, 0xffff80000000000LL, + 17, 32, 21, 0xffff8000ffff800LL, + 18, 64, 22, 0xffffc0000000000LL, + 18, 32, 22, 0xffffc000ffffc00LL, + 19, 64, 23, 0xffffe0000000000LL, + 19, 32, 23, 0xffffe000ffffe00LL, + 20, 64, 24, 0xfffff0000000000LL, + 20, 32, 24, 0xfffff000fffff00LL, + 21, 64, 25, 0xfffff8000000000LL, + 21, 32, 25, 0xfffff800fffff80LL, + 22, 64, 26, 0xfffffc000000000LL, + 22, 32, 26, 0xfffffc00fffffc0LL, + 23, 64, 27, 0xfffffe000000000LL, + 23, 32, 27, 0xfffffe00fffffe0LL, + 24, 64, 28, 0xffffff000000000LL, + 24, 32, 28, 0xffffff00ffffff0LL, + 25, 64, 29, 0xffffff800000000LL, + 25, 32, 29, 0xffffff80ffffff8LL, + 26, 64, 30, 0xffffffc00000000LL, + 26, 32, 30, 0xffffffc0ffffffcLL, + 27, 64, 31, 0xffffffe00000000LL, + 27, 32, 31, 0xffffffe0ffffffeLL, + 28, 64, 32, 0xfffffff00000000LL, + 28, 32, 0, 0xfffffff0fffffffLL, + 29, 64, 33, 0xfffffff80000000LL, + 30, 64, 34, 0xfffffffc0000000LL, + 31, 64, 35, 0xfffffffe0000000LL, + 32, 64, 36, 0xffffffff0000000LL, + 33, 64, 37, 0xffffffff8000000LL, + 34, 64, 38, 0xffffffffc000000LL, + 35, 64, 39, 0xffffffffe000000LL, + 36, 64, 40, 0xfffffffff000000LL, + 37, 64, 41, 0xfffffffff800000LL, + 38, 64, 42, 0xfffffffffc00000LL, + 39, 64, 43, 0xfffffffffe00000LL, + 40, 64, 44, 0xffffffffff00000LL, + 41, 64, 45, 0xffffffffff80000LL, + 42, 64, 46, 0xffffffffffc0000LL, + 43, 64, 47, 0xffffffffffe0000LL, + 44, 64, 48, 0xfffffffffff0000LL, + 45, 64, 49, 0xfffffffffff8000LL, + 46, 64, 50, 0xfffffffffffc000LL, + 47, 64, 51, 0xfffffffffffe000LL, + 48, 64, 52, 0xffffffffffff000LL, + 49, 64, 53, 0xffffffffffff800LL, + 50, 64, 54, 0xffffffffffffc00LL, + 51, 64, 55, 0xffffffffffffe00LL, + 52, 64, 56, 0xfffffffffffff00LL, + 53, 64, 57, 0xfffffffffffff80LL, + 54, 64, 58, 0xfffffffffffffc0LL, + 55, 64, 59, 0xfffffffffffffe0LL, + 56, 64, 60, 0xffffffffffffff0LL, + 57, 64, 61, 0xffffffffffffff8LL, + 58, 64, 62, 0xffffffffffffffcLL, + 59, 64, 63, 0xffffffffffffffeLL, + 60, 64, 0, 0xfffffffffffffffLL, + 1, 64, 4, 0x1000000000000000LL, + 1, 32, 4, 0x1000000010000000LL, + 1, 16, 4, 0x1000100010001000LL, + 1, 8, 4, 0x1010101010101010LL, + 1, 4, 0, 0x1111111111111111LL, + 2, 64, 5, 0x1800000000000000LL, + 2, 32, 5, 0x1800000018000000LL, + 2, 16, 5, 0x1800180018001800LL, + 2, 8, 5, 0x1818181818181818LL, + 3, 64, 6, 0x1c00000000000000LL, + 3, 32, 6, 0x1c0000001c000000LL, + 3, 16, 6, 0x1c001c001c001c00LL, + 3, 8, 6, 0x1c1c1c1c1c1c1c1cLL, + 4, 64, 7, 0x1e00000000000000LL, + 4, 32, 7, 0x1e0000001e000000LL, + 4, 16, 7, 0x1e001e001e001e00LL, + 4, 8, 7, 0x1e1e1e1e1e1e1e1eLL, + 5, 64, 8, 0x1f00000000000000LL, + 5, 32, 8, 0x1f0000001f000000LL, + 5, 16, 8, 0x1f001f001f001f00LL, + 5, 8, 0, 0x1f1f1f1f1f1f1f1fLL, + 6, 64, 9, 0x1f80000000000000LL, + 6, 32, 9, 0x1f8000001f800000LL, + 6, 16, 9, 0x1f801f801f801f80LL, + 7, 64, 10, 0x1fc0000000000000LL, + 7, 32, 10, 0x1fc000001fc00000LL, + 7, 16, 10, 0x1fc01fc01fc01fc0LL, + 8, 64, 11, 0x1fe0000000000000LL, + 8, 32, 11, 0x1fe000001fe00000LL, + 8, 16, 11, 0x1fe01fe01fe01fe0LL, + 9, 64, 12, 0x1ff0000000000000LL, + 9, 32, 12, 0x1ff000001ff00000LL, + 9, 16, 12, 0x1ff01ff01ff01ff0LL, + 10, 64, 13, 0x1ff8000000000000LL, + 10, 32, 13, 0x1ff800001ff80000LL, + 10, 16, 13, 0x1ff81ff81ff81ff8LL, + 11, 64, 14, 0x1ffc000000000000LL, + 11, 32, 14, 0x1ffc00001ffc0000LL, + 11, 16, 14, 0x1ffc1ffc1ffc1ffcLL, + 12, 64, 15, 0x1ffe000000000000LL, + 12, 32, 15, 0x1ffe00001ffe0000LL, + 12, 16, 15, 0x1ffe1ffe1ffe1ffeLL, + 13, 64, 16, 0x1fff000000000000LL, + 13, 32, 16, 0x1fff00001fff0000LL, + 13, 16, 0, 0x1fff1fff1fff1fffLL, + 14, 64, 17, 0x1fff800000000000LL, + 14, 32, 17, 0x1fff80001fff8000LL, + 15, 64, 18, 0x1fffc00000000000LL, + 15, 32, 18, 0x1fffc0001fffc000LL, + 16, 64, 19, 0x1fffe00000000000LL, + 16, 32, 19, 0x1fffe0001fffe000LL, + 17, 64, 20, 0x1ffff00000000000LL, + 17, 32, 20, 0x1ffff0001ffff000LL, + 18, 64, 21, 0x1ffff80000000000LL, + 18, 32, 21, 0x1ffff8001ffff800LL, + 19, 64, 22, 0x1ffffc0000000000LL, + 19, 32, 22, 0x1ffffc001ffffc00LL, + 20, 64, 23, 0x1ffffe0000000000LL, + 20, 32, 23, 0x1ffffe001ffffe00LL, + 21, 64, 24, 0x1fffff0000000000LL, + 21, 32, 24, 0x1fffff001fffff00LL, + 22, 64, 25, 0x1fffff8000000000LL, + 22, 32, 25, 0x1fffff801fffff80LL, + 23, 64, 26, 0x1fffffc000000000LL, + 23, 32, 26, 0x1fffffc01fffffc0LL, + 24, 64, 27, 0x1fffffe000000000LL, + 24, 32, 27, 0x1fffffe01fffffe0LL, + 25, 64, 28, 0x1ffffff000000000LL, + 25, 32, 28, 0x1ffffff01ffffff0LL, + 26, 64, 29, 0x1ffffff800000000LL, + 26, 32, 29, 0x1ffffff81ffffff8LL, + 27, 64, 30, 0x1ffffffc00000000LL, + 27, 32, 30, 0x1ffffffc1ffffffcLL, + 28, 64, 31, 0x1ffffffe00000000LL, + 28, 32, 31, 0x1ffffffe1ffffffeLL, + 29, 64, 32, 0x1fffffff00000000LL, + 29, 32, 0, 0x1fffffff1fffffffLL, + 30, 64, 33, 0x1fffffff80000000LL, + 31, 64, 34, 0x1fffffffc0000000LL, + 32, 64, 35, 0x1fffffffe0000000LL, + 33, 64, 36, 0x1ffffffff0000000LL, + 34, 64, 37, 0x1ffffffff8000000LL, + 35, 64, 38, 0x1ffffffffc000000LL, + 36, 64, 39, 0x1ffffffffe000000LL, + 37, 64, 40, 0x1fffffffff000000LL, + 38, 64, 41, 0x1fffffffff800000LL, + 39, 64, 42, 0x1fffffffffc00000LL, + 40, 64, 43, 0x1fffffffffe00000LL, + 41, 64, 44, 0x1ffffffffff00000LL, + 42, 64, 45, 0x1ffffffffff80000LL, + 43, 64, 46, 0x1ffffffffffc0000LL, + 44, 64, 47, 0x1ffffffffffe0000LL, + 45, 64, 48, 0x1fffffffffff0000LL, + 46, 64, 49, 0x1fffffffffff8000LL, + 47, 64, 50, 0x1fffffffffffc000LL, + 48, 64, 51, 0x1fffffffffffe000LL, + 49, 64, 52, 0x1ffffffffffff000LL, + 50, 64, 53, 0x1ffffffffffff800LL, + 51, 64, 54, 0x1ffffffffffffc00LL, + 52, 64, 55, 0x1ffffffffffffe00LL, + 53, 64, 56, 0x1fffffffffffff00LL, + 54, 64, 57, 0x1fffffffffffff80LL, + 55, 64, 58, 0x1fffffffffffffc0LL, + 56, 64, 59, 0x1fffffffffffffe0LL, + 57, 64, 60, 0x1ffffffffffffff0LL, + 58, 64, 61, 0x1ffffffffffffff8LL, + 59, 64, 62, 0x1ffffffffffffffcLL, + 60, 64, 63, 0x1ffffffffffffffeLL, + 61, 64, 0, 0x1fffffffffffffffLL, + 1, 64, 3, 0x2000000000000000LL, + 1, 32, 3, 0x2000000020000000LL, + 1, 16, 3, 0x2000200020002000LL, + 1, 8, 3, 0x2020202020202020LL, + 1, 4, 3, 0x2222222222222222LL, + 2, 64, 4, 0x3000000000000000LL, + 2, 32, 4, 0x3000000030000000LL, + 2, 16, 4, 0x3000300030003000LL, + 2, 8, 4, 0x3030303030303030LL, + 2, 4, 0, 0x3333333333333333LL, + 3, 64, 5, 0x3800000000000000LL, + 3, 32, 5, 0x3800000038000000LL, + 3, 16, 5, 0x3800380038003800LL, + 3, 8, 5, 0x3838383838383838LL, + 4, 64, 6, 0x3c00000000000000LL, + 4, 32, 6, 0x3c0000003c000000LL, + 4, 16, 6, 0x3c003c003c003c00LL, + 4, 8, 6, 0x3c3c3c3c3c3c3c3cLL, + 5, 64, 7, 0x3e00000000000000LL, + 5, 32, 7, 0x3e0000003e000000LL, + 5, 16, 7, 0x3e003e003e003e00LL, + 5, 8, 7, 0x3e3e3e3e3e3e3e3eLL, + 6, 64, 8, 0x3f00000000000000LL, + 6, 32, 8, 0x3f0000003f000000LL, + 6, 16, 8, 0x3f003f003f003f00LL, + 6, 8, 0, 0x3f3f3f3f3f3f3f3fLL, + 7, 64, 9, 0x3f80000000000000LL, + 7, 32, 9, 0x3f8000003f800000LL, + 7, 16, 9, 0x3f803f803f803f80LL, + 8, 64, 10, 0x3fc0000000000000LL, + 8, 32, 10, 0x3fc000003fc00000LL, + 8, 16, 10, 0x3fc03fc03fc03fc0LL, + 9, 64, 11, 0x3fe0000000000000LL, + 9, 32, 11, 0x3fe000003fe00000LL, + 9, 16, 11, 0x3fe03fe03fe03fe0LL, + 10, 64, 12, 0x3ff0000000000000LL, + 10, 32, 12, 0x3ff000003ff00000LL, + 10, 16, 12, 0x3ff03ff03ff03ff0LL, + 11, 64, 13, 0x3ff8000000000000LL, + 11, 32, 13, 0x3ff800003ff80000LL, + 11, 16, 13, 0x3ff83ff83ff83ff8LL, + 12, 64, 14, 0x3ffc000000000000LL, + 12, 32, 14, 0x3ffc00003ffc0000LL, + 12, 16, 14, 0x3ffc3ffc3ffc3ffcLL, + 13, 64, 15, 0x3ffe000000000000LL, + 13, 32, 15, 0x3ffe00003ffe0000LL, + 13, 16, 15, 0x3ffe3ffe3ffe3ffeLL, + 14, 64, 16, 0x3fff000000000000LL, + 14, 32, 16, 0x3fff00003fff0000LL, + 14, 16, 0, 0x3fff3fff3fff3fffLL, + 15, 64, 17, 0x3fff800000000000LL, + 15, 32, 17, 0x3fff80003fff8000LL, + 16, 64, 18, 0x3fffc00000000000LL, + 16, 32, 18, 0x3fffc0003fffc000LL, + 17, 64, 19, 0x3fffe00000000000LL, + 17, 32, 19, 0x3fffe0003fffe000LL, + 18, 64, 20, 0x3ffff00000000000LL, + 18, 32, 20, 0x3ffff0003ffff000LL, + 19, 64, 21, 0x3ffff80000000000LL, + 19, 32, 21, 0x3ffff8003ffff800LL, + 20, 64, 22, 0x3ffffc0000000000LL, + 20, 32, 22, 0x3ffffc003ffffc00LL, + 21, 64, 23, 0x3ffffe0000000000LL, + 21, 32, 23, 0x3ffffe003ffffe00LL, + 22, 64, 24, 0x3fffff0000000000LL, + 22, 32, 24, 0x3fffff003fffff00LL, + 23, 64, 25, 0x3fffff8000000000LL, + 23, 32, 25, 0x3fffff803fffff80LL, + 24, 64, 26, 0x3fffffc000000000LL, + 24, 32, 26, 0x3fffffc03fffffc0LL, + 25, 64, 27, 0x3fffffe000000000LL, + 25, 32, 27, 0x3fffffe03fffffe0LL, + 26, 64, 28, 0x3ffffff000000000LL, + 26, 32, 28, 0x3ffffff03ffffff0LL, + 27, 64, 29, 0x3ffffff800000000LL, + 27, 32, 29, 0x3ffffff83ffffff8LL, + 28, 64, 30, 0x3ffffffc00000000LL, + 28, 32, 30, 0x3ffffffc3ffffffcLL, + 29, 64, 31, 0x3ffffffe00000000LL, + 29, 32, 31, 0x3ffffffe3ffffffeLL, + 30, 64, 32, 0x3fffffff00000000LL, + 30, 32, 0, 0x3fffffff3fffffffLL, + 31, 64, 33, 0x3fffffff80000000LL, + 32, 64, 34, 0x3fffffffc0000000LL, + 33, 64, 35, 0x3fffffffe0000000LL, + 34, 64, 36, 0x3ffffffff0000000LL, + 35, 64, 37, 0x3ffffffff8000000LL, + 36, 64, 38, 0x3ffffffffc000000LL, + 37, 64, 39, 0x3ffffffffe000000LL, + 38, 64, 40, 0x3fffffffff000000LL, + 39, 64, 41, 0x3fffffffff800000LL, + 40, 64, 42, 0x3fffffffffc00000LL, + 41, 64, 43, 0x3fffffffffe00000LL, + 42, 64, 44, 0x3ffffffffff00000LL, + 43, 64, 45, 0x3ffffffffff80000LL, + 44, 64, 46, 0x3ffffffffffc0000LL, + 45, 64, 47, 0x3ffffffffffe0000LL, + 46, 64, 48, 0x3fffffffffff0000LL, + 47, 64, 49, 0x3fffffffffff8000LL, + 48, 64, 50, 0x3fffffffffffc000LL, + 49, 64, 51, 0x3fffffffffffe000LL, + 50, 64, 52, 0x3ffffffffffff000LL, + 51, 64, 53, 0x3ffffffffffff800LL, + 52, 64, 54, 0x3ffffffffffffc00LL, + 53, 64, 55, 0x3ffffffffffffe00LL, + 54, 64, 56, 0x3fffffffffffff00LL, + 55, 64, 57, 0x3fffffffffffff80LL, + 56, 64, 58, 0x3fffffffffffffc0LL, + 57, 64, 59, 0x3fffffffffffffe0LL, + 58, 64, 60, 0x3ffffffffffffff0LL, + 59, 64, 61, 0x3ffffffffffffff8LL, + 60, 64, 62, 0x3ffffffffffffffcLL, + 61, 64, 63, 0x3ffffffffffffffeLL, + 62, 64, 0, 0x3fffffffffffffffLL, + 1, 64, 2, 0x4000000000000000LL, + 1, 32, 2, 0x4000000040000000LL, + 1, 16, 2, 0x4000400040004000LL, + 1, 8, 2, 0x4040404040404040LL, + 1, 4, 2, 0x4444444444444444LL, + 1, 2, 0, 0x5555555555555555LL, + 2, 64, 3, 0x6000000000000000LL, + 2, 32, 3, 0x6000000060000000LL, + 2, 16, 3, 0x6000600060006000LL, + 2, 8, 3, 0x6060606060606060LL, + 2, 4, 3, 0x6666666666666666LL, + 3, 64, 4, 0x7000000000000000LL, + 3, 32, 4, 0x7000000070000000LL, + 3, 16, 4, 0x7000700070007000LL, + 3, 8, 4, 0x7070707070707070LL, + 3, 4, 0, 0x7777777777777777LL, + 4, 64, 5, 0x7800000000000000LL, + 4, 32, 5, 0x7800000078000000LL, + 4, 16, 5, 0x7800780078007800LL, + 4, 8, 5, 0x7878787878787878LL, + 5, 64, 6, 0x7c00000000000000LL, + 5, 32, 6, 0x7c0000007c000000LL, + 5, 16, 6, 0x7c007c007c007c00LL, + 5, 8, 6, 0x7c7c7c7c7c7c7c7cLL, + 6, 64, 7, 0x7e00000000000000LL, + 6, 32, 7, 0x7e0000007e000000LL, + 6, 16, 7, 0x7e007e007e007e00LL, + 6, 8, 7, 0x7e7e7e7e7e7e7e7eLL, + 7, 64, 8, 0x7f00000000000000LL, + 7, 32, 8, 0x7f0000007f000000LL, + 7, 16, 8, 0x7f007f007f007f00LL, + 7, 8, 0, 0x7f7f7f7f7f7f7f7fLL, + 8, 64, 9, 0x7f80000000000000LL, + 8, 32, 9, 0x7f8000007f800000LL, + 8, 16, 9, 0x7f807f807f807f80LL, + 9, 64, 10, 0x7fc0000000000000LL, + 9, 32, 10, 0x7fc000007fc00000LL, + 9, 16, 10, 0x7fc07fc07fc07fc0LL, + 10, 64, 11, 0x7fe0000000000000LL, + 10, 32, 11, 0x7fe000007fe00000LL, + 10, 16, 11, 0x7fe07fe07fe07fe0LL, + 11, 64, 12, 0x7ff0000000000000LL, + 11, 32, 12, 0x7ff000007ff00000LL, + 11, 16, 12, 0x7ff07ff07ff07ff0LL, + 12, 64, 13, 0x7ff8000000000000LL, + 12, 32, 13, 0x7ff800007ff80000LL, + 12, 16, 13, 0x7ff87ff87ff87ff8LL, + 13, 64, 14, 0x7ffc000000000000LL, + 13, 32, 14, 0x7ffc00007ffc0000LL, + 13, 16, 14, 0x7ffc7ffc7ffc7ffcLL, + 14, 64, 15, 0x7ffe000000000000LL, + 14, 32, 15, 0x7ffe00007ffe0000LL, + 14, 16, 15, 0x7ffe7ffe7ffe7ffeLL, + 15, 64, 16, 0x7fff000000000000LL, + 15, 32, 16, 0x7fff00007fff0000LL, + 15, 16, 0, 0x7fff7fff7fff7fffLL, + 16, 64, 17, 0x7fff800000000000LL, + 16, 32, 17, 0x7fff80007fff8000LL, + 17, 64, 18, 0x7fffc00000000000LL, + 17, 32, 18, 0x7fffc0007fffc000LL, + 18, 64, 19, 0x7fffe00000000000LL, + 18, 32, 19, 0x7fffe0007fffe000LL, + 19, 64, 20, 0x7ffff00000000000LL, + 19, 32, 20, 0x7ffff0007ffff000LL, + 20, 64, 21, 0x7ffff80000000000LL, + 20, 32, 21, 0x7ffff8007ffff800LL, + 21, 64, 22, 0x7ffffc0000000000LL, + 21, 32, 22, 0x7ffffc007ffffc00LL, + 22, 64, 23, 0x7ffffe0000000000LL, + 22, 32, 23, 0x7ffffe007ffffe00LL, + 23, 64, 24, 0x7fffff0000000000LL, + 23, 32, 24, 0x7fffff007fffff00LL, + 24, 64, 25, 0x7fffff8000000000LL, + 24, 32, 25, 0x7fffff807fffff80LL, + 25, 64, 26, 0x7fffffc000000000LL, + 25, 32, 26, 0x7fffffc07fffffc0LL, + 26, 64, 27, 0x7fffffe000000000LL, + 26, 32, 27, 0x7fffffe07fffffe0LL, + 27, 64, 28, 0x7ffffff000000000LL, + 27, 32, 28, 0x7ffffff07ffffff0LL, + 28, 64, 29, 0x7ffffff800000000LL, + 28, 32, 29, 0x7ffffff87ffffff8LL, + 29, 64, 30, 0x7ffffffc00000000LL, + 29, 32, 30, 0x7ffffffc7ffffffcLL, + 30, 64, 31, 0x7ffffffe00000000LL, + 30, 32, 31, 0x7ffffffe7ffffffeLL, + 31, 64, 32, 0x7fffffff00000000LL, + 31, 32, 0, 0x7fffffff7fffffffLL, + 32, 64, 33, 0x7fffffff80000000LL, + 33, 64, 34, 0x7fffffffc0000000LL, + 34, 64, 35, 0x7fffffffe0000000LL, + 35, 64, 36, 0x7ffffffff0000000LL, + 36, 64, 37, 0x7ffffffff8000000LL, + 37, 64, 38, 0x7ffffffffc000000LL, + 38, 64, 39, 0x7ffffffffe000000LL, + 39, 64, 40, 0x7fffffffff000000LL, + 40, 64, 41, 0x7fffffffff800000LL, + 41, 64, 42, 0x7fffffffffc00000LL, + 42, 64, 43, 0x7fffffffffe00000LL, + 43, 64, 44, 0x7ffffffffff00000LL, + 44, 64, 45, 0x7ffffffffff80000LL, + 45, 64, 46, 0x7ffffffffffc0000LL, + 46, 64, 47, 0x7ffffffffffe0000LL, + 47, 64, 48, 0x7fffffffffff0000LL, + 48, 64, 49, 0x7fffffffffff8000LL, + 49, 64, 50, 0x7fffffffffffc000LL, + 50, 64, 51, 0x7fffffffffffe000LL, + 51, 64, 52, 0x7ffffffffffff000LL, + 52, 64, 53, 0x7ffffffffffff800LL, + 53, 64, 54, 0x7ffffffffffffc00LL, + 54, 64, 55, 0x7ffffffffffffe00LL, + 55, 64, 56, 0x7fffffffffffff00LL, + 56, 64, 57, 0x7fffffffffffff80LL, + 57, 64, 58, 0x7fffffffffffffc0LL, + 58, 64, 59, 0x7fffffffffffffe0LL, + 59, 64, 60, 0x7ffffffffffffff0LL, + 60, 64, 61, 0x7ffffffffffffff8LL, + 61, 64, 62, 0x7ffffffffffffffcLL, + 62, 64, 63, 0x7ffffffffffffffeLL, + 63, 64, 0, 0x7fffffffffffffffLL, + 1, 64, 1, 0x8000000000000000LL, + 2, 64, 1, 0x8000000000000001LL, + 3, 64, 1, 0x8000000000000003LL, + 4, 64, 1, 0x8000000000000007LL, + 5, 64, 1, 0x800000000000000fLL, + 6, 64, 1, 0x800000000000001fLL, + 7, 64, 1, 0x800000000000003fLL, + 8, 64, 1, 0x800000000000007fLL, + 9, 64, 1, 0x80000000000000ffLL, + 10, 64, 1, 0x80000000000001ffLL, + 11, 64, 1, 0x80000000000003ffLL, + 12, 64, 1, 0x80000000000007ffLL, + 13, 64, 1, 0x8000000000000fffLL, + 14, 64, 1, 0x8000000000001fffLL, + 15, 64, 1, 0x8000000000003fffLL, + 16, 64, 1, 0x8000000000007fffLL, + 17, 64, 1, 0x800000000000ffffLL, + 18, 64, 1, 0x800000000001ffffLL, + 19, 64, 1, 0x800000000003ffffLL, + 20, 64, 1, 0x800000000007ffffLL, + 21, 64, 1, 0x80000000000fffffLL, + 22, 64, 1, 0x80000000001fffffLL, + 23, 64, 1, 0x80000000003fffffLL, + 24, 64, 1, 0x80000000007fffffLL, + 25, 64, 1, 0x8000000000ffffffLL, + 26, 64, 1, 0x8000000001ffffffLL, + 27, 64, 1, 0x8000000003ffffffLL, + 28, 64, 1, 0x8000000007ffffffLL, + 29, 64, 1, 0x800000000fffffffLL, + 30, 64, 1, 0x800000001fffffffLL, + 31, 64, 1, 0x800000003fffffffLL, + 32, 64, 1, 0x800000007fffffffLL, + 1, 32, 1, 0x8000000080000000LL, + 33, 64, 1, 0x80000000ffffffffLL, + 2, 32, 1, 0x8000000180000001LL, + 34, 64, 1, 0x80000001ffffffffLL, + 3, 32, 1, 0x8000000380000003LL, + 35, 64, 1, 0x80000003ffffffffLL, + 4, 32, 1, 0x8000000780000007LL, + 36, 64, 1, 0x80000007ffffffffLL, + 5, 32, 1, 0x8000000f8000000fLL, + 37, 64, 1, 0x8000000fffffffffLL, + 6, 32, 1, 0x8000001f8000001fLL, + 38, 64, 1, 0x8000001fffffffffLL, + 7, 32, 1, 0x8000003f8000003fLL, + 39, 64, 1, 0x8000003fffffffffLL, + 8, 32, 1, 0x8000007f8000007fLL, + 40, 64, 1, 0x8000007fffffffffLL, + 9, 32, 1, 0x800000ff800000ffLL, + 41, 64, 1, 0x800000ffffffffffLL, + 10, 32, 1, 0x800001ff800001ffLL, + 42, 64, 1, 0x800001ffffffffffLL, + 11, 32, 1, 0x800003ff800003ffLL, + 43, 64, 1, 0x800003ffffffffffLL, + 12, 32, 1, 0x800007ff800007ffLL, + 44, 64, 1, 0x800007ffffffffffLL, + 13, 32, 1, 0x80000fff80000fffLL, + 45, 64, 1, 0x80000fffffffffffLL, + 14, 32, 1, 0x80001fff80001fffLL, + 46, 64, 1, 0x80001fffffffffffLL, + 15, 32, 1, 0x80003fff80003fffLL, + 47, 64, 1, 0x80003fffffffffffLL, + 16, 32, 1, 0x80007fff80007fffLL, + 48, 64, 1, 0x80007fffffffffffLL, + 1, 16, 1, 0x8000800080008000LL, + 17, 32, 1, 0x8000ffff8000ffffLL, + 49, 64, 1, 0x8000ffffffffffffLL, + 2, 16, 1, 0x8001800180018001LL, + 18, 32, 1, 0x8001ffff8001ffffLL, + 50, 64, 1, 0x8001ffffffffffffLL, + 3, 16, 1, 0x8003800380038003LL, + 19, 32, 1, 0x8003ffff8003ffffLL, + 51, 64, 1, 0x8003ffffffffffffLL, + 4, 16, 1, 0x8007800780078007LL, + 20, 32, 1, 0x8007ffff8007ffffLL, + 52, 64, 1, 0x8007ffffffffffffLL, + 5, 16, 1, 0x800f800f800f800fLL, + 21, 32, 1, 0x800fffff800fffffLL, + 53, 64, 1, 0x800fffffffffffffLL, + 6, 16, 1, 0x801f801f801f801fLL, + 22, 32, 1, 0x801fffff801fffffLL, + 54, 64, 1, 0x801fffffffffffffLL, + 7, 16, 1, 0x803f803f803f803fLL, + 23, 32, 1, 0x803fffff803fffffLL, + 55, 64, 1, 0x803fffffffffffffLL, + 8, 16, 1, 0x807f807f807f807fLL, + 24, 32, 1, 0x807fffff807fffffLL, + 56, 64, 1, 0x807fffffffffffffLL, + 1, 8, 1, 0x8080808080808080LL, + 9, 16, 1, 0x80ff80ff80ff80ffLL, + 25, 32, 1, 0x80ffffff80ffffffLL, + 57, 64, 1, 0x80ffffffffffffffLL, + 2, 8, 1, 0x8181818181818181LL, + 10, 16, 1, 0x81ff81ff81ff81ffLL, + 26, 32, 1, 0x81ffffff81ffffffLL, + 58, 64, 1, 0x81ffffffffffffffLL, + 3, 8, 1, 0x8383838383838383LL, + 11, 16, 1, 0x83ff83ff83ff83ffLL, + 27, 32, 1, 0x83ffffff83ffffffLL, + 59, 64, 1, 0x83ffffffffffffffLL, + 4, 8, 1, 0x8787878787878787LL, + 12, 16, 1, 0x87ff87ff87ff87ffLL, + 28, 32, 1, 0x87ffffff87ffffffLL, + 60, 64, 1, 0x87ffffffffffffffLL, + 1, 4, 1, 0x8888888888888888LL, + 5, 8, 1, 0x8f8f8f8f8f8f8f8fLL, + 13, 16, 1, 0x8fff8fff8fff8fffLL, + 29, 32, 1, 0x8fffffff8fffffffLL, + 61, 64, 1, 0x8fffffffffffffffLL, + 2, 4, 1, 0x9999999999999999LL, + 6, 8, 1, 0x9f9f9f9f9f9f9f9fLL, + 14, 16, 1, 0x9fff9fff9fff9fffLL, + 30, 32, 1, 0x9fffffff9fffffffLL, + 62, 64, 1, 0x9fffffffffffffffLL, + 1, 2, 1, 0xaaaaaaaaaaaaaaaaLL, + 3, 4, 1, 0xbbbbbbbbbbbbbbbbLL, + 7, 8, 1, 0xbfbfbfbfbfbfbfbfLL, + 15, 16, 1, 0xbfffbfffbfffbfffLL, + 31, 32, 1, 0xbfffffffbfffffffLL, + 63, 64, 1, 0xbfffffffffffffffLL, + 2, 64, 2, 0xc000000000000000LL, + 3, 64, 2, 0xc000000000000001LL, + 4, 64, 2, 0xc000000000000003LL, + 5, 64, 2, 0xc000000000000007LL, + 6, 64, 2, 0xc00000000000000fLL, + 7, 64, 2, 0xc00000000000001fLL, + 8, 64, 2, 0xc00000000000003fLL, + 9, 64, 2, 0xc00000000000007fLL, + 10, 64, 2, 0xc0000000000000ffLL, + 11, 64, 2, 0xc0000000000001ffLL, + 12, 64, 2, 0xc0000000000003ffLL, + 13, 64, 2, 0xc0000000000007ffLL, + 14, 64, 2, 0xc000000000000fffLL, + 15, 64, 2, 0xc000000000001fffLL, + 16, 64, 2, 0xc000000000003fffLL, + 17, 64, 2, 0xc000000000007fffLL, + 18, 64, 2, 0xc00000000000ffffLL, + 19, 64, 2, 0xc00000000001ffffLL, + 20, 64, 2, 0xc00000000003ffffLL, + 21, 64, 2, 0xc00000000007ffffLL, + 22, 64, 2, 0xc0000000000fffffLL, + 23, 64, 2, 0xc0000000001fffffLL, + 24, 64, 2, 0xc0000000003fffffLL, + 25, 64, 2, 0xc0000000007fffffLL, + 26, 64, 2, 0xc000000000ffffffLL, + 27, 64, 2, 0xc000000001ffffffLL, + 28, 64, 2, 0xc000000003ffffffLL, + 29, 64, 2, 0xc000000007ffffffLL, + 30, 64, 2, 0xc00000000fffffffLL, + 31, 64, 2, 0xc00000001fffffffLL, + 32, 64, 2, 0xc00000003fffffffLL, + 33, 64, 2, 0xc00000007fffffffLL, + 2, 32, 2, 0xc0000000c0000000LL, + 34, 64, 2, 0xc0000000ffffffffLL, + 3, 32, 2, 0xc0000001c0000001LL, + 35, 64, 2, 0xc0000001ffffffffLL, + 4, 32, 2, 0xc0000003c0000003LL, + 36, 64, 2, 0xc0000003ffffffffLL, + 5, 32, 2, 0xc0000007c0000007LL, + 37, 64, 2, 0xc0000007ffffffffLL, + 6, 32, 2, 0xc000000fc000000fLL, + 38, 64, 2, 0xc000000fffffffffLL, + 7, 32, 2, 0xc000001fc000001fLL, + 39, 64, 2, 0xc000001fffffffffLL, + 8, 32, 2, 0xc000003fc000003fLL, + 40, 64, 2, 0xc000003fffffffffLL, + 9, 32, 2, 0xc000007fc000007fLL, + 41, 64, 2, 0xc000007fffffffffLL, + 10, 32, 2, 0xc00000ffc00000ffLL, + 42, 64, 2, 0xc00000ffffffffffLL, + 11, 32, 2, 0xc00001ffc00001ffLL, + 43, 64, 2, 0xc00001ffffffffffLL, + 12, 32, 2, 0xc00003ffc00003ffLL, + 44, 64, 2, 0xc00003ffffffffffLL, + 13, 32, 2, 0xc00007ffc00007ffLL, + 45, 64, 2, 0xc00007ffffffffffLL, + 14, 32, 2, 0xc0000fffc0000fffLL, + 46, 64, 2, 0xc0000fffffffffffLL, + 15, 32, 2, 0xc0001fffc0001fffLL, + 47, 64, 2, 0xc0001fffffffffffLL, + 16, 32, 2, 0xc0003fffc0003fffLL, + 48, 64, 2, 0xc0003fffffffffffLL, + 17, 32, 2, 0xc0007fffc0007fffLL, + 49, 64, 2, 0xc0007fffffffffffLL, + 2, 16, 2, 0xc000c000c000c000LL, + 18, 32, 2, 0xc000ffffc000ffffLL, + 50, 64, 2, 0xc000ffffffffffffLL, + 3, 16, 2, 0xc001c001c001c001LL, + 19, 32, 2, 0xc001ffffc001ffffLL, + 51, 64, 2, 0xc001ffffffffffffLL, + 4, 16, 2, 0xc003c003c003c003LL, + 20, 32, 2, 0xc003ffffc003ffffLL, + 52, 64, 2, 0xc003ffffffffffffLL, + 5, 16, 2, 0xc007c007c007c007LL, + 21, 32, 2, 0xc007ffffc007ffffLL, + 53, 64, 2, 0xc007ffffffffffffLL, + 6, 16, 2, 0xc00fc00fc00fc00fLL, + 22, 32, 2, 0xc00fffffc00fffffLL, + 54, 64, 2, 0xc00fffffffffffffLL, + 7, 16, 2, 0xc01fc01fc01fc01fLL, + 23, 32, 2, 0xc01fffffc01fffffLL, + 55, 64, 2, 0xc01fffffffffffffLL, + 8, 16, 2, 0xc03fc03fc03fc03fLL, + 24, 32, 2, 0xc03fffffc03fffffLL, + 56, 64, 2, 0xc03fffffffffffffLL, + 9, 16, 2, 0xc07fc07fc07fc07fLL, + 25, 32, 2, 0xc07fffffc07fffffLL, + 57, 64, 2, 0xc07fffffffffffffLL, + 2, 8, 2, 0xc0c0c0c0c0c0c0c0LL, + 10, 16, 2, 0xc0ffc0ffc0ffc0ffLL, + 26, 32, 2, 0xc0ffffffc0ffffffLL, + 58, 64, 2, 0xc0ffffffffffffffLL, + 3, 8, 2, 0xc1c1c1c1c1c1c1c1LL, + 11, 16, 2, 0xc1ffc1ffc1ffc1ffLL, + 27, 32, 2, 0xc1ffffffc1ffffffLL, + 59, 64, 2, 0xc1ffffffffffffffLL, + 4, 8, 2, 0xc3c3c3c3c3c3c3c3LL, + 12, 16, 2, 0xc3ffc3ffc3ffc3ffLL, + 28, 32, 2, 0xc3ffffffc3ffffffLL, + 60, 64, 2, 0xc3ffffffffffffffLL, + 5, 8, 2, 0xc7c7c7c7c7c7c7c7LL, + 13, 16, 2, 0xc7ffc7ffc7ffc7ffLL, + 29, 32, 2, 0xc7ffffffc7ffffffLL, + 61, 64, 2, 0xc7ffffffffffffffLL, + 2, 4, 2, 0xccccccccccccccccLL, + 6, 8, 2, 0xcfcfcfcfcfcfcfcfLL, + 14, 16, 2, 0xcfffcfffcfffcfffLL, + 30, 32, 2, 0xcfffffffcfffffffLL, + 62, 64, 2, 0xcfffffffffffffffLL, + 3, 4, 2, 0xddddddddddddddddLL, + 7, 8, 2, 0xdfdfdfdfdfdfdfdfLL, + 15, 16, 2, 0xdfffdfffdfffdfffLL, + 31, 32, 2, 0xdfffffffdfffffffLL, + 63, 64, 2, 0xdfffffffffffffffLL, + 3, 64, 3, 0xe000000000000000LL, + 4, 64, 3, 0xe000000000000001LL, + 5, 64, 3, 0xe000000000000003LL, + 6, 64, 3, 0xe000000000000007LL, + 7, 64, 3, 0xe00000000000000fLL, + 8, 64, 3, 0xe00000000000001fLL, + 9, 64, 3, 0xe00000000000003fLL, + 10, 64, 3, 0xe00000000000007fLL, + 11, 64, 3, 0xe0000000000000ffLL, + 12, 64, 3, 0xe0000000000001ffLL, + 13, 64, 3, 0xe0000000000003ffLL, + 14, 64, 3, 0xe0000000000007ffLL, + 15, 64, 3, 0xe000000000000fffLL, + 16, 64, 3, 0xe000000000001fffLL, + 17, 64, 3, 0xe000000000003fffLL, + 18, 64, 3, 0xe000000000007fffLL, + 19, 64, 3, 0xe00000000000ffffLL, + 20, 64, 3, 0xe00000000001ffffLL, + 21, 64, 3, 0xe00000000003ffffLL, + 22, 64, 3, 0xe00000000007ffffLL, + 23, 64, 3, 0xe0000000000fffffLL, + 24, 64, 3, 0xe0000000001fffffLL, + 25, 64, 3, 0xe0000000003fffffLL, + 26, 64, 3, 0xe0000000007fffffLL, + 27, 64, 3, 0xe000000000ffffffLL, + 28, 64, 3, 0xe000000001ffffffLL, + 29, 64, 3, 0xe000000003ffffffLL, + 30, 64, 3, 0xe000000007ffffffLL, + 31, 64, 3, 0xe00000000fffffffLL, + 32, 64, 3, 0xe00000001fffffffLL, + 33, 64, 3, 0xe00000003fffffffLL, + 34, 64, 3, 0xe00000007fffffffLL, + 3, 32, 3, 0xe0000000e0000000LL, + 35, 64, 3, 0xe0000000ffffffffLL, + 4, 32, 3, 0xe0000001e0000001LL, + 36, 64, 3, 0xe0000001ffffffffLL, + 5, 32, 3, 0xe0000003e0000003LL, + 37, 64, 3, 0xe0000003ffffffffLL, + 6, 32, 3, 0xe0000007e0000007LL, + 38, 64, 3, 0xe0000007ffffffffLL, + 7, 32, 3, 0xe000000fe000000fLL, + 39, 64, 3, 0xe000000fffffffffLL, + 8, 32, 3, 0xe000001fe000001fLL, + 40, 64, 3, 0xe000001fffffffffLL, + 9, 32, 3, 0xe000003fe000003fLL, + 41, 64, 3, 0xe000003fffffffffLL, + 10, 32, 3, 0xe000007fe000007fLL, + 42, 64, 3, 0xe000007fffffffffLL, + 11, 32, 3, 0xe00000ffe00000ffLL, + 43, 64, 3, 0xe00000ffffffffffLL, + 12, 32, 3, 0xe00001ffe00001ffLL, + 44, 64, 3, 0xe00001ffffffffffLL, + 13, 32, 3, 0xe00003ffe00003ffLL, + 45, 64, 3, 0xe00003ffffffffffLL, + 14, 32, 3, 0xe00007ffe00007ffLL, + 46, 64, 3, 0xe00007ffffffffffLL, + 15, 32, 3, 0xe0000fffe0000fffLL, + 47, 64, 3, 0xe0000fffffffffffLL, + 16, 32, 3, 0xe0001fffe0001fffLL, + 48, 64, 3, 0xe0001fffffffffffLL, + 17, 32, 3, 0xe0003fffe0003fffLL, + 49, 64, 3, 0xe0003fffffffffffLL, + 18, 32, 3, 0xe0007fffe0007fffLL, + 50, 64, 3, 0xe0007fffffffffffLL, + 3, 16, 3, 0xe000e000e000e000LL, + 19, 32, 3, 0xe000ffffe000ffffLL, + 51, 64, 3, 0xe000ffffffffffffLL, + 4, 16, 3, 0xe001e001e001e001LL, + 20, 32, 3, 0xe001ffffe001ffffLL, + 52, 64, 3, 0xe001ffffffffffffLL, + 5, 16, 3, 0xe003e003e003e003LL, + 21, 32, 3, 0xe003ffffe003ffffLL, + 53, 64, 3, 0xe003ffffffffffffLL, + 6, 16, 3, 0xe007e007e007e007LL, + 22, 32, 3, 0xe007ffffe007ffffLL, + 54, 64, 3, 0xe007ffffffffffffLL, + 7, 16, 3, 0xe00fe00fe00fe00fLL, + 23, 32, 3, 0xe00fffffe00fffffLL, + 55, 64, 3, 0xe00fffffffffffffLL, + 8, 16, 3, 0xe01fe01fe01fe01fLL, + 24, 32, 3, 0xe01fffffe01fffffLL, + 56, 64, 3, 0xe01fffffffffffffLL, + 9, 16, 3, 0xe03fe03fe03fe03fLL, + 25, 32, 3, 0xe03fffffe03fffffLL, + 57, 64, 3, 0xe03fffffffffffffLL, + 10, 16, 3, 0xe07fe07fe07fe07fLL, + 26, 32, 3, 0xe07fffffe07fffffLL, + 58, 64, 3, 0xe07fffffffffffffLL, + 3, 8, 3, 0xe0e0e0e0e0e0e0e0LL, + 11, 16, 3, 0xe0ffe0ffe0ffe0ffLL, + 27, 32, 3, 0xe0ffffffe0ffffffLL, + 59, 64, 3, 0xe0ffffffffffffffLL, + 4, 8, 3, 0xe1e1e1e1e1e1e1e1LL, + 12, 16, 3, 0xe1ffe1ffe1ffe1ffLL, + 28, 32, 3, 0xe1ffffffe1ffffffLL, + 60, 64, 3, 0xe1ffffffffffffffLL, + 5, 8, 3, 0xe3e3e3e3e3e3e3e3LL, + 13, 16, 3, 0xe3ffe3ffe3ffe3ffLL, + 29, 32, 3, 0xe3ffffffe3ffffffLL, + 61, 64, 3, 0xe3ffffffffffffffLL, + 6, 8, 3, 0xe7e7e7e7e7e7e7e7LL, + 14, 16, 3, 0xe7ffe7ffe7ffe7ffLL, + 30, 32, 3, 0xe7ffffffe7ffffffLL, + 62, 64, 3, 0xe7ffffffffffffffLL, + 3, 4, 3, 0xeeeeeeeeeeeeeeeeLL, + 7, 8, 3, 0xefefefefefefefefLL, + 15, 16, 3, 0xefffefffefffefffLL, + 31, 32, 3, 0xefffffffefffffffLL, + 63, 64, 3, 0xefffffffffffffffLL, + 4, 64, 4, 0xf000000000000000LL, + 5, 64, 4, 0xf000000000000001LL, + 6, 64, 4, 0xf000000000000003LL, + 7, 64, 4, 0xf000000000000007LL, + 8, 64, 4, 0xf00000000000000fLL, + 9, 64, 4, 0xf00000000000001fLL, + 10, 64, 4, 0xf00000000000003fLL, + 11, 64, 4, 0xf00000000000007fLL, + 12, 64, 4, 0xf0000000000000ffLL, + 13, 64, 4, 0xf0000000000001ffLL, + 14, 64, 4, 0xf0000000000003ffLL, + 15, 64, 4, 0xf0000000000007ffLL, + 16, 64, 4, 0xf000000000000fffLL, + 17, 64, 4, 0xf000000000001fffLL, + 18, 64, 4, 0xf000000000003fffLL, + 19, 64, 4, 0xf000000000007fffLL, + 20, 64, 4, 0xf00000000000ffffLL, + 21, 64, 4, 0xf00000000001ffffLL, + 22, 64, 4, 0xf00000000003ffffLL, + 23, 64, 4, 0xf00000000007ffffLL, + 24, 64, 4, 0xf0000000000fffffLL, + 25, 64, 4, 0xf0000000001fffffLL, + 26, 64, 4, 0xf0000000003fffffLL, + 27, 64, 4, 0xf0000000007fffffLL, + 28, 64, 4, 0xf000000000ffffffLL, + 29, 64, 4, 0xf000000001ffffffLL, + 30, 64, 4, 0xf000000003ffffffLL, + 31, 64, 4, 0xf000000007ffffffLL, + 32, 64, 4, 0xf00000000fffffffLL, + 33, 64, 4, 0xf00000001fffffffLL, + 34, 64, 4, 0xf00000003fffffffLL, + 35, 64, 4, 0xf00000007fffffffLL, + 4, 32, 4, 0xf0000000f0000000LL, + 36, 64, 4, 0xf0000000ffffffffLL, + 5, 32, 4, 0xf0000001f0000001LL, + 37, 64, 4, 0xf0000001ffffffffLL, + 6, 32, 4, 0xf0000003f0000003LL, + 38, 64, 4, 0xf0000003ffffffffLL, + 7, 32, 4, 0xf0000007f0000007LL, + 39, 64, 4, 0xf0000007ffffffffLL, + 8, 32, 4, 0xf000000ff000000fLL, + 40, 64, 4, 0xf000000fffffffffLL, + 9, 32, 4, 0xf000001ff000001fLL, + 41, 64, 4, 0xf000001fffffffffLL, + 10, 32, 4, 0xf000003ff000003fLL, + 42, 64, 4, 0xf000003fffffffffLL, + 11, 32, 4, 0xf000007ff000007fLL, + 43, 64, 4, 0xf000007fffffffffLL, + 12, 32, 4, 0xf00000fff00000ffLL, + 44, 64, 4, 0xf00000ffffffffffLL, + 13, 32, 4, 0xf00001fff00001ffLL, + 45, 64, 4, 0xf00001ffffffffffLL, + 14, 32, 4, 0xf00003fff00003ffLL, + 46, 64, 4, 0xf00003ffffffffffLL, + 15, 32, 4, 0xf00007fff00007ffLL, + 47, 64, 4, 0xf00007ffffffffffLL, + 16, 32, 4, 0xf0000ffff0000fffLL, + 48, 64, 4, 0xf0000fffffffffffLL, + 17, 32, 4, 0xf0001ffff0001fffLL, + 49, 64, 4, 0xf0001fffffffffffLL, + 18, 32, 4, 0xf0003ffff0003fffLL, + 50, 64, 4, 0xf0003fffffffffffLL, + 19, 32, 4, 0xf0007ffff0007fffLL, + 51, 64, 4, 0xf0007fffffffffffLL, + 4, 16, 4, 0xf000f000f000f000LL, + 20, 32, 4, 0xf000fffff000ffffLL, + 52, 64, 4, 0xf000ffffffffffffLL, + 5, 16, 4, 0xf001f001f001f001LL, + 21, 32, 4, 0xf001fffff001ffffLL, + 53, 64, 4, 0xf001ffffffffffffLL, + 6, 16, 4, 0xf003f003f003f003LL, + 22, 32, 4, 0xf003fffff003ffffLL, + 54, 64, 4, 0xf003ffffffffffffLL, + 7, 16, 4, 0xf007f007f007f007LL, + 23, 32, 4, 0xf007fffff007ffffLL, + 55, 64, 4, 0xf007ffffffffffffLL, + 8, 16, 4, 0xf00ff00ff00ff00fLL, + 24, 32, 4, 0xf00ffffff00fffffLL, + 56, 64, 4, 0xf00fffffffffffffLL, + 9, 16, 4, 0xf01ff01ff01ff01fLL, + 25, 32, 4, 0xf01ffffff01fffffLL, + 57, 64, 4, 0xf01fffffffffffffLL, + 10, 16, 4, 0xf03ff03ff03ff03fLL, + 26, 32, 4, 0xf03ffffff03fffffLL, + 58, 64, 4, 0xf03fffffffffffffLL, + 11, 16, 4, 0xf07ff07ff07ff07fLL, + 27, 32, 4, 0xf07ffffff07fffffLL, + 59, 64, 4, 0xf07fffffffffffffLL, + 4, 8, 4, 0xf0f0f0f0f0f0f0f0LL, + 12, 16, 4, 0xf0fff0fff0fff0ffLL, + 28, 32, 4, 0xf0fffffff0ffffffLL, + 60, 64, 4, 0xf0ffffffffffffffLL, + 5, 8, 4, 0xf1f1f1f1f1f1f1f1LL, + 13, 16, 4, 0xf1fff1fff1fff1ffLL, + 29, 32, 4, 0xf1fffffff1ffffffLL, + 61, 64, 4, 0xf1ffffffffffffffLL, + 6, 8, 4, 0xf3f3f3f3f3f3f3f3LL, + 14, 16, 4, 0xf3fff3fff3fff3ffLL, + 30, 32, 4, 0xf3fffffff3ffffffLL, + 62, 64, 4, 0xf3ffffffffffffffLL, + 7, 8, 4, 0xf7f7f7f7f7f7f7f7LL, + 15, 16, 4, 0xf7fff7fff7fff7ffLL, + 31, 32, 4, 0xf7fffffff7ffffffLL, + 63, 64, 4, 0xf7ffffffffffffffLL, + 5, 64, 5, 0xf800000000000000LL, + 6, 64, 5, 0xf800000000000001LL, + 7, 64, 5, 0xf800000000000003LL, + 8, 64, 5, 0xf800000000000007LL, + 9, 64, 5, 0xf80000000000000fLL, + 10, 64, 5, 0xf80000000000001fLL, + 11, 64, 5, 0xf80000000000003fLL, + 12, 64, 5, 0xf80000000000007fLL, + 13, 64, 5, 0xf8000000000000ffLL, + 14, 64, 5, 0xf8000000000001ffLL, + 15, 64, 5, 0xf8000000000003ffLL, + 16, 64, 5, 0xf8000000000007ffLL, + 17, 64, 5, 0xf800000000000fffLL, + 18, 64, 5, 0xf800000000001fffLL, + 19, 64, 5, 0xf800000000003fffLL, + 20, 64, 5, 0xf800000000007fffLL, + 21, 64, 5, 0xf80000000000ffffLL, + 22, 64, 5, 0xf80000000001ffffLL, + 23, 64, 5, 0xf80000000003ffffLL, + 24, 64, 5, 0xf80000000007ffffLL, + 25, 64, 5, 0xf8000000000fffffLL, + 26, 64, 5, 0xf8000000001fffffLL, + 27, 64, 5, 0xf8000000003fffffLL, + 28, 64, 5, 0xf8000000007fffffLL, + 29, 64, 5, 0xf800000000ffffffLL, + 30, 64, 5, 0xf800000001ffffffLL, + 31, 64, 5, 0xf800000003ffffffLL, + 32, 64, 5, 0xf800000007ffffffLL, + 33, 64, 5, 0xf80000000fffffffLL, + 34, 64, 5, 0xf80000001fffffffLL, + 35, 64, 5, 0xf80000003fffffffLL, + 36, 64, 5, 0xf80000007fffffffLL, + 5, 32, 5, 0xf8000000f8000000LL, + 37, 64, 5, 0xf8000000ffffffffLL, + 6, 32, 5, 0xf8000001f8000001LL, + 38, 64, 5, 0xf8000001ffffffffLL, + 7, 32, 5, 0xf8000003f8000003LL, + 39, 64, 5, 0xf8000003ffffffffLL, + 8, 32, 5, 0xf8000007f8000007LL, + 40, 64, 5, 0xf8000007ffffffffLL, + 9, 32, 5, 0xf800000ff800000fLL, + 41, 64, 5, 0xf800000fffffffffLL, + 10, 32, 5, 0xf800001ff800001fLL, + 42, 64, 5, 0xf800001fffffffffLL, + 11, 32, 5, 0xf800003ff800003fLL, + 43, 64, 5, 0xf800003fffffffffLL, + 12, 32, 5, 0xf800007ff800007fLL, + 44, 64, 5, 0xf800007fffffffffLL, + 13, 32, 5, 0xf80000fff80000ffLL, + 45, 64, 5, 0xf80000ffffffffffLL, + 14, 32, 5, 0xf80001fff80001ffLL, + 46, 64, 5, 0xf80001ffffffffffLL, + 15, 32, 5, 0xf80003fff80003ffLL, + 47, 64, 5, 0xf80003ffffffffffLL, + 16, 32, 5, 0xf80007fff80007ffLL, + 48, 64, 5, 0xf80007ffffffffffLL, + 17, 32, 5, 0xf8000ffff8000fffLL, + 49, 64, 5, 0xf8000fffffffffffLL, + 18, 32, 5, 0xf8001ffff8001fffLL, + 50, 64, 5, 0xf8001fffffffffffLL, + 19, 32, 5, 0xf8003ffff8003fffLL, + 51, 64, 5, 0xf8003fffffffffffLL, + 20, 32, 5, 0xf8007ffff8007fffLL, + 52, 64, 5, 0xf8007fffffffffffLL, + 5, 16, 5, 0xf800f800f800f800LL, + 21, 32, 5, 0xf800fffff800ffffLL, + 53, 64, 5, 0xf800ffffffffffffLL, + 6, 16, 5, 0xf801f801f801f801LL, + 22, 32, 5, 0xf801fffff801ffffLL, + 54, 64, 5, 0xf801ffffffffffffLL, + 7, 16, 5, 0xf803f803f803f803LL, + 23, 32, 5, 0xf803fffff803ffffLL, + 55, 64, 5, 0xf803ffffffffffffLL, + 8, 16, 5, 0xf807f807f807f807LL, + 24, 32, 5, 0xf807fffff807ffffLL, + 56, 64, 5, 0xf807ffffffffffffLL, + 9, 16, 5, 0xf80ff80ff80ff80fLL, + 25, 32, 5, 0xf80ffffff80fffffLL, + 57, 64, 5, 0xf80fffffffffffffLL, + 10, 16, 5, 0xf81ff81ff81ff81fLL, + 26, 32, 5, 0xf81ffffff81fffffLL, + 58, 64, 5, 0xf81fffffffffffffLL, + 11, 16, 5, 0xf83ff83ff83ff83fLL, + 27, 32, 5, 0xf83ffffff83fffffLL, + 59, 64, 5, 0xf83fffffffffffffLL, + 12, 16, 5, 0xf87ff87ff87ff87fLL, + 28, 32, 5, 0xf87ffffff87fffffLL, + 60, 64, 5, 0xf87fffffffffffffLL, + 5, 8, 5, 0xf8f8f8f8f8f8f8f8LL, + 13, 16, 5, 0xf8fff8fff8fff8ffLL, + 29, 32, 5, 0xf8fffffff8ffffffLL, + 61, 64, 5, 0xf8ffffffffffffffLL, + 6, 8, 5, 0xf9f9f9f9f9f9f9f9LL, + 14, 16, 5, 0xf9fff9fff9fff9ffLL, + 30, 32, 5, 0xf9fffffff9ffffffLL, + 62, 64, 5, 0xf9ffffffffffffffLL, + 7, 8, 5, 0xfbfbfbfbfbfbfbfbLL, + 15, 16, 5, 0xfbfffbfffbfffbffLL, + 31, 32, 5, 0xfbfffffffbffffffLL, + 63, 64, 5, 0xfbffffffffffffffLL, + 6, 64, 6, 0xfc00000000000000LL, + 7, 64, 6, 0xfc00000000000001LL, + 8, 64, 6, 0xfc00000000000003LL, + 9, 64, 6, 0xfc00000000000007LL, + 10, 64, 6, 0xfc0000000000000fLL, + 11, 64, 6, 0xfc0000000000001fLL, + 12, 64, 6, 0xfc0000000000003fLL, + 13, 64, 6, 0xfc0000000000007fLL, + 14, 64, 6, 0xfc000000000000ffLL, + 15, 64, 6, 0xfc000000000001ffLL, + 16, 64, 6, 0xfc000000000003ffLL, + 17, 64, 6, 0xfc000000000007ffLL, + 18, 64, 6, 0xfc00000000000fffLL, + 19, 64, 6, 0xfc00000000001fffLL, + 20, 64, 6, 0xfc00000000003fffLL, + 21, 64, 6, 0xfc00000000007fffLL, + 22, 64, 6, 0xfc0000000000ffffLL, + 23, 64, 6, 0xfc0000000001ffffLL, + 24, 64, 6, 0xfc0000000003ffffLL, + 25, 64, 6, 0xfc0000000007ffffLL, + 26, 64, 6, 0xfc000000000fffffLL, + 27, 64, 6, 0xfc000000001fffffLL, + 28, 64, 6, 0xfc000000003fffffLL, + 29, 64, 6, 0xfc000000007fffffLL, + 30, 64, 6, 0xfc00000000ffffffLL, + 31, 64, 6, 0xfc00000001ffffffLL, + 32, 64, 6, 0xfc00000003ffffffLL, + 33, 64, 6, 0xfc00000007ffffffLL, + 34, 64, 6, 0xfc0000000fffffffLL, + 35, 64, 6, 0xfc0000001fffffffLL, + 36, 64, 6, 0xfc0000003fffffffLL, + 37, 64, 6, 0xfc0000007fffffffLL, + 6, 32, 6, 0xfc000000fc000000LL, + 38, 64, 6, 0xfc000000ffffffffLL, + 7, 32, 6, 0xfc000001fc000001LL, + 39, 64, 6, 0xfc000001ffffffffLL, + 8, 32, 6, 0xfc000003fc000003LL, + 40, 64, 6, 0xfc000003ffffffffLL, + 9, 32, 6, 0xfc000007fc000007LL, + 41, 64, 6, 0xfc000007ffffffffLL, + 10, 32, 6, 0xfc00000ffc00000fLL, + 42, 64, 6, 0xfc00000fffffffffLL, + 11, 32, 6, 0xfc00001ffc00001fLL, + 43, 64, 6, 0xfc00001fffffffffLL, + 12, 32, 6, 0xfc00003ffc00003fLL, + 44, 64, 6, 0xfc00003fffffffffLL, + 13, 32, 6, 0xfc00007ffc00007fLL, + 45, 64, 6, 0xfc00007fffffffffLL, + 14, 32, 6, 0xfc0000fffc0000ffLL, + 46, 64, 6, 0xfc0000ffffffffffLL, + 15, 32, 6, 0xfc0001fffc0001ffLL, + 47, 64, 6, 0xfc0001ffffffffffLL, + 16, 32, 6, 0xfc0003fffc0003ffLL, + 48, 64, 6, 0xfc0003ffffffffffLL, + 17, 32, 6, 0xfc0007fffc0007ffLL, + 49, 64, 6, 0xfc0007ffffffffffLL, + 18, 32, 6, 0xfc000ffffc000fffLL, + 50, 64, 6, 0xfc000fffffffffffLL, + 19, 32, 6, 0xfc001ffffc001fffLL, + 51, 64, 6, 0xfc001fffffffffffLL, + 20, 32, 6, 0xfc003ffffc003fffLL, + 52, 64, 6, 0xfc003fffffffffffLL, + 21, 32, 6, 0xfc007ffffc007fffLL, + 53, 64, 6, 0xfc007fffffffffffLL, + 6, 16, 6, 0xfc00fc00fc00fc00LL, + 22, 32, 6, 0xfc00fffffc00ffffLL, + 54, 64, 6, 0xfc00ffffffffffffLL, + 7, 16, 6, 0xfc01fc01fc01fc01LL, + 23, 32, 6, 0xfc01fffffc01ffffLL, + 55, 64, 6, 0xfc01ffffffffffffLL, + 8, 16, 6, 0xfc03fc03fc03fc03LL, + 24, 32, 6, 0xfc03fffffc03ffffLL, + 56, 64, 6, 0xfc03ffffffffffffLL, + 9, 16, 6, 0xfc07fc07fc07fc07LL, + 25, 32, 6, 0xfc07fffffc07ffffLL, + 57, 64, 6, 0xfc07ffffffffffffLL, + 10, 16, 6, 0xfc0ffc0ffc0ffc0fLL, + 26, 32, 6, 0xfc0ffffffc0fffffLL, + 58, 64, 6, 0xfc0fffffffffffffLL, + 11, 16, 6, 0xfc1ffc1ffc1ffc1fLL, + 27, 32, 6, 0xfc1ffffffc1fffffLL, + 59, 64, 6, 0xfc1fffffffffffffLL, + 12, 16, 6, 0xfc3ffc3ffc3ffc3fLL, + 28, 32, 6, 0xfc3ffffffc3fffffLL, + 60, 64, 6, 0xfc3fffffffffffffLL, + 13, 16, 6, 0xfc7ffc7ffc7ffc7fLL, + 29, 32, 6, 0xfc7ffffffc7fffffLL, + 61, 64, 6, 0xfc7fffffffffffffLL, + 6, 8, 6, 0xfcfcfcfcfcfcfcfcLL, + 14, 16, 6, 0xfcfffcfffcfffcffLL, + 30, 32, 6, 0xfcfffffffcffffffLL, + 62, 64, 6, 0xfcffffffffffffffLL, + 7, 8, 6, 0xfdfdfdfdfdfdfdfdLL, + 15, 16, 6, 0xfdfffdfffdfffdffLL, + 31, 32, 6, 0xfdfffffffdffffffLL, + 63, 64, 6, 0xfdffffffffffffffLL, + 7, 64, 7, 0xfe00000000000000LL, + 8, 64, 7, 0xfe00000000000001LL, + 9, 64, 7, 0xfe00000000000003LL, + 10, 64, 7, 0xfe00000000000007LL, + 11, 64, 7, 0xfe0000000000000fLL, + 12, 64, 7, 0xfe0000000000001fLL, + 13, 64, 7, 0xfe0000000000003fLL, + 14, 64, 7, 0xfe0000000000007fLL, + 15, 64, 7, 0xfe000000000000ffLL, + 16, 64, 7, 0xfe000000000001ffLL, + 17, 64, 7, 0xfe000000000003ffLL, + 18, 64, 7, 0xfe000000000007ffLL, + 19, 64, 7, 0xfe00000000000fffLL, + 20, 64, 7, 0xfe00000000001fffLL, + 21, 64, 7, 0xfe00000000003fffLL, + 22, 64, 7, 0xfe00000000007fffLL, + 23, 64, 7, 0xfe0000000000ffffLL, + 24, 64, 7, 0xfe0000000001ffffLL, + 25, 64, 7, 0xfe0000000003ffffLL, + 26, 64, 7, 0xfe0000000007ffffLL, + 27, 64, 7, 0xfe000000000fffffLL, + 28, 64, 7, 0xfe000000001fffffLL, + 29, 64, 7, 0xfe000000003fffffLL, + 30, 64, 7, 0xfe000000007fffffLL, + 31, 64, 7, 0xfe00000000ffffffLL, + 32, 64, 7, 0xfe00000001ffffffLL, + 33, 64, 7, 0xfe00000003ffffffLL, + 34, 64, 7, 0xfe00000007ffffffLL, + 35, 64, 7, 0xfe0000000fffffffLL, + 36, 64, 7, 0xfe0000001fffffffLL, + 37, 64, 7, 0xfe0000003fffffffLL, + 38, 64, 7, 0xfe0000007fffffffLL, + 7, 32, 7, 0xfe000000fe000000LL, + 39, 64, 7, 0xfe000000ffffffffLL, + 8, 32, 7, 0xfe000001fe000001LL, + 40, 64, 7, 0xfe000001ffffffffLL, + 9, 32, 7, 0xfe000003fe000003LL, + 41, 64, 7, 0xfe000003ffffffffLL, + 10, 32, 7, 0xfe000007fe000007LL, + 42, 64, 7, 0xfe000007ffffffffLL, + 11, 32, 7, 0xfe00000ffe00000fLL, + 43, 64, 7, 0xfe00000fffffffffLL, + 12, 32, 7, 0xfe00001ffe00001fLL, + 44, 64, 7, 0xfe00001fffffffffLL, + 13, 32, 7, 0xfe00003ffe00003fLL, + 45, 64, 7, 0xfe00003fffffffffLL, + 14, 32, 7, 0xfe00007ffe00007fLL, + 46, 64, 7, 0xfe00007fffffffffLL, + 15, 32, 7, 0xfe0000fffe0000ffLL, + 47, 64, 7, 0xfe0000ffffffffffLL, + 16, 32, 7, 0xfe0001fffe0001ffLL, + 48, 64, 7, 0xfe0001ffffffffffLL, + 17, 32, 7, 0xfe0003fffe0003ffLL, + 49, 64, 7, 0xfe0003ffffffffffLL, + 18, 32, 7, 0xfe0007fffe0007ffLL, + 50, 64, 7, 0xfe0007ffffffffffLL, + 19, 32, 7, 0xfe000ffffe000fffLL, + 51, 64, 7, 0xfe000fffffffffffLL, + 20, 32, 7, 0xfe001ffffe001fffLL, + 52, 64, 7, 0xfe001fffffffffffLL, + 21, 32, 7, 0xfe003ffffe003fffLL, + 53, 64, 7, 0xfe003fffffffffffLL, + 22, 32, 7, 0xfe007ffffe007fffLL, + 54, 64, 7, 0xfe007fffffffffffLL, + 7, 16, 7, 0xfe00fe00fe00fe00LL, + 23, 32, 7, 0xfe00fffffe00ffffLL, + 55, 64, 7, 0xfe00ffffffffffffLL, + 8, 16, 7, 0xfe01fe01fe01fe01LL, + 24, 32, 7, 0xfe01fffffe01ffffLL, + 56, 64, 7, 0xfe01ffffffffffffLL, + 9, 16, 7, 0xfe03fe03fe03fe03LL, + 25, 32, 7, 0xfe03fffffe03ffffLL, + 57, 64, 7, 0xfe03ffffffffffffLL, + 10, 16, 7, 0xfe07fe07fe07fe07LL, + 26, 32, 7, 0xfe07fffffe07ffffLL, + 58, 64, 7, 0xfe07ffffffffffffLL, + 11, 16, 7, 0xfe0ffe0ffe0ffe0fLL, + 27, 32, 7, 0xfe0ffffffe0fffffLL, + 59, 64, 7, 0xfe0fffffffffffffLL, + 12, 16, 7, 0xfe1ffe1ffe1ffe1fLL, + 28, 32, 7, 0xfe1ffffffe1fffffLL, + 60, 64, 7, 0xfe1fffffffffffffLL, + 13, 16, 7, 0xfe3ffe3ffe3ffe3fLL, + 29, 32, 7, 0xfe3ffffffe3fffffLL, + 61, 64, 7, 0xfe3fffffffffffffLL, + 14, 16, 7, 0xfe7ffe7ffe7ffe7fLL, + 30, 32, 7, 0xfe7ffffffe7fffffLL, + 62, 64, 7, 0xfe7fffffffffffffLL, + 7, 8, 7, 0xfefefefefefefefeLL, + 15, 16, 7, 0xfefffefffefffeffLL, + 31, 32, 7, 0xfefffffffeffffffLL, + 63, 64, 7, 0xfeffffffffffffffLL, + 8, 64, 8, 0xff00000000000000LL, + 9, 64, 8, 0xff00000000000001LL, + 10, 64, 8, 0xff00000000000003LL, + 11, 64, 8, 0xff00000000000007LL, + 12, 64, 8, 0xff0000000000000fLL, + 13, 64, 8, 0xff0000000000001fLL, + 14, 64, 8, 0xff0000000000003fLL, + 15, 64, 8, 0xff0000000000007fLL, + 16, 64, 8, 0xff000000000000ffLL, + 17, 64, 8, 0xff000000000001ffLL, + 18, 64, 8, 0xff000000000003ffLL, + 19, 64, 8, 0xff000000000007ffLL, + 20, 64, 8, 0xff00000000000fffLL, + 21, 64, 8, 0xff00000000001fffLL, + 22, 64, 8, 0xff00000000003fffLL, + 23, 64, 8, 0xff00000000007fffLL, + 24, 64, 8, 0xff0000000000ffffLL, + 25, 64, 8, 0xff0000000001ffffLL, + 26, 64, 8, 0xff0000000003ffffLL, + 27, 64, 8, 0xff0000000007ffffLL, + 28, 64, 8, 0xff000000000fffffLL, + 29, 64, 8, 0xff000000001fffffLL, + 30, 64, 8, 0xff000000003fffffLL, + 31, 64, 8, 0xff000000007fffffLL, + 32, 64, 8, 0xff00000000ffffffLL, + 33, 64, 8, 0xff00000001ffffffLL, + 34, 64, 8, 0xff00000003ffffffLL, + 35, 64, 8, 0xff00000007ffffffLL, + 36, 64, 8, 0xff0000000fffffffLL, + 37, 64, 8, 0xff0000001fffffffLL, + 38, 64, 8, 0xff0000003fffffffLL, + 39, 64, 8, 0xff0000007fffffffLL, + 8, 32, 8, 0xff000000ff000000LL, + 40, 64, 8, 0xff000000ffffffffLL, + 9, 32, 8, 0xff000001ff000001LL, + 41, 64, 8, 0xff000001ffffffffLL, + 10, 32, 8, 0xff000003ff000003LL, + 42, 64, 8, 0xff000003ffffffffLL, + 11, 32, 8, 0xff000007ff000007LL, + 43, 64, 8, 0xff000007ffffffffLL, + 12, 32, 8, 0xff00000fff00000fLL, + 44, 64, 8, 0xff00000fffffffffLL, + 13, 32, 8, 0xff00001fff00001fLL, + 45, 64, 8, 0xff00001fffffffffLL, + 14, 32, 8, 0xff00003fff00003fLL, + 46, 64, 8, 0xff00003fffffffffLL, + 15, 32, 8, 0xff00007fff00007fLL, + 47, 64, 8, 0xff00007fffffffffLL, + 16, 32, 8, 0xff0000ffff0000ffLL, + 48, 64, 8, 0xff0000ffffffffffLL, + 17, 32, 8, 0xff0001ffff0001ffLL, + 49, 64, 8, 0xff0001ffffffffffLL, + 18, 32, 8, 0xff0003ffff0003ffLL, + 50, 64, 8, 0xff0003ffffffffffLL, + 19, 32, 8, 0xff0007ffff0007ffLL, + 51, 64, 8, 0xff0007ffffffffffLL, + 20, 32, 8, 0xff000fffff000fffLL, + 52, 64, 8, 0xff000fffffffffffLL, + 21, 32, 8, 0xff001fffff001fffLL, + 53, 64, 8, 0xff001fffffffffffLL, + 22, 32, 8, 0xff003fffff003fffLL, + 54, 64, 8, 0xff003fffffffffffLL, + 23, 32, 8, 0xff007fffff007fffLL, + 55, 64, 8, 0xff007fffffffffffLL, + 8, 16, 8, 0xff00ff00ff00ff00LL, + 24, 32, 8, 0xff00ffffff00ffffLL, + 56, 64, 8, 0xff00ffffffffffffLL, + 9, 16, 8, 0xff01ff01ff01ff01LL, + 25, 32, 8, 0xff01ffffff01ffffLL, + 57, 64, 8, 0xff01ffffffffffffLL, + 10, 16, 8, 0xff03ff03ff03ff03LL, + 26, 32, 8, 0xff03ffffff03ffffLL, + 58, 64, 8, 0xff03ffffffffffffLL, + 11, 16, 8, 0xff07ff07ff07ff07LL, + 27, 32, 8, 0xff07ffffff07ffffLL, + 59, 64, 8, 0xff07ffffffffffffLL, + 12, 16, 8, 0xff0fff0fff0fff0fLL, + 28, 32, 8, 0xff0fffffff0fffffLL, + 60, 64, 8, 0xff0fffffffffffffLL, + 13, 16, 8, 0xff1fff1fff1fff1fLL, + 29, 32, 8, 0xff1fffffff1fffffLL, + 61, 64, 8, 0xff1fffffffffffffLL, + 14, 16, 8, 0xff3fff3fff3fff3fLL, + 30, 32, 8, 0xff3fffffff3fffffLL, + 62, 64, 8, 0xff3fffffffffffffLL, + 15, 16, 8, 0xff7fff7fff7fff7fLL, + 31, 32, 8, 0xff7fffffff7fffffLL, + 63, 64, 8, 0xff7fffffffffffffLL, + 9, 64, 9, 0xff80000000000000LL, + 10, 64, 9, 0xff80000000000001LL, + 11, 64, 9, 0xff80000000000003LL, + 12, 64, 9, 0xff80000000000007LL, + 13, 64, 9, 0xff8000000000000fLL, + 14, 64, 9, 0xff8000000000001fLL, + 15, 64, 9, 0xff8000000000003fLL, + 16, 64, 9, 0xff8000000000007fLL, + 17, 64, 9, 0xff800000000000ffLL, + 18, 64, 9, 0xff800000000001ffLL, + 19, 64, 9, 0xff800000000003ffLL, + 20, 64, 9, 0xff800000000007ffLL, + 21, 64, 9, 0xff80000000000fffLL, + 22, 64, 9, 0xff80000000001fffLL, + 23, 64, 9, 0xff80000000003fffLL, + 24, 64, 9, 0xff80000000007fffLL, + 25, 64, 9, 0xff8000000000ffffLL, + 26, 64, 9, 0xff8000000001ffffLL, + 27, 64, 9, 0xff8000000003ffffLL, + 28, 64, 9, 0xff8000000007ffffLL, + 29, 64, 9, 0xff800000000fffffLL, + 30, 64, 9, 0xff800000001fffffLL, + 31, 64, 9, 0xff800000003fffffLL, + 32, 64, 9, 0xff800000007fffffLL, + 33, 64, 9, 0xff80000000ffffffLL, + 34, 64, 9, 0xff80000001ffffffLL, + 35, 64, 9, 0xff80000003ffffffLL, + 36, 64, 9, 0xff80000007ffffffLL, + 37, 64, 9, 0xff8000000fffffffLL, + 38, 64, 9, 0xff8000001fffffffLL, + 39, 64, 9, 0xff8000003fffffffLL, + 40, 64, 9, 0xff8000007fffffffLL, + 9, 32, 9, 0xff800000ff800000LL, + 41, 64, 9, 0xff800000ffffffffLL, + 10, 32, 9, 0xff800001ff800001LL, + 42, 64, 9, 0xff800001ffffffffLL, + 11, 32, 9, 0xff800003ff800003LL, + 43, 64, 9, 0xff800003ffffffffLL, + 12, 32, 9, 0xff800007ff800007LL, + 44, 64, 9, 0xff800007ffffffffLL, + 13, 32, 9, 0xff80000fff80000fLL, + 45, 64, 9, 0xff80000fffffffffLL, + 14, 32, 9, 0xff80001fff80001fLL, + 46, 64, 9, 0xff80001fffffffffLL, + 15, 32, 9, 0xff80003fff80003fLL, + 47, 64, 9, 0xff80003fffffffffLL, + 16, 32, 9, 0xff80007fff80007fLL, + 48, 64, 9, 0xff80007fffffffffLL, + 17, 32, 9, 0xff8000ffff8000ffLL, + 49, 64, 9, 0xff8000ffffffffffLL, + 18, 32, 9, 0xff8001ffff8001ffLL, + 50, 64, 9, 0xff8001ffffffffffLL, + 19, 32, 9, 0xff8003ffff8003ffLL, + 51, 64, 9, 0xff8003ffffffffffLL, + 20, 32, 9, 0xff8007ffff8007ffLL, + 52, 64, 9, 0xff8007ffffffffffLL, + 21, 32, 9, 0xff800fffff800fffLL, + 53, 64, 9, 0xff800fffffffffffLL, + 22, 32, 9, 0xff801fffff801fffLL, + 54, 64, 9, 0xff801fffffffffffLL, + 23, 32, 9, 0xff803fffff803fffLL, + 55, 64, 9, 0xff803fffffffffffLL, + 24, 32, 9, 0xff807fffff807fffLL, + 56, 64, 9, 0xff807fffffffffffLL, + 9, 16, 9, 0xff80ff80ff80ff80LL, + 25, 32, 9, 0xff80ffffff80ffffLL, + 57, 64, 9, 0xff80ffffffffffffLL, + 10, 16, 9, 0xff81ff81ff81ff81LL, + 26, 32, 9, 0xff81ffffff81ffffLL, + 58, 64, 9, 0xff81ffffffffffffLL, + 11, 16, 9, 0xff83ff83ff83ff83LL, + 27, 32, 9, 0xff83ffffff83ffffLL, + 59, 64, 9, 0xff83ffffffffffffLL, + 12, 16, 9, 0xff87ff87ff87ff87LL, + 28, 32, 9, 0xff87ffffff87ffffLL, + 60, 64, 9, 0xff87ffffffffffffLL, + 13, 16, 9, 0xff8fff8fff8fff8fLL, + 29, 32, 9, 0xff8fffffff8fffffLL, + 61, 64, 9, 0xff8fffffffffffffLL, + 14, 16, 9, 0xff9fff9fff9fff9fLL, + 30, 32, 9, 0xff9fffffff9fffffLL, + 62, 64, 9, 0xff9fffffffffffffLL, + 15, 16, 9, 0xffbfffbfffbfffbfLL, + 31, 32, 9, 0xffbfffffffbfffffLL, + 63, 64, 9, 0xffbfffffffffffffLL, + 10, 64, 10, 0xffc0000000000000LL, + 11, 64, 10, 0xffc0000000000001LL, + 12, 64, 10, 0xffc0000000000003LL, + 13, 64, 10, 0xffc0000000000007LL, + 14, 64, 10, 0xffc000000000000fLL, + 15, 64, 10, 0xffc000000000001fLL, + 16, 64, 10, 0xffc000000000003fLL, + 17, 64, 10, 0xffc000000000007fLL, + 18, 64, 10, 0xffc00000000000ffLL, + 19, 64, 10, 0xffc00000000001ffLL, + 20, 64, 10, 0xffc00000000003ffLL, + 21, 64, 10, 0xffc00000000007ffLL, + 22, 64, 10, 0xffc0000000000fffLL, + 23, 64, 10, 0xffc0000000001fffLL, + 24, 64, 10, 0xffc0000000003fffLL, + 25, 64, 10, 0xffc0000000007fffLL, + 26, 64, 10, 0xffc000000000ffffLL, + 27, 64, 10, 0xffc000000001ffffLL, + 28, 64, 10, 0xffc000000003ffffLL, + 29, 64, 10, 0xffc000000007ffffLL, + 30, 64, 10, 0xffc00000000fffffLL, + 31, 64, 10, 0xffc00000001fffffLL, + 32, 64, 10, 0xffc00000003fffffLL, + 33, 64, 10, 0xffc00000007fffffLL, + 34, 64, 10, 0xffc0000000ffffffLL, + 35, 64, 10, 0xffc0000001ffffffLL, + 36, 64, 10, 0xffc0000003ffffffLL, + 37, 64, 10, 0xffc0000007ffffffLL, + 38, 64, 10, 0xffc000000fffffffLL, + 39, 64, 10, 0xffc000001fffffffLL, + 40, 64, 10, 0xffc000003fffffffLL, + 41, 64, 10, 0xffc000007fffffffLL, + 10, 32, 10, 0xffc00000ffc00000LL, + 42, 64, 10, 0xffc00000ffffffffLL, + 11, 32, 10, 0xffc00001ffc00001LL, + 43, 64, 10, 0xffc00001ffffffffLL, + 12, 32, 10, 0xffc00003ffc00003LL, + 44, 64, 10, 0xffc00003ffffffffLL, + 13, 32, 10, 0xffc00007ffc00007LL, + 45, 64, 10, 0xffc00007ffffffffLL, + 14, 32, 10, 0xffc0000fffc0000fLL, + 46, 64, 10, 0xffc0000fffffffffLL, + 15, 32, 10, 0xffc0001fffc0001fLL, + 47, 64, 10, 0xffc0001fffffffffLL, + 16, 32, 10, 0xffc0003fffc0003fLL, + 48, 64, 10, 0xffc0003fffffffffLL, + 17, 32, 10, 0xffc0007fffc0007fLL, + 49, 64, 10, 0xffc0007fffffffffLL, + 18, 32, 10, 0xffc000ffffc000ffLL, + 50, 64, 10, 0xffc000ffffffffffLL, + 19, 32, 10, 0xffc001ffffc001ffLL, + 51, 64, 10, 0xffc001ffffffffffLL, + 20, 32, 10, 0xffc003ffffc003ffLL, + 52, 64, 10, 0xffc003ffffffffffLL, + 21, 32, 10, 0xffc007ffffc007ffLL, + 53, 64, 10, 0xffc007ffffffffffLL, + 22, 32, 10, 0xffc00fffffc00fffLL, + 54, 64, 10, 0xffc00fffffffffffLL, + 23, 32, 10, 0xffc01fffffc01fffLL, + 55, 64, 10, 0xffc01fffffffffffLL, + 24, 32, 10, 0xffc03fffffc03fffLL, + 56, 64, 10, 0xffc03fffffffffffLL, + 25, 32, 10, 0xffc07fffffc07fffLL, + 57, 64, 10, 0xffc07fffffffffffLL, + 10, 16, 10, 0xffc0ffc0ffc0ffc0LL, + 26, 32, 10, 0xffc0ffffffc0ffffLL, + 58, 64, 10, 0xffc0ffffffffffffLL, + 11, 16, 10, 0xffc1ffc1ffc1ffc1LL, + 27, 32, 10, 0xffc1ffffffc1ffffLL, + 59, 64, 10, 0xffc1ffffffffffffLL, + 12, 16, 10, 0xffc3ffc3ffc3ffc3LL, + 28, 32, 10, 0xffc3ffffffc3ffffLL, + 60, 64, 10, 0xffc3ffffffffffffLL, + 13, 16, 10, 0xffc7ffc7ffc7ffc7LL, + 29, 32, 10, 0xffc7ffffffc7ffffLL, + 61, 64, 10, 0xffc7ffffffffffffLL, + 14, 16, 10, 0xffcfffcfffcfffcfLL, + 30, 32, 10, 0xffcfffffffcfffffLL, + 62, 64, 10, 0xffcfffffffffffffLL, + 15, 16, 10, 0xffdfffdfffdfffdfLL, + 31, 32, 10, 0xffdfffffffdfffffLL, + 63, 64, 10, 0xffdfffffffffffffLL, + 11, 64, 11, 0xffe0000000000000LL, + 12, 64, 11, 0xffe0000000000001LL, + 13, 64, 11, 0xffe0000000000003LL, + 14, 64, 11, 0xffe0000000000007LL, + 15, 64, 11, 0xffe000000000000fLL, + 16, 64, 11, 0xffe000000000001fLL, + 17, 64, 11, 0xffe000000000003fLL, + 18, 64, 11, 0xffe000000000007fLL, + 19, 64, 11, 0xffe00000000000ffLL, + 20, 64, 11, 0xffe00000000001ffLL, + 21, 64, 11, 0xffe00000000003ffLL, + 22, 64, 11, 0xffe00000000007ffLL, + 23, 64, 11, 0xffe0000000000fffLL, + 24, 64, 11, 0xffe0000000001fffLL, + 25, 64, 11, 0xffe0000000003fffLL, + 26, 64, 11, 0xffe0000000007fffLL, + 27, 64, 11, 0xffe000000000ffffLL, + 28, 64, 11, 0xffe000000001ffffLL, + 29, 64, 11, 0xffe000000003ffffLL, + 30, 64, 11, 0xffe000000007ffffLL, + 31, 64, 11, 0xffe00000000fffffLL, + 32, 64, 11, 0xffe00000001fffffLL, + 33, 64, 11, 0xffe00000003fffffLL, + 34, 64, 11, 0xffe00000007fffffLL, + 35, 64, 11, 0xffe0000000ffffffLL, + 36, 64, 11, 0xffe0000001ffffffLL, + 37, 64, 11, 0xffe0000003ffffffLL, + 38, 64, 11, 0xffe0000007ffffffLL, + 39, 64, 11, 0xffe000000fffffffLL, + 40, 64, 11, 0xffe000001fffffffLL, + 41, 64, 11, 0xffe000003fffffffLL, + 42, 64, 11, 0xffe000007fffffffLL, + 11, 32, 11, 0xffe00000ffe00000LL, + 43, 64, 11, 0xffe00000ffffffffLL, + 12, 32, 11, 0xffe00001ffe00001LL, + 44, 64, 11, 0xffe00001ffffffffLL, + 13, 32, 11, 0xffe00003ffe00003LL, + 45, 64, 11, 0xffe00003ffffffffLL, + 14, 32, 11, 0xffe00007ffe00007LL, + 46, 64, 11, 0xffe00007ffffffffLL, + 15, 32, 11, 0xffe0000fffe0000fLL, + 47, 64, 11, 0xffe0000fffffffffLL, + 16, 32, 11, 0xffe0001fffe0001fLL, + 48, 64, 11, 0xffe0001fffffffffLL, + 17, 32, 11, 0xffe0003fffe0003fLL, + 49, 64, 11, 0xffe0003fffffffffLL, + 18, 32, 11, 0xffe0007fffe0007fLL, + 50, 64, 11, 0xffe0007fffffffffLL, + 19, 32, 11, 0xffe000ffffe000ffLL, + 51, 64, 11, 0xffe000ffffffffffLL, + 20, 32, 11, 0xffe001ffffe001ffLL, + 52, 64, 11, 0xffe001ffffffffffLL, + 21, 32, 11, 0xffe003ffffe003ffLL, + 53, 64, 11, 0xffe003ffffffffffLL, + 22, 32, 11, 0xffe007ffffe007ffLL, + 54, 64, 11, 0xffe007ffffffffffLL, + 23, 32, 11, 0xffe00fffffe00fffLL, + 55, 64, 11, 0xffe00fffffffffffLL, + 24, 32, 11, 0xffe01fffffe01fffLL, + 56, 64, 11, 0xffe01fffffffffffLL, + 25, 32, 11, 0xffe03fffffe03fffLL, + 57, 64, 11, 0xffe03fffffffffffLL, + 26, 32, 11, 0xffe07fffffe07fffLL, + 58, 64, 11, 0xffe07fffffffffffLL, + 11, 16, 11, 0xffe0ffe0ffe0ffe0LL, + 27, 32, 11, 0xffe0ffffffe0ffffLL, + 59, 64, 11, 0xffe0ffffffffffffLL, + 12, 16, 11, 0xffe1ffe1ffe1ffe1LL, + 28, 32, 11, 0xffe1ffffffe1ffffLL, + 60, 64, 11, 0xffe1ffffffffffffLL, + 13, 16, 11, 0xffe3ffe3ffe3ffe3LL, + 29, 32, 11, 0xffe3ffffffe3ffffLL, + 61, 64, 11, 0xffe3ffffffffffffLL, + 14, 16, 11, 0xffe7ffe7ffe7ffe7LL, + 30, 32, 11, 0xffe7ffffffe7ffffLL, + 62, 64, 11, 0xffe7ffffffffffffLL, + 15, 16, 11, 0xffefffefffefffefLL, + 31, 32, 11, 0xffefffffffefffffLL, + 63, 64, 11, 0xffefffffffffffffLL, + 12, 64, 12, 0xfff0000000000000LL, + 13, 64, 12, 0xfff0000000000001LL, + 14, 64, 12, 0xfff0000000000003LL, + 15, 64, 12, 0xfff0000000000007LL, + 16, 64, 12, 0xfff000000000000fLL, + 17, 64, 12, 0xfff000000000001fLL, + 18, 64, 12, 0xfff000000000003fLL, + 19, 64, 12, 0xfff000000000007fLL, + 20, 64, 12, 0xfff00000000000ffLL, + 21, 64, 12, 0xfff00000000001ffLL, + 22, 64, 12, 0xfff00000000003ffLL, + 23, 64, 12, 0xfff00000000007ffLL, + 24, 64, 12, 0xfff0000000000fffLL, + 25, 64, 12, 0xfff0000000001fffLL, + 26, 64, 12, 0xfff0000000003fffLL, + 27, 64, 12, 0xfff0000000007fffLL, + 28, 64, 12, 0xfff000000000ffffLL, + 29, 64, 12, 0xfff000000001ffffLL, + 30, 64, 12, 0xfff000000003ffffLL, + 31, 64, 12, 0xfff000000007ffffLL, + 32, 64, 12, 0xfff00000000fffffLL, + 33, 64, 12, 0xfff00000001fffffLL, + 34, 64, 12, 0xfff00000003fffffLL, + 35, 64, 12, 0xfff00000007fffffLL, + 36, 64, 12, 0xfff0000000ffffffLL, + 37, 64, 12, 0xfff0000001ffffffLL, + 38, 64, 12, 0xfff0000003ffffffLL, + 39, 64, 12, 0xfff0000007ffffffLL, + 40, 64, 12, 0xfff000000fffffffLL, + 41, 64, 12, 0xfff000001fffffffLL, + 42, 64, 12, 0xfff000003fffffffLL, + 43, 64, 12, 0xfff000007fffffffLL, + 12, 32, 12, 0xfff00000fff00000LL, + 44, 64, 12, 0xfff00000ffffffffLL, + 13, 32, 12, 0xfff00001fff00001LL, + 45, 64, 12, 0xfff00001ffffffffLL, + 14, 32, 12, 0xfff00003fff00003LL, + 46, 64, 12, 0xfff00003ffffffffLL, + 15, 32, 12, 0xfff00007fff00007LL, + 47, 64, 12, 0xfff00007ffffffffLL, + 16, 32, 12, 0xfff0000ffff0000fLL, + 48, 64, 12, 0xfff0000fffffffffLL, + 17, 32, 12, 0xfff0001ffff0001fLL, + 49, 64, 12, 0xfff0001fffffffffLL, + 18, 32, 12, 0xfff0003ffff0003fLL, + 50, 64, 12, 0xfff0003fffffffffLL, + 19, 32, 12, 0xfff0007ffff0007fLL, + 51, 64, 12, 0xfff0007fffffffffLL, + 20, 32, 12, 0xfff000fffff000ffLL, + 52, 64, 12, 0xfff000ffffffffffLL, + 21, 32, 12, 0xfff001fffff001ffLL, + 53, 64, 12, 0xfff001ffffffffffLL, + 22, 32, 12, 0xfff003fffff003ffLL, + 54, 64, 12, 0xfff003ffffffffffLL, + 23, 32, 12, 0xfff007fffff007ffLL, + 55, 64, 12, 0xfff007ffffffffffLL, + 24, 32, 12, 0xfff00ffffff00fffLL, + 56, 64, 12, 0xfff00fffffffffffLL, + 25, 32, 12, 0xfff01ffffff01fffLL, + 57, 64, 12, 0xfff01fffffffffffLL, + 26, 32, 12, 0xfff03ffffff03fffLL, + 58, 64, 12, 0xfff03fffffffffffLL, + 27, 32, 12, 0xfff07ffffff07fffLL, + 59, 64, 12, 0xfff07fffffffffffLL, + 12, 16, 12, 0xfff0fff0fff0fff0LL, + 28, 32, 12, 0xfff0fffffff0ffffLL, + 60, 64, 12, 0xfff0ffffffffffffLL, + 13, 16, 12, 0xfff1fff1fff1fff1LL, + 29, 32, 12, 0xfff1fffffff1ffffLL, + 61, 64, 12, 0xfff1ffffffffffffLL, + 14, 16, 12, 0xfff3fff3fff3fff3LL, + 30, 32, 12, 0xfff3fffffff3ffffLL, + 62, 64, 12, 0xfff3ffffffffffffLL, + 15, 16, 12, 0xfff7fff7fff7fff7LL, + 31, 32, 12, 0xfff7fffffff7ffffLL, + 63, 64, 12, 0xfff7ffffffffffffLL, + 13, 64, 13, 0xfff8000000000000LL, + 14, 64, 13, 0xfff8000000000001LL, + 15, 64, 13, 0xfff8000000000003LL, + 16, 64, 13, 0xfff8000000000007LL, + 17, 64, 13, 0xfff800000000000fLL, + 18, 64, 13, 0xfff800000000001fLL, + 19, 64, 13, 0xfff800000000003fLL, + 20, 64, 13, 0xfff800000000007fLL, + 21, 64, 13, 0xfff80000000000ffLL, + 22, 64, 13, 0xfff80000000001ffLL, + 23, 64, 13, 0xfff80000000003ffLL, + 24, 64, 13, 0xfff80000000007ffLL, + 25, 64, 13, 0xfff8000000000fffLL, + 26, 64, 13, 0xfff8000000001fffLL, + 27, 64, 13, 0xfff8000000003fffLL, + 28, 64, 13, 0xfff8000000007fffLL, + 29, 64, 13, 0xfff800000000ffffLL, + 30, 64, 13, 0xfff800000001ffffLL, + 31, 64, 13, 0xfff800000003ffffLL, + 32, 64, 13, 0xfff800000007ffffLL, + 33, 64, 13, 0xfff80000000fffffLL, + 34, 64, 13, 0xfff80000001fffffLL, + 35, 64, 13, 0xfff80000003fffffLL, + 36, 64, 13, 0xfff80000007fffffLL, + 37, 64, 13, 0xfff8000000ffffffLL, + 38, 64, 13, 0xfff8000001ffffffLL, + 39, 64, 13, 0xfff8000003ffffffLL, + 40, 64, 13, 0xfff8000007ffffffLL, + 41, 64, 13, 0xfff800000fffffffLL, + 42, 64, 13, 0xfff800001fffffffLL, + 43, 64, 13, 0xfff800003fffffffLL, + 44, 64, 13, 0xfff800007fffffffLL, + 13, 32, 13, 0xfff80000fff80000LL, + 45, 64, 13, 0xfff80000ffffffffLL, + 14, 32, 13, 0xfff80001fff80001LL, + 46, 64, 13, 0xfff80001ffffffffLL, + 15, 32, 13, 0xfff80003fff80003LL, + 47, 64, 13, 0xfff80003ffffffffLL, + 16, 32, 13, 0xfff80007fff80007LL, + 48, 64, 13, 0xfff80007ffffffffLL, + 17, 32, 13, 0xfff8000ffff8000fLL, + 49, 64, 13, 0xfff8000fffffffffLL, + 18, 32, 13, 0xfff8001ffff8001fLL, + 50, 64, 13, 0xfff8001fffffffffLL, + 19, 32, 13, 0xfff8003ffff8003fLL, + 51, 64, 13, 0xfff8003fffffffffLL, + 20, 32, 13, 0xfff8007ffff8007fLL, + 52, 64, 13, 0xfff8007fffffffffLL, + 21, 32, 13, 0xfff800fffff800ffLL, + 53, 64, 13, 0xfff800ffffffffffLL, + 22, 32, 13, 0xfff801fffff801ffLL, + 54, 64, 13, 0xfff801ffffffffffLL, + 23, 32, 13, 0xfff803fffff803ffLL, + 55, 64, 13, 0xfff803ffffffffffLL, + 24, 32, 13, 0xfff807fffff807ffLL, + 56, 64, 13, 0xfff807ffffffffffLL, + 25, 32, 13, 0xfff80ffffff80fffLL, + 57, 64, 13, 0xfff80fffffffffffLL, + 26, 32, 13, 0xfff81ffffff81fffLL, + 58, 64, 13, 0xfff81fffffffffffLL, + 27, 32, 13, 0xfff83ffffff83fffLL, + 59, 64, 13, 0xfff83fffffffffffLL, + 28, 32, 13, 0xfff87ffffff87fffLL, + 60, 64, 13, 0xfff87fffffffffffLL, + 13, 16, 13, 0xfff8fff8fff8fff8LL, + 29, 32, 13, 0xfff8fffffff8ffffLL, + 61, 64, 13, 0xfff8ffffffffffffLL, + 14, 16, 13, 0xfff9fff9fff9fff9LL, + 30, 32, 13, 0xfff9fffffff9ffffLL, + 62, 64, 13, 0xfff9ffffffffffffLL, + 15, 16, 13, 0xfffbfffbfffbfffbLL, + 31, 32, 13, 0xfffbfffffffbffffLL, + 63, 64, 13, 0xfffbffffffffffffLL, + 14, 64, 14, 0xfffc000000000000LL, + 15, 64, 14, 0xfffc000000000001LL, + 16, 64, 14, 0xfffc000000000003LL, + 17, 64, 14, 0xfffc000000000007LL, + 18, 64, 14, 0xfffc00000000000fLL, + 19, 64, 14, 0xfffc00000000001fLL, + 20, 64, 14, 0xfffc00000000003fLL, + 21, 64, 14, 0xfffc00000000007fLL, + 22, 64, 14, 0xfffc0000000000ffLL, + 23, 64, 14, 0xfffc0000000001ffLL, + 24, 64, 14, 0xfffc0000000003ffLL, + 25, 64, 14, 0xfffc0000000007ffLL, + 26, 64, 14, 0xfffc000000000fffLL, + 27, 64, 14, 0xfffc000000001fffLL, + 28, 64, 14, 0xfffc000000003fffLL, + 29, 64, 14, 0xfffc000000007fffLL, + 30, 64, 14, 0xfffc00000000ffffLL, + 31, 64, 14, 0xfffc00000001ffffLL, + 32, 64, 14, 0xfffc00000003ffffLL, + 33, 64, 14, 0xfffc00000007ffffLL, + 34, 64, 14, 0xfffc0000000fffffLL, + 35, 64, 14, 0xfffc0000001fffffLL, + 36, 64, 14, 0xfffc0000003fffffLL, + 37, 64, 14, 0xfffc0000007fffffLL, + 38, 64, 14, 0xfffc000000ffffffLL, + 39, 64, 14, 0xfffc000001ffffffLL, + 40, 64, 14, 0xfffc000003ffffffLL, + 41, 64, 14, 0xfffc000007ffffffLL, + 42, 64, 14, 0xfffc00000fffffffLL, + 43, 64, 14, 0xfffc00001fffffffLL, + 44, 64, 14, 0xfffc00003fffffffLL, + 45, 64, 14, 0xfffc00007fffffffLL, + 14, 32, 14, 0xfffc0000fffc0000LL, + 46, 64, 14, 0xfffc0000ffffffffLL, + 15, 32, 14, 0xfffc0001fffc0001LL, + 47, 64, 14, 0xfffc0001ffffffffLL, + 16, 32, 14, 0xfffc0003fffc0003LL, + 48, 64, 14, 0xfffc0003ffffffffLL, + 17, 32, 14, 0xfffc0007fffc0007LL, + 49, 64, 14, 0xfffc0007ffffffffLL, + 18, 32, 14, 0xfffc000ffffc000fLL, + 50, 64, 14, 0xfffc000fffffffffLL, + 19, 32, 14, 0xfffc001ffffc001fLL, + 51, 64, 14, 0xfffc001fffffffffLL, + 20, 32, 14, 0xfffc003ffffc003fLL, + 52, 64, 14, 0xfffc003fffffffffLL, + 21, 32, 14, 0xfffc007ffffc007fLL, + 53, 64, 14, 0xfffc007fffffffffLL, + 22, 32, 14, 0xfffc00fffffc00ffLL, + 54, 64, 14, 0xfffc00ffffffffffLL, + 23, 32, 14, 0xfffc01fffffc01ffLL, + 55, 64, 14, 0xfffc01ffffffffffLL, + 24, 32, 14, 0xfffc03fffffc03ffLL, + 56, 64, 14, 0xfffc03ffffffffffLL, + 25, 32, 14, 0xfffc07fffffc07ffLL, + 57, 64, 14, 0xfffc07ffffffffffLL, + 26, 32, 14, 0xfffc0ffffffc0fffLL, + 58, 64, 14, 0xfffc0fffffffffffLL, + 27, 32, 14, 0xfffc1ffffffc1fffLL, + 59, 64, 14, 0xfffc1fffffffffffLL, + 28, 32, 14, 0xfffc3ffffffc3fffLL, + 60, 64, 14, 0xfffc3fffffffffffLL, + 29, 32, 14, 0xfffc7ffffffc7fffLL, + 61, 64, 14, 0xfffc7fffffffffffLL, + 14, 16, 14, 0xfffcfffcfffcfffcLL, + 30, 32, 14, 0xfffcfffffffcffffLL, + 62, 64, 14, 0xfffcffffffffffffLL, + 15, 16, 14, 0xfffdfffdfffdfffdLL, + 31, 32, 14, 0xfffdfffffffdffffLL, + 63, 64, 14, 0xfffdffffffffffffLL, + 15, 64, 15, 0xfffe000000000000LL, + 16, 64, 15, 0xfffe000000000001LL, + 17, 64, 15, 0xfffe000000000003LL, + 18, 64, 15, 0xfffe000000000007LL, + 19, 64, 15, 0xfffe00000000000fLL, + 20, 64, 15, 0xfffe00000000001fLL, + 21, 64, 15, 0xfffe00000000003fLL, + 22, 64, 15, 0xfffe00000000007fLL, + 23, 64, 15, 0xfffe0000000000ffLL, + 24, 64, 15, 0xfffe0000000001ffLL, + 25, 64, 15, 0xfffe0000000003ffLL, + 26, 64, 15, 0xfffe0000000007ffLL, + 27, 64, 15, 0xfffe000000000fffLL, + 28, 64, 15, 0xfffe000000001fffLL, + 29, 64, 15, 0xfffe000000003fffLL, + 30, 64, 15, 0xfffe000000007fffLL, + 31, 64, 15, 0xfffe00000000ffffLL, + 32, 64, 15, 0xfffe00000001ffffLL, + 33, 64, 15, 0xfffe00000003ffffLL, + 34, 64, 15, 0xfffe00000007ffffLL, + 35, 64, 15, 0xfffe0000000fffffLL, + 36, 64, 15, 0xfffe0000001fffffLL, + 37, 64, 15, 0xfffe0000003fffffLL, + 38, 64, 15, 0xfffe0000007fffffLL, + 39, 64, 15, 0xfffe000000ffffffLL, + 40, 64, 15, 0xfffe000001ffffffLL, + 41, 64, 15, 0xfffe000003ffffffLL, + 42, 64, 15, 0xfffe000007ffffffLL, + 43, 64, 15, 0xfffe00000fffffffLL, + 44, 64, 15, 0xfffe00001fffffffLL, + 45, 64, 15, 0xfffe00003fffffffLL, + 46, 64, 15, 0xfffe00007fffffffLL, + 15, 32, 15, 0xfffe0000fffe0000LL, + 47, 64, 15, 0xfffe0000ffffffffLL, + 16, 32, 15, 0xfffe0001fffe0001LL, + 48, 64, 15, 0xfffe0001ffffffffLL, + 17, 32, 15, 0xfffe0003fffe0003LL, + 49, 64, 15, 0xfffe0003ffffffffLL, + 18, 32, 15, 0xfffe0007fffe0007LL, + 50, 64, 15, 0xfffe0007ffffffffLL, + 19, 32, 15, 0xfffe000ffffe000fLL, + 51, 64, 15, 0xfffe000fffffffffLL, + 20, 32, 15, 0xfffe001ffffe001fLL, + 52, 64, 15, 0xfffe001fffffffffLL, + 21, 32, 15, 0xfffe003ffffe003fLL, + 53, 64, 15, 0xfffe003fffffffffLL, + 22, 32, 15, 0xfffe007ffffe007fLL, + 54, 64, 15, 0xfffe007fffffffffLL, + 23, 32, 15, 0xfffe00fffffe00ffLL, + 55, 64, 15, 0xfffe00ffffffffffLL, + 24, 32, 15, 0xfffe01fffffe01ffLL, + 56, 64, 15, 0xfffe01ffffffffffLL, + 25, 32, 15, 0xfffe03fffffe03ffLL, + 57, 64, 15, 0xfffe03ffffffffffLL, + 26, 32, 15, 0xfffe07fffffe07ffLL, + 58, 64, 15, 0xfffe07ffffffffffLL, + 27, 32, 15, 0xfffe0ffffffe0fffLL, + 59, 64, 15, 0xfffe0fffffffffffLL, + 28, 32, 15, 0xfffe1ffffffe1fffLL, + 60, 64, 15, 0xfffe1fffffffffffLL, + 29, 32, 15, 0xfffe3ffffffe3fffLL, + 61, 64, 15, 0xfffe3fffffffffffLL, + 30, 32, 15, 0xfffe7ffffffe7fffLL, + 62, 64, 15, 0xfffe7fffffffffffLL, + 15, 16, 15, 0xfffefffefffefffeLL, + 31, 32, 15, 0xfffefffffffeffffLL, + 63, 64, 15, 0xfffeffffffffffffLL, + 16, 64, 16, 0xffff000000000000LL, + 17, 64, 16, 0xffff000000000001LL, + 18, 64, 16, 0xffff000000000003LL, + 19, 64, 16, 0xffff000000000007LL, + 20, 64, 16, 0xffff00000000000fLL, + 21, 64, 16, 0xffff00000000001fLL, + 22, 64, 16, 0xffff00000000003fLL, + 23, 64, 16, 0xffff00000000007fLL, + 24, 64, 16, 0xffff0000000000ffLL, + 25, 64, 16, 0xffff0000000001ffLL, + 26, 64, 16, 0xffff0000000003ffLL, + 27, 64, 16, 0xffff0000000007ffLL, + 28, 64, 16, 0xffff000000000fffLL, + 29, 64, 16, 0xffff000000001fffLL, + 30, 64, 16, 0xffff000000003fffLL, + 31, 64, 16, 0xffff000000007fffLL, + 32, 64, 16, 0xffff00000000ffffLL, + 33, 64, 16, 0xffff00000001ffffLL, + 34, 64, 16, 0xffff00000003ffffLL, + 35, 64, 16, 0xffff00000007ffffLL, + 36, 64, 16, 0xffff0000000fffffLL, + 37, 64, 16, 0xffff0000001fffffLL, + 38, 64, 16, 0xffff0000003fffffLL, + 39, 64, 16, 0xffff0000007fffffLL, + 40, 64, 16, 0xffff000000ffffffLL, + 41, 64, 16, 0xffff000001ffffffLL, + 42, 64, 16, 0xffff000003ffffffLL, + 43, 64, 16, 0xffff000007ffffffLL, + 44, 64, 16, 0xffff00000fffffffLL, + 45, 64, 16, 0xffff00001fffffffLL, + 46, 64, 16, 0xffff00003fffffffLL, + 47, 64, 16, 0xffff00007fffffffLL, + 16, 32, 16, 0xffff0000ffff0000LL, + 48, 64, 16, 0xffff0000ffffffffLL, + 17, 32, 16, 0xffff0001ffff0001LL, + 49, 64, 16, 0xffff0001ffffffffLL, + 18, 32, 16, 0xffff0003ffff0003LL, + 50, 64, 16, 0xffff0003ffffffffLL, + 19, 32, 16, 0xffff0007ffff0007LL, + 51, 64, 16, 0xffff0007ffffffffLL, + 20, 32, 16, 0xffff000fffff000fLL, + 52, 64, 16, 0xffff000fffffffffLL, + 21, 32, 16, 0xffff001fffff001fLL, + 53, 64, 16, 0xffff001fffffffffLL, + 22, 32, 16, 0xffff003fffff003fLL, + 54, 64, 16, 0xffff003fffffffffLL, + 23, 32, 16, 0xffff007fffff007fLL, + 55, 64, 16, 0xffff007fffffffffLL, + 24, 32, 16, 0xffff00ffffff00ffLL, + 56, 64, 16, 0xffff00ffffffffffLL, + 25, 32, 16, 0xffff01ffffff01ffLL, + 57, 64, 16, 0xffff01ffffffffffLL, + 26, 32, 16, 0xffff03ffffff03ffLL, + 58, 64, 16, 0xffff03ffffffffffLL, + 27, 32, 16, 0xffff07ffffff07ffLL, + 59, 64, 16, 0xffff07ffffffffffLL, + 28, 32, 16, 0xffff0fffffff0fffLL, + 60, 64, 16, 0xffff0fffffffffffLL, + 29, 32, 16, 0xffff1fffffff1fffLL, + 61, 64, 16, 0xffff1fffffffffffLL, + 30, 32, 16, 0xffff3fffffff3fffLL, + 62, 64, 16, 0xffff3fffffffffffLL, + 31, 32, 16, 0xffff7fffffff7fffLL, + 63, 64, 16, 0xffff7fffffffffffLL, + 17, 64, 17, 0xffff800000000000LL, + 18, 64, 17, 0xffff800000000001LL, + 19, 64, 17, 0xffff800000000003LL, + 20, 64, 17, 0xffff800000000007LL, + 21, 64, 17, 0xffff80000000000fLL, + 22, 64, 17, 0xffff80000000001fLL, + 23, 64, 17, 0xffff80000000003fLL, + 24, 64, 17, 0xffff80000000007fLL, + 25, 64, 17, 0xffff8000000000ffLL, + 26, 64, 17, 0xffff8000000001ffLL, + 27, 64, 17, 0xffff8000000003ffLL, + 28, 64, 17, 0xffff8000000007ffLL, + 29, 64, 17, 0xffff800000000fffLL, + 30, 64, 17, 0xffff800000001fffLL, + 31, 64, 17, 0xffff800000003fffLL, + 32, 64, 17, 0xffff800000007fffLL, + 33, 64, 17, 0xffff80000000ffffLL, + 34, 64, 17, 0xffff80000001ffffLL, + 35, 64, 17, 0xffff80000003ffffLL, + 36, 64, 17, 0xffff80000007ffffLL, + 37, 64, 17, 0xffff8000000fffffLL, + 38, 64, 17, 0xffff8000001fffffLL, + 39, 64, 17, 0xffff8000003fffffLL, + 40, 64, 17, 0xffff8000007fffffLL, + 41, 64, 17, 0xffff800000ffffffLL, + 42, 64, 17, 0xffff800001ffffffLL, + 43, 64, 17, 0xffff800003ffffffLL, + 44, 64, 17, 0xffff800007ffffffLL, + 45, 64, 17, 0xffff80000fffffffLL, + 46, 64, 17, 0xffff80001fffffffLL, + 47, 64, 17, 0xffff80003fffffffLL, + 48, 64, 17, 0xffff80007fffffffLL, + 17, 32, 17, 0xffff8000ffff8000LL, + 49, 64, 17, 0xffff8000ffffffffLL, + 18, 32, 17, 0xffff8001ffff8001LL, + 50, 64, 17, 0xffff8001ffffffffLL, + 19, 32, 17, 0xffff8003ffff8003LL, + 51, 64, 17, 0xffff8003ffffffffLL, + 20, 32, 17, 0xffff8007ffff8007LL, + 52, 64, 17, 0xffff8007ffffffffLL, + 21, 32, 17, 0xffff800fffff800fLL, + 53, 64, 17, 0xffff800fffffffffLL, + 22, 32, 17, 0xffff801fffff801fLL, + 54, 64, 17, 0xffff801fffffffffLL, + 23, 32, 17, 0xffff803fffff803fLL, + 55, 64, 17, 0xffff803fffffffffLL, + 24, 32, 17, 0xffff807fffff807fLL, + 56, 64, 17, 0xffff807fffffffffLL, + 25, 32, 17, 0xffff80ffffff80ffLL, + 57, 64, 17, 0xffff80ffffffffffLL, + 26, 32, 17, 0xffff81ffffff81ffLL, + 58, 64, 17, 0xffff81ffffffffffLL, + 27, 32, 17, 0xffff83ffffff83ffLL, + 59, 64, 17, 0xffff83ffffffffffLL, + 28, 32, 17, 0xffff87ffffff87ffLL, + 60, 64, 17, 0xffff87ffffffffffLL, + 29, 32, 17, 0xffff8fffffff8fffLL, + 61, 64, 17, 0xffff8fffffffffffLL, + 30, 32, 17, 0xffff9fffffff9fffLL, + 62, 64, 17, 0xffff9fffffffffffLL, + 31, 32, 17, 0xffffbfffffffbfffLL, + 63, 64, 17, 0xffffbfffffffffffLL, + 18, 64, 18, 0xffffc00000000000LL, + 19, 64, 18, 0xffffc00000000001LL, + 20, 64, 18, 0xffffc00000000003LL, + 21, 64, 18, 0xffffc00000000007LL, + 22, 64, 18, 0xffffc0000000000fLL, + 23, 64, 18, 0xffffc0000000001fLL, + 24, 64, 18, 0xffffc0000000003fLL, + 25, 64, 18, 0xffffc0000000007fLL, + 26, 64, 18, 0xffffc000000000ffLL, + 27, 64, 18, 0xffffc000000001ffLL, + 28, 64, 18, 0xffffc000000003ffLL, + 29, 64, 18, 0xffffc000000007ffLL, + 30, 64, 18, 0xffffc00000000fffLL, + 31, 64, 18, 0xffffc00000001fffLL, + 32, 64, 18, 0xffffc00000003fffLL, + 33, 64, 18, 0xffffc00000007fffLL, + 34, 64, 18, 0xffffc0000000ffffLL, + 35, 64, 18, 0xffffc0000001ffffLL, + 36, 64, 18, 0xffffc0000003ffffLL, + 37, 64, 18, 0xffffc0000007ffffLL, + 38, 64, 18, 0xffffc000000fffffLL, + 39, 64, 18, 0xffffc000001fffffLL, + 40, 64, 18, 0xffffc000003fffffLL, + 41, 64, 18, 0xffffc000007fffffLL, + 42, 64, 18, 0xffffc00000ffffffLL, + 43, 64, 18, 0xffffc00001ffffffLL, + 44, 64, 18, 0xffffc00003ffffffLL, + 45, 64, 18, 0xffffc00007ffffffLL, + 46, 64, 18, 0xffffc0000fffffffLL, + 47, 64, 18, 0xffffc0001fffffffLL, + 48, 64, 18, 0xffffc0003fffffffLL, + 49, 64, 18, 0xffffc0007fffffffLL, + 18, 32, 18, 0xffffc000ffffc000LL, + 50, 64, 18, 0xffffc000ffffffffLL, + 19, 32, 18, 0xffffc001ffffc001LL, + 51, 64, 18, 0xffffc001ffffffffLL, + 20, 32, 18, 0xffffc003ffffc003LL, + 52, 64, 18, 0xffffc003ffffffffLL, + 21, 32, 18, 0xffffc007ffffc007LL, + 53, 64, 18, 0xffffc007ffffffffLL, + 22, 32, 18, 0xffffc00fffffc00fLL, + 54, 64, 18, 0xffffc00fffffffffLL, + 23, 32, 18, 0xffffc01fffffc01fLL, + 55, 64, 18, 0xffffc01fffffffffLL, + 24, 32, 18, 0xffffc03fffffc03fLL, + 56, 64, 18, 0xffffc03fffffffffLL, + 25, 32, 18, 0xffffc07fffffc07fLL, + 57, 64, 18, 0xffffc07fffffffffLL, + 26, 32, 18, 0xffffc0ffffffc0ffLL, + 58, 64, 18, 0xffffc0ffffffffffLL, + 27, 32, 18, 0xffffc1ffffffc1ffLL, + 59, 64, 18, 0xffffc1ffffffffffLL, + 28, 32, 18, 0xffffc3ffffffc3ffLL, + 60, 64, 18, 0xffffc3ffffffffffLL, + 29, 32, 18, 0xffffc7ffffffc7ffLL, + 61, 64, 18, 0xffffc7ffffffffffLL, + 30, 32, 18, 0xffffcfffffffcfffLL, + 62, 64, 18, 0xffffcfffffffffffLL, + 31, 32, 18, 0xffffdfffffffdfffLL, + 63, 64, 18, 0xffffdfffffffffffLL, + 19, 64, 19, 0xffffe00000000000LL, + 20, 64, 19, 0xffffe00000000001LL, + 21, 64, 19, 0xffffe00000000003LL, + 22, 64, 19, 0xffffe00000000007LL, + 23, 64, 19, 0xffffe0000000000fLL, + 24, 64, 19, 0xffffe0000000001fLL, + 25, 64, 19, 0xffffe0000000003fLL, + 26, 64, 19, 0xffffe0000000007fLL, + 27, 64, 19, 0xffffe000000000ffLL, + 28, 64, 19, 0xffffe000000001ffLL, + 29, 64, 19, 0xffffe000000003ffLL, + 30, 64, 19, 0xffffe000000007ffLL, + 31, 64, 19, 0xffffe00000000fffLL, + 32, 64, 19, 0xffffe00000001fffLL, + 33, 64, 19, 0xffffe00000003fffLL, + 34, 64, 19, 0xffffe00000007fffLL, + 35, 64, 19, 0xffffe0000000ffffLL, + 36, 64, 19, 0xffffe0000001ffffLL, + 37, 64, 19, 0xffffe0000003ffffLL, + 38, 64, 19, 0xffffe0000007ffffLL, + 39, 64, 19, 0xffffe000000fffffLL, + 40, 64, 19, 0xffffe000001fffffLL, + 41, 64, 19, 0xffffe000003fffffLL, + 42, 64, 19, 0xffffe000007fffffLL, + 43, 64, 19, 0xffffe00000ffffffLL, + 44, 64, 19, 0xffffe00001ffffffLL, + 45, 64, 19, 0xffffe00003ffffffLL, + 46, 64, 19, 0xffffe00007ffffffLL, + 47, 64, 19, 0xffffe0000fffffffLL, + 48, 64, 19, 0xffffe0001fffffffLL, + 49, 64, 19, 0xffffe0003fffffffLL, + 50, 64, 19, 0xffffe0007fffffffLL, + 19, 32, 19, 0xffffe000ffffe000LL, + 51, 64, 19, 0xffffe000ffffffffLL, + 20, 32, 19, 0xffffe001ffffe001LL, + 52, 64, 19, 0xffffe001ffffffffLL, + 21, 32, 19, 0xffffe003ffffe003LL, + 53, 64, 19, 0xffffe003ffffffffLL, + 22, 32, 19, 0xffffe007ffffe007LL, + 54, 64, 19, 0xffffe007ffffffffLL, + 23, 32, 19, 0xffffe00fffffe00fLL, + 55, 64, 19, 0xffffe00fffffffffLL, + 24, 32, 19, 0xffffe01fffffe01fLL, + 56, 64, 19, 0xffffe01fffffffffLL, + 25, 32, 19, 0xffffe03fffffe03fLL, + 57, 64, 19, 0xffffe03fffffffffLL, + 26, 32, 19, 0xffffe07fffffe07fLL, + 58, 64, 19, 0xffffe07fffffffffLL, + 27, 32, 19, 0xffffe0ffffffe0ffLL, + 59, 64, 19, 0xffffe0ffffffffffLL, + 28, 32, 19, 0xffffe1ffffffe1ffLL, + 60, 64, 19, 0xffffe1ffffffffffLL, + 29, 32, 19, 0xffffe3ffffffe3ffLL, + 61, 64, 19, 0xffffe3ffffffffffLL, + 30, 32, 19, 0xffffe7ffffffe7ffLL, + 62, 64, 19, 0xffffe7ffffffffffLL, + 31, 32, 19, 0xffffefffffffefffLL, + 63, 64, 19, 0xffffefffffffffffLL, + 20, 64, 20, 0xfffff00000000000LL, + 21, 64, 20, 0xfffff00000000001LL, + 22, 64, 20, 0xfffff00000000003LL, + 23, 64, 20, 0xfffff00000000007LL, + 24, 64, 20, 0xfffff0000000000fLL, + 25, 64, 20, 0xfffff0000000001fLL, + 26, 64, 20, 0xfffff0000000003fLL, + 27, 64, 20, 0xfffff0000000007fLL, + 28, 64, 20, 0xfffff000000000ffLL, + 29, 64, 20, 0xfffff000000001ffLL, + 30, 64, 20, 0xfffff000000003ffLL, + 31, 64, 20, 0xfffff000000007ffLL, + 32, 64, 20, 0xfffff00000000fffLL, + 33, 64, 20, 0xfffff00000001fffLL, + 34, 64, 20, 0xfffff00000003fffLL, + 35, 64, 20, 0xfffff00000007fffLL, + 36, 64, 20, 0xfffff0000000ffffLL, + 37, 64, 20, 0xfffff0000001ffffLL, + 38, 64, 20, 0xfffff0000003ffffLL, + 39, 64, 20, 0xfffff0000007ffffLL, + 40, 64, 20, 0xfffff000000fffffLL, + 41, 64, 20, 0xfffff000001fffffLL, + 42, 64, 20, 0xfffff000003fffffLL, + 43, 64, 20, 0xfffff000007fffffLL, + 44, 64, 20, 0xfffff00000ffffffLL, + 45, 64, 20, 0xfffff00001ffffffLL, + 46, 64, 20, 0xfffff00003ffffffLL, + 47, 64, 20, 0xfffff00007ffffffLL, + 48, 64, 20, 0xfffff0000fffffffLL, + 49, 64, 20, 0xfffff0001fffffffLL, + 50, 64, 20, 0xfffff0003fffffffLL, + 51, 64, 20, 0xfffff0007fffffffLL, + 20, 32, 20, 0xfffff000fffff000LL, + 52, 64, 20, 0xfffff000ffffffffLL, + 21, 32, 20, 0xfffff001fffff001LL, + 53, 64, 20, 0xfffff001ffffffffLL, + 22, 32, 20, 0xfffff003fffff003LL, + 54, 64, 20, 0xfffff003ffffffffLL, + 23, 32, 20, 0xfffff007fffff007LL, + 55, 64, 20, 0xfffff007ffffffffLL, + 24, 32, 20, 0xfffff00ffffff00fLL, + 56, 64, 20, 0xfffff00fffffffffLL, + 25, 32, 20, 0xfffff01ffffff01fLL, + 57, 64, 20, 0xfffff01fffffffffLL, + 26, 32, 20, 0xfffff03ffffff03fLL, + 58, 64, 20, 0xfffff03fffffffffLL, + 27, 32, 20, 0xfffff07ffffff07fLL, + 59, 64, 20, 0xfffff07fffffffffLL, + 28, 32, 20, 0xfffff0fffffff0ffLL, + 60, 64, 20, 0xfffff0ffffffffffLL, + 29, 32, 20, 0xfffff1fffffff1ffLL, + 61, 64, 20, 0xfffff1ffffffffffLL, + 30, 32, 20, 0xfffff3fffffff3ffLL, + 62, 64, 20, 0xfffff3ffffffffffLL, + 31, 32, 20, 0xfffff7fffffff7ffLL, + 63, 64, 20, 0xfffff7ffffffffffLL, + 21, 64, 21, 0xfffff80000000000LL, + 22, 64, 21, 0xfffff80000000001LL, + 23, 64, 21, 0xfffff80000000003LL, + 24, 64, 21, 0xfffff80000000007LL, + 25, 64, 21, 0xfffff8000000000fLL, + 26, 64, 21, 0xfffff8000000001fLL, + 27, 64, 21, 0xfffff8000000003fLL, + 28, 64, 21, 0xfffff8000000007fLL, + 29, 64, 21, 0xfffff800000000ffLL, + 30, 64, 21, 0xfffff800000001ffLL, + 31, 64, 21, 0xfffff800000003ffLL, + 32, 64, 21, 0xfffff800000007ffLL, + 33, 64, 21, 0xfffff80000000fffLL, + 34, 64, 21, 0xfffff80000001fffLL, + 35, 64, 21, 0xfffff80000003fffLL, + 36, 64, 21, 0xfffff80000007fffLL, + 37, 64, 21, 0xfffff8000000ffffLL, + 38, 64, 21, 0xfffff8000001ffffLL, + 39, 64, 21, 0xfffff8000003ffffLL, + 40, 64, 21, 0xfffff8000007ffffLL, + 41, 64, 21, 0xfffff800000fffffLL, + 42, 64, 21, 0xfffff800001fffffLL, + 43, 64, 21, 0xfffff800003fffffLL, + 44, 64, 21, 0xfffff800007fffffLL, + 45, 64, 21, 0xfffff80000ffffffLL, + 46, 64, 21, 0xfffff80001ffffffLL, + 47, 64, 21, 0xfffff80003ffffffLL, + 48, 64, 21, 0xfffff80007ffffffLL, + 49, 64, 21, 0xfffff8000fffffffLL, + 50, 64, 21, 0xfffff8001fffffffLL, + 51, 64, 21, 0xfffff8003fffffffLL, + 52, 64, 21, 0xfffff8007fffffffLL, + 21, 32, 21, 0xfffff800fffff800LL, + 53, 64, 21, 0xfffff800ffffffffLL, + 22, 32, 21, 0xfffff801fffff801LL, + 54, 64, 21, 0xfffff801ffffffffLL, + 23, 32, 21, 0xfffff803fffff803LL, + 55, 64, 21, 0xfffff803ffffffffLL, + 24, 32, 21, 0xfffff807fffff807LL, + 56, 64, 21, 0xfffff807ffffffffLL, + 25, 32, 21, 0xfffff80ffffff80fLL, + 57, 64, 21, 0xfffff80fffffffffLL, + 26, 32, 21, 0xfffff81ffffff81fLL, + 58, 64, 21, 0xfffff81fffffffffLL, + 27, 32, 21, 0xfffff83ffffff83fLL, + 59, 64, 21, 0xfffff83fffffffffLL, + 28, 32, 21, 0xfffff87ffffff87fLL, + 60, 64, 21, 0xfffff87fffffffffLL, + 29, 32, 21, 0xfffff8fffffff8ffLL, + 61, 64, 21, 0xfffff8ffffffffffLL, + 30, 32, 21, 0xfffff9fffffff9ffLL, + 62, 64, 21, 0xfffff9ffffffffffLL, + 31, 32, 21, 0xfffffbfffffffbffLL, + 63, 64, 21, 0xfffffbffffffffffLL, + 22, 64, 22, 0xfffffc0000000000LL, + 23, 64, 22, 0xfffffc0000000001LL, + 24, 64, 22, 0xfffffc0000000003LL, + 25, 64, 22, 0xfffffc0000000007LL, + 26, 64, 22, 0xfffffc000000000fLL, + 27, 64, 22, 0xfffffc000000001fLL, + 28, 64, 22, 0xfffffc000000003fLL, + 29, 64, 22, 0xfffffc000000007fLL, + 30, 64, 22, 0xfffffc00000000ffLL, + 31, 64, 22, 0xfffffc00000001ffLL, + 32, 64, 22, 0xfffffc00000003ffLL, + 33, 64, 22, 0xfffffc00000007ffLL, + 34, 64, 22, 0xfffffc0000000fffLL, + 35, 64, 22, 0xfffffc0000001fffLL, + 36, 64, 22, 0xfffffc0000003fffLL, + 37, 64, 22, 0xfffffc0000007fffLL, + 38, 64, 22, 0xfffffc000000ffffLL, + 39, 64, 22, 0xfffffc000001ffffLL, + 40, 64, 22, 0xfffffc000003ffffLL, + 41, 64, 22, 0xfffffc000007ffffLL, + 42, 64, 22, 0xfffffc00000fffffLL, + 43, 64, 22, 0xfffffc00001fffffLL, + 44, 64, 22, 0xfffffc00003fffffLL, + 45, 64, 22, 0xfffffc00007fffffLL, + 46, 64, 22, 0xfffffc0000ffffffLL, + 47, 64, 22, 0xfffffc0001ffffffLL, + 48, 64, 22, 0xfffffc0003ffffffLL, + 49, 64, 22, 0xfffffc0007ffffffLL, + 50, 64, 22, 0xfffffc000fffffffLL, + 51, 64, 22, 0xfffffc001fffffffLL, + 52, 64, 22, 0xfffffc003fffffffLL, + 53, 64, 22, 0xfffffc007fffffffLL, + 22, 32, 22, 0xfffffc00fffffc00LL, + 54, 64, 22, 0xfffffc00ffffffffLL, + 23, 32, 22, 0xfffffc01fffffc01LL, + 55, 64, 22, 0xfffffc01ffffffffLL, + 24, 32, 22, 0xfffffc03fffffc03LL, + 56, 64, 22, 0xfffffc03ffffffffLL, + 25, 32, 22, 0xfffffc07fffffc07LL, + 57, 64, 22, 0xfffffc07ffffffffLL, + 26, 32, 22, 0xfffffc0ffffffc0fLL, + 58, 64, 22, 0xfffffc0fffffffffLL, + 27, 32, 22, 0xfffffc1ffffffc1fLL, + 59, 64, 22, 0xfffffc1fffffffffLL, + 28, 32, 22, 0xfffffc3ffffffc3fLL, + 60, 64, 22, 0xfffffc3fffffffffLL, + 29, 32, 22, 0xfffffc7ffffffc7fLL, + 61, 64, 22, 0xfffffc7fffffffffLL, + 30, 32, 22, 0xfffffcfffffffcffLL, + 62, 64, 22, 0xfffffcffffffffffLL, + 31, 32, 22, 0xfffffdfffffffdffLL, + 63, 64, 22, 0xfffffdffffffffffLL, + 23, 64, 23, 0xfffffe0000000000LL, + 24, 64, 23, 0xfffffe0000000001LL, + 25, 64, 23, 0xfffffe0000000003LL, + 26, 64, 23, 0xfffffe0000000007LL, + 27, 64, 23, 0xfffffe000000000fLL, + 28, 64, 23, 0xfffffe000000001fLL, + 29, 64, 23, 0xfffffe000000003fLL, + 30, 64, 23, 0xfffffe000000007fLL, + 31, 64, 23, 0xfffffe00000000ffLL, + 32, 64, 23, 0xfffffe00000001ffLL, + 33, 64, 23, 0xfffffe00000003ffLL, + 34, 64, 23, 0xfffffe00000007ffLL, + 35, 64, 23, 0xfffffe0000000fffLL, + 36, 64, 23, 0xfffffe0000001fffLL, + 37, 64, 23, 0xfffffe0000003fffLL, + 38, 64, 23, 0xfffffe0000007fffLL, + 39, 64, 23, 0xfffffe000000ffffLL, + 40, 64, 23, 0xfffffe000001ffffLL, + 41, 64, 23, 0xfffffe000003ffffLL, + 42, 64, 23, 0xfffffe000007ffffLL, + 43, 64, 23, 0xfffffe00000fffffLL, + 44, 64, 23, 0xfffffe00001fffffLL, + 45, 64, 23, 0xfffffe00003fffffLL, + 46, 64, 23, 0xfffffe00007fffffLL, + 47, 64, 23, 0xfffffe0000ffffffLL, + 48, 64, 23, 0xfffffe0001ffffffLL, + 49, 64, 23, 0xfffffe0003ffffffLL, + 50, 64, 23, 0xfffffe0007ffffffLL, + 51, 64, 23, 0xfffffe000fffffffLL, + 52, 64, 23, 0xfffffe001fffffffLL, + 53, 64, 23, 0xfffffe003fffffffLL, + 54, 64, 23, 0xfffffe007fffffffLL, + 23, 32, 23, 0xfffffe00fffffe00LL, + 55, 64, 23, 0xfffffe00ffffffffLL, + 24, 32, 23, 0xfffffe01fffffe01LL, + 56, 64, 23, 0xfffffe01ffffffffLL, + 25, 32, 23, 0xfffffe03fffffe03LL, + 57, 64, 23, 0xfffffe03ffffffffLL, + 26, 32, 23, 0xfffffe07fffffe07LL, + 58, 64, 23, 0xfffffe07ffffffffLL, + 27, 32, 23, 0xfffffe0ffffffe0fLL, + 59, 64, 23, 0xfffffe0fffffffffLL, + 28, 32, 23, 0xfffffe1ffffffe1fLL, + 60, 64, 23, 0xfffffe1fffffffffLL, + 29, 32, 23, 0xfffffe3ffffffe3fLL, + 61, 64, 23, 0xfffffe3fffffffffLL, + 30, 32, 23, 0xfffffe7ffffffe7fLL, + 62, 64, 23, 0xfffffe7fffffffffLL, + 31, 32, 23, 0xfffffefffffffeffLL, + 63, 64, 23, 0xfffffeffffffffffLL, + 24, 64, 24, 0xffffff0000000000LL, + 25, 64, 24, 0xffffff0000000001LL, + 26, 64, 24, 0xffffff0000000003LL, + 27, 64, 24, 0xffffff0000000007LL, + 28, 64, 24, 0xffffff000000000fLL, + 29, 64, 24, 0xffffff000000001fLL, + 30, 64, 24, 0xffffff000000003fLL, + 31, 64, 24, 0xffffff000000007fLL, + 32, 64, 24, 0xffffff00000000ffLL, + 33, 64, 24, 0xffffff00000001ffLL, + 34, 64, 24, 0xffffff00000003ffLL, + 35, 64, 24, 0xffffff00000007ffLL, + 36, 64, 24, 0xffffff0000000fffLL, + 37, 64, 24, 0xffffff0000001fffLL, + 38, 64, 24, 0xffffff0000003fffLL, + 39, 64, 24, 0xffffff0000007fffLL, + 40, 64, 24, 0xffffff000000ffffLL, + 41, 64, 24, 0xffffff000001ffffLL, + 42, 64, 24, 0xffffff000003ffffLL, + 43, 64, 24, 0xffffff000007ffffLL, + 44, 64, 24, 0xffffff00000fffffLL, + 45, 64, 24, 0xffffff00001fffffLL, + 46, 64, 24, 0xffffff00003fffffLL, + 47, 64, 24, 0xffffff00007fffffLL, + 48, 64, 24, 0xffffff0000ffffffLL, + 49, 64, 24, 0xffffff0001ffffffLL, + 50, 64, 24, 0xffffff0003ffffffLL, + 51, 64, 24, 0xffffff0007ffffffLL, + 52, 64, 24, 0xffffff000fffffffLL, + 53, 64, 24, 0xffffff001fffffffLL, + 54, 64, 24, 0xffffff003fffffffLL, + 55, 64, 24, 0xffffff007fffffffLL, + 24, 32, 24, 0xffffff00ffffff00LL, + 56, 64, 24, 0xffffff00ffffffffLL, + 25, 32, 24, 0xffffff01ffffff01LL, + 57, 64, 24, 0xffffff01ffffffffLL, + 26, 32, 24, 0xffffff03ffffff03LL, + 58, 64, 24, 0xffffff03ffffffffLL, + 27, 32, 24, 0xffffff07ffffff07LL, + 59, 64, 24, 0xffffff07ffffffffLL, + 28, 32, 24, 0xffffff0fffffff0fLL, + 60, 64, 24, 0xffffff0fffffffffLL, + 29, 32, 24, 0xffffff1fffffff1fLL, + 61, 64, 24, 0xffffff1fffffffffLL, + 30, 32, 24, 0xffffff3fffffff3fLL, + 62, 64, 24, 0xffffff3fffffffffLL, + 31, 32, 24, 0xffffff7fffffff7fLL, + 63, 64, 24, 0xffffff7fffffffffLL, + 25, 64, 25, 0xffffff8000000000LL, + 26, 64, 25, 0xffffff8000000001LL, + 27, 64, 25, 0xffffff8000000003LL, + 28, 64, 25, 0xffffff8000000007LL, + 29, 64, 25, 0xffffff800000000fLL, + 30, 64, 25, 0xffffff800000001fLL, + 31, 64, 25, 0xffffff800000003fLL, + 32, 64, 25, 0xffffff800000007fLL, + 33, 64, 25, 0xffffff80000000ffLL, + 34, 64, 25, 0xffffff80000001ffLL, + 35, 64, 25, 0xffffff80000003ffLL, + 36, 64, 25, 0xffffff80000007ffLL, + 37, 64, 25, 0xffffff8000000fffLL, + 38, 64, 25, 0xffffff8000001fffLL, + 39, 64, 25, 0xffffff8000003fffLL, + 40, 64, 25, 0xffffff8000007fffLL, + 41, 64, 25, 0xffffff800000ffffLL, + 42, 64, 25, 0xffffff800001ffffLL, + 43, 64, 25, 0xffffff800003ffffLL, + 44, 64, 25, 0xffffff800007ffffLL, + 45, 64, 25, 0xffffff80000fffffLL, + 46, 64, 25, 0xffffff80001fffffLL, + 47, 64, 25, 0xffffff80003fffffLL, + 48, 64, 25, 0xffffff80007fffffLL, + 49, 64, 25, 0xffffff8000ffffffLL, + 50, 64, 25, 0xffffff8001ffffffLL, + 51, 64, 25, 0xffffff8003ffffffLL, + 52, 64, 25, 0xffffff8007ffffffLL, + 53, 64, 25, 0xffffff800fffffffLL, + 54, 64, 25, 0xffffff801fffffffLL, + 55, 64, 25, 0xffffff803fffffffLL, + 56, 64, 25, 0xffffff807fffffffLL, + 25, 32, 25, 0xffffff80ffffff80LL, + 57, 64, 25, 0xffffff80ffffffffLL, + 26, 32, 25, 0xffffff81ffffff81LL, + 58, 64, 25, 0xffffff81ffffffffLL, + 27, 32, 25, 0xffffff83ffffff83LL, + 59, 64, 25, 0xffffff83ffffffffLL, + 28, 32, 25, 0xffffff87ffffff87LL, + 60, 64, 25, 0xffffff87ffffffffLL, + 29, 32, 25, 0xffffff8fffffff8fLL, + 61, 64, 25, 0xffffff8fffffffffLL, + 30, 32, 25, 0xffffff9fffffff9fLL, + 62, 64, 25, 0xffffff9fffffffffLL, + 31, 32, 25, 0xffffffbfffffffbfLL, + 63, 64, 25, 0xffffffbfffffffffLL, + 26, 64, 26, 0xffffffc000000000LL, + 27, 64, 26, 0xffffffc000000001LL, + 28, 64, 26, 0xffffffc000000003LL, + 29, 64, 26, 0xffffffc000000007LL, + 30, 64, 26, 0xffffffc00000000fLL, + 31, 64, 26, 0xffffffc00000001fLL, + 32, 64, 26, 0xffffffc00000003fLL, + 33, 64, 26, 0xffffffc00000007fLL, + 34, 64, 26, 0xffffffc0000000ffLL, + 35, 64, 26, 0xffffffc0000001ffLL, + 36, 64, 26, 0xffffffc0000003ffLL, + 37, 64, 26, 0xffffffc0000007ffLL, + 38, 64, 26, 0xffffffc000000fffLL, + 39, 64, 26, 0xffffffc000001fffLL, + 40, 64, 26, 0xffffffc000003fffLL, + 41, 64, 26, 0xffffffc000007fffLL, + 42, 64, 26, 0xffffffc00000ffffLL, + 43, 64, 26, 0xffffffc00001ffffLL, + 44, 64, 26, 0xffffffc00003ffffLL, + 45, 64, 26, 0xffffffc00007ffffLL, + 46, 64, 26, 0xffffffc0000fffffLL, + 47, 64, 26, 0xffffffc0001fffffLL, + 48, 64, 26, 0xffffffc0003fffffLL, + 49, 64, 26, 0xffffffc0007fffffLL, + 50, 64, 26, 0xffffffc000ffffffLL, + 51, 64, 26, 0xffffffc001ffffffLL, + 52, 64, 26, 0xffffffc003ffffffLL, + 53, 64, 26, 0xffffffc007ffffffLL, + 54, 64, 26, 0xffffffc00fffffffLL, + 55, 64, 26, 0xffffffc01fffffffLL, + 56, 64, 26, 0xffffffc03fffffffLL, + 57, 64, 26, 0xffffffc07fffffffLL, + 26, 32, 26, 0xffffffc0ffffffc0LL, + 58, 64, 26, 0xffffffc0ffffffffLL, + 27, 32, 26, 0xffffffc1ffffffc1LL, + 59, 64, 26, 0xffffffc1ffffffffLL, + 28, 32, 26, 0xffffffc3ffffffc3LL, + 60, 64, 26, 0xffffffc3ffffffffLL, + 29, 32, 26, 0xffffffc7ffffffc7LL, + 61, 64, 26, 0xffffffc7ffffffffLL, + 30, 32, 26, 0xffffffcfffffffcfLL, + 62, 64, 26, 0xffffffcfffffffffLL, + 31, 32, 26, 0xffffffdfffffffdfLL, + 63, 64, 26, 0xffffffdfffffffffLL, + 27, 64, 27, 0xffffffe000000000LL, + 28, 64, 27, 0xffffffe000000001LL, + 29, 64, 27, 0xffffffe000000003LL, + 30, 64, 27, 0xffffffe000000007LL, + 31, 64, 27, 0xffffffe00000000fLL, + 32, 64, 27, 0xffffffe00000001fLL, + 33, 64, 27, 0xffffffe00000003fLL, + 34, 64, 27, 0xffffffe00000007fLL, + 35, 64, 27, 0xffffffe0000000ffLL, + 36, 64, 27, 0xffffffe0000001ffLL, + 37, 64, 27, 0xffffffe0000003ffLL, + 38, 64, 27, 0xffffffe0000007ffLL, + 39, 64, 27, 0xffffffe000000fffLL, + 40, 64, 27, 0xffffffe000001fffLL, + 41, 64, 27, 0xffffffe000003fffLL, + 42, 64, 27, 0xffffffe000007fffLL, + 43, 64, 27, 0xffffffe00000ffffLL, + 44, 64, 27, 0xffffffe00001ffffLL, + 45, 64, 27, 0xffffffe00003ffffLL, + 46, 64, 27, 0xffffffe00007ffffLL, + 47, 64, 27, 0xffffffe0000fffffLL, + 48, 64, 27, 0xffffffe0001fffffLL, + 49, 64, 27, 0xffffffe0003fffffLL, + 50, 64, 27, 0xffffffe0007fffffLL, + 51, 64, 27, 0xffffffe000ffffffLL, + 52, 64, 27, 0xffffffe001ffffffLL, + 53, 64, 27, 0xffffffe003ffffffLL, + 54, 64, 27, 0xffffffe007ffffffLL, + 55, 64, 27, 0xffffffe00fffffffLL, + 56, 64, 27, 0xffffffe01fffffffLL, + 57, 64, 27, 0xffffffe03fffffffLL, + 58, 64, 27, 0xffffffe07fffffffLL, + 27, 32, 27, 0xffffffe0ffffffe0LL, + 59, 64, 27, 0xffffffe0ffffffffLL, + 28, 32, 27, 0xffffffe1ffffffe1LL, + 60, 64, 27, 0xffffffe1ffffffffLL, + 29, 32, 27, 0xffffffe3ffffffe3LL, + 61, 64, 27, 0xffffffe3ffffffffLL, + 30, 32, 27, 0xffffffe7ffffffe7LL, + 62, 64, 27, 0xffffffe7ffffffffLL, + 31, 32, 27, 0xffffffefffffffefLL, + 63, 64, 27, 0xffffffefffffffffLL, + 28, 64, 28, 0xfffffff000000000LL, + 29, 64, 28, 0xfffffff000000001LL, + 30, 64, 28, 0xfffffff000000003LL, + 31, 64, 28, 0xfffffff000000007LL, + 32, 64, 28, 0xfffffff00000000fLL, + 33, 64, 28, 0xfffffff00000001fLL, + 34, 64, 28, 0xfffffff00000003fLL, + 35, 64, 28, 0xfffffff00000007fLL, + 36, 64, 28, 0xfffffff0000000ffLL, + 37, 64, 28, 0xfffffff0000001ffLL, + 38, 64, 28, 0xfffffff0000003ffLL, + 39, 64, 28, 0xfffffff0000007ffLL, + 40, 64, 28, 0xfffffff000000fffLL, + 41, 64, 28, 0xfffffff000001fffLL, + 42, 64, 28, 0xfffffff000003fffLL, + 43, 64, 28, 0xfffffff000007fffLL, + 44, 64, 28, 0xfffffff00000ffffLL, + 45, 64, 28, 0xfffffff00001ffffLL, + 46, 64, 28, 0xfffffff00003ffffLL, + 47, 64, 28, 0xfffffff00007ffffLL, + 48, 64, 28, 0xfffffff0000fffffLL, + 49, 64, 28, 0xfffffff0001fffffLL, + 50, 64, 28, 0xfffffff0003fffffLL, + 51, 64, 28, 0xfffffff0007fffffLL, + 52, 64, 28, 0xfffffff000ffffffLL, + 53, 64, 28, 0xfffffff001ffffffLL, + 54, 64, 28, 0xfffffff003ffffffLL, + 55, 64, 28, 0xfffffff007ffffffLL, + 56, 64, 28, 0xfffffff00fffffffLL, + 57, 64, 28, 0xfffffff01fffffffLL, + 58, 64, 28, 0xfffffff03fffffffLL, + 59, 64, 28, 0xfffffff07fffffffLL, + 28, 32, 28, 0xfffffff0fffffff0LL, + 60, 64, 28, 0xfffffff0ffffffffLL, + 29, 32, 28, 0xfffffff1fffffff1LL, + 61, 64, 28, 0xfffffff1ffffffffLL, + 30, 32, 28, 0xfffffff3fffffff3LL, + 62, 64, 28, 0xfffffff3ffffffffLL, + 31, 32, 28, 0xfffffff7fffffff7LL, + 63, 64, 28, 0xfffffff7ffffffffLL, + 29, 64, 29, 0xfffffff800000000LL, + 30, 64, 29, 0xfffffff800000001LL, + 31, 64, 29, 0xfffffff800000003LL, + 32, 64, 29, 0xfffffff800000007LL, + 33, 64, 29, 0xfffffff80000000fLL, + 34, 64, 29, 0xfffffff80000001fLL, + 35, 64, 29, 0xfffffff80000003fLL, + 36, 64, 29, 0xfffffff80000007fLL, + 37, 64, 29, 0xfffffff8000000ffLL, + 38, 64, 29, 0xfffffff8000001ffLL, + 39, 64, 29, 0xfffffff8000003ffLL, + 40, 64, 29, 0xfffffff8000007ffLL, + 41, 64, 29, 0xfffffff800000fffLL, + 42, 64, 29, 0xfffffff800001fffLL, + 43, 64, 29, 0xfffffff800003fffLL, + 44, 64, 29, 0xfffffff800007fffLL, + 45, 64, 29, 0xfffffff80000ffffLL, + 46, 64, 29, 0xfffffff80001ffffLL, + 47, 64, 29, 0xfffffff80003ffffLL, + 48, 64, 29, 0xfffffff80007ffffLL, + 49, 64, 29, 0xfffffff8000fffffLL, + 50, 64, 29, 0xfffffff8001fffffLL, + 51, 64, 29, 0xfffffff8003fffffLL, + 52, 64, 29, 0xfffffff8007fffffLL, + 53, 64, 29, 0xfffffff800ffffffLL, + 54, 64, 29, 0xfffffff801ffffffLL, + 55, 64, 29, 0xfffffff803ffffffLL, + 56, 64, 29, 0xfffffff807ffffffLL, + 57, 64, 29, 0xfffffff80fffffffLL, + 58, 64, 29, 0xfffffff81fffffffLL, + 59, 64, 29, 0xfffffff83fffffffLL, + 60, 64, 29, 0xfffffff87fffffffLL, + 29, 32, 29, 0xfffffff8fffffff8LL, + 61, 64, 29, 0xfffffff8ffffffffLL, + 30, 32, 29, 0xfffffff9fffffff9LL, + 62, 64, 29, 0xfffffff9ffffffffLL, + 31, 32, 29, 0xfffffffbfffffffbLL, + 63, 64, 29, 0xfffffffbffffffffLL, + 30, 64, 30, 0xfffffffc00000000LL, + 31, 64, 30, 0xfffffffc00000001LL, + 32, 64, 30, 0xfffffffc00000003LL, + 33, 64, 30, 0xfffffffc00000007LL, + 34, 64, 30, 0xfffffffc0000000fLL, + 35, 64, 30, 0xfffffffc0000001fLL, + 36, 64, 30, 0xfffffffc0000003fLL, + 37, 64, 30, 0xfffffffc0000007fLL, + 38, 64, 30, 0xfffffffc000000ffLL, + 39, 64, 30, 0xfffffffc000001ffLL, + 40, 64, 30, 0xfffffffc000003ffLL, + 41, 64, 30, 0xfffffffc000007ffLL, + 42, 64, 30, 0xfffffffc00000fffLL, + 43, 64, 30, 0xfffffffc00001fffLL, + 44, 64, 30, 0xfffffffc00003fffLL, + 45, 64, 30, 0xfffffffc00007fffLL, + 46, 64, 30, 0xfffffffc0000ffffLL, + 47, 64, 30, 0xfffffffc0001ffffLL, + 48, 64, 30, 0xfffffffc0003ffffLL, + 49, 64, 30, 0xfffffffc0007ffffLL, + 50, 64, 30, 0xfffffffc000fffffLL, + 51, 64, 30, 0xfffffffc001fffffLL, + 52, 64, 30, 0xfffffffc003fffffLL, + 53, 64, 30, 0xfffffffc007fffffLL, + 54, 64, 30, 0xfffffffc00ffffffLL, + 55, 64, 30, 0xfffffffc01ffffffLL, + 56, 64, 30, 0xfffffffc03ffffffLL, + 57, 64, 30, 0xfffffffc07ffffffLL, + 58, 64, 30, 0xfffffffc0fffffffLL, + 59, 64, 30, 0xfffffffc1fffffffLL, + 60, 64, 30, 0xfffffffc3fffffffLL, + 61, 64, 30, 0xfffffffc7fffffffLL, + 30, 32, 30, 0xfffffffcfffffffcLL, + 62, 64, 30, 0xfffffffcffffffffLL, + 31, 32, 30, 0xfffffffdfffffffdLL, + 63, 64, 30, 0xfffffffdffffffffLL, + 31, 64, 31, 0xfffffffe00000000LL, + 32, 64, 31, 0xfffffffe00000001LL, + 33, 64, 31, 0xfffffffe00000003LL, + 34, 64, 31, 0xfffffffe00000007LL, + 35, 64, 31, 0xfffffffe0000000fLL, + 36, 64, 31, 0xfffffffe0000001fLL, + 37, 64, 31, 0xfffffffe0000003fLL, + 38, 64, 31, 0xfffffffe0000007fLL, + 39, 64, 31, 0xfffffffe000000ffLL, + 40, 64, 31, 0xfffffffe000001ffLL, + 41, 64, 31, 0xfffffffe000003ffLL, + 42, 64, 31, 0xfffffffe000007ffLL, + 43, 64, 31, 0xfffffffe00000fffLL, + 44, 64, 31, 0xfffffffe00001fffLL, + 45, 64, 31, 0xfffffffe00003fffLL, + 46, 64, 31, 0xfffffffe00007fffLL, + 47, 64, 31, 0xfffffffe0000ffffLL, + 48, 64, 31, 0xfffffffe0001ffffLL, + 49, 64, 31, 0xfffffffe0003ffffLL, + 50, 64, 31, 0xfffffffe0007ffffLL, + 51, 64, 31, 0xfffffffe000fffffLL, + 52, 64, 31, 0xfffffffe001fffffLL, + 53, 64, 31, 0xfffffffe003fffffLL, + 54, 64, 31, 0xfffffffe007fffffLL, + 55, 64, 31, 0xfffffffe00ffffffLL, + 56, 64, 31, 0xfffffffe01ffffffLL, + 57, 64, 31, 0xfffffffe03ffffffLL, + 58, 64, 31, 0xfffffffe07ffffffLL, + 59, 64, 31, 0xfffffffe0fffffffLL, + 60, 64, 31, 0xfffffffe1fffffffLL, + 61, 64, 31, 0xfffffffe3fffffffLL, + 62, 64, 31, 0xfffffffe7fffffffLL, + 31, 32, 31, 0xfffffffefffffffeLL, + 63, 64, 31, 0xfffffffeffffffffLL, + 32, 64, 32, 0xffffffff00000000LL, + 33, 64, 32, 0xffffffff00000001LL, + 34, 64, 32, 0xffffffff00000003LL, + 35, 64, 32, 0xffffffff00000007LL, + 36, 64, 32, 0xffffffff0000000fLL, + 37, 64, 32, 0xffffffff0000001fLL, + 38, 64, 32, 0xffffffff0000003fLL, + 39, 64, 32, 0xffffffff0000007fLL, + 40, 64, 32, 0xffffffff000000ffLL, + 41, 64, 32, 0xffffffff000001ffLL, + 42, 64, 32, 0xffffffff000003ffLL, + 43, 64, 32, 0xffffffff000007ffLL, + 44, 64, 32, 0xffffffff00000fffLL, + 45, 64, 32, 0xffffffff00001fffLL, + 46, 64, 32, 0xffffffff00003fffLL, + 47, 64, 32, 0xffffffff00007fffLL, + 48, 64, 32, 0xffffffff0000ffffLL, + 49, 64, 32, 0xffffffff0001ffffLL, + 50, 64, 32, 0xffffffff0003ffffLL, + 51, 64, 32, 0xffffffff0007ffffLL, + 52, 64, 32, 0xffffffff000fffffLL, + 53, 64, 32, 0xffffffff001fffffLL, + 54, 64, 32, 0xffffffff003fffffLL, + 55, 64, 32, 0xffffffff007fffffLL, + 56, 64, 32, 0xffffffff00ffffffLL, + 57, 64, 32, 0xffffffff01ffffffLL, + 58, 64, 32, 0xffffffff03ffffffLL, + 59, 64, 32, 0xffffffff07ffffffLL, + 60, 64, 32, 0xffffffff0fffffffLL, + 61, 64, 32, 0xffffffff1fffffffLL, + 62, 64, 32, 0xffffffff3fffffffLL, + 63, 64, 32, 0xffffffff7fffffffLL, + 33, 64, 33, 0xffffffff80000000LL, + 34, 64, 33, 0xffffffff80000001LL, + 35, 64, 33, 0xffffffff80000003LL, + 36, 64, 33, 0xffffffff80000007LL, + 37, 64, 33, 0xffffffff8000000fLL, + 38, 64, 33, 0xffffffff8000001fLL, + 39, 64, 33, 0xffffffff8000003fLL, + 40, 64, 33, 0xffffffff8000007fLL, + 41, 64, 33, 0xffffffff800000ffLL, + 42, 64, 33, 0xffffffff800001ffLL, + 43, 64, 33, 0xffffffff800003ffLL, + 44, 64, 33, 0xffffffff800007ffLL, + 45, 64, 33, 0xffffffff80000fffLL, + 46, 64, 33, 0xffffffff80001fffLL, + 47, 64, 33, 0xffffffff80003fffLL, + 48, 64, 33, 0xffffffff80007fffLL, + 49, 64, 33, 0xffffffff8000ffffLL, + 50, 64, 33, 0xffffffff8001ffffLL, + 51, 64, 33, 0xffffffff8003ffffLL, + 52, 64, 33, 0xffffffff8007ffffLL, + 53, 64, 33, 0xffffffff800fffffLL, + 54, 64, 33, 0xffffffff801fffffLL, + 55, 64, 33, 0xffffffff803fffffLL, + 56, 64, 33, 0xffffffff807fffffLL, + 57, 64, 33, 0xffffffff80ffffffLL, + 58, 64, 33, 0xffffffff81ffffffLL, + 59, 64, 33, 0xffffffff83ffffffLL, + 60, 64, 33, 0xffffffff87ffffffLL, + 61, 64, 33, 0xffffffff8fffffffLL, + 62, 64, 33, 0xffffffff9fffffffLL, + 63, 64, 33, 0xffffffffbfffffffLL, + 34, 64, 34, 0xffffffffc0000000LL, + 35, 64, 34, 0xffffffffc0000001LL, + 36, 64, 34, 0xffffffffc0000003LL, + 37, 64, 34, 0xffffffffc0000007LL, + 38, 64, 34, 0xffffffffc000000fLL, + 39, 64, 34, 0xffffffffc000001fLL, + 40, 64, 34, 0xffffffffc000003fLL, + 41, 64, 34, 0xffffffffc000007fLL, + 42, 64, 34, 0xffffffffc00000ffLL, + 43, 64, 34, 0xffffffffc00001ffLL, + 44, 64, 34, 0xffffffffc00003ffLL, + 45, 64, 34, 0xffffffffc00007ffLL, + 46, 64, 34, 0xffffffffc0000fffLL, + 47, 64, 34, 0xffffffffc0001fffLL, + 48, 64, 34, 0xffffffffc0003fffLL, + 49, 64, 34, 0xffffffffc0007fffLL, + 50, 64, 34, 0xffffffffc000ffffLL, + 51, 64, 34, 0xffffffffc001ffffLL, + 52, 64, 34, 0xffffffffc003ffffLL, + 53, 64, 34, 0xffffffffc007ffffLL, + 54, 64, 34, 0xffffffffc00fffffLL, + 55, 64, 34, 0xffffffffc01fffffLL, + 56, 64, 34, 0xffffffffc03fffffLL, + 57, 64, 34, 0xffffffffc07fffffLL, + 58, 64, 34, 0xffffffffc0ffffffLL, + 59, 64, 34, 0xffffffffc1ffffffLL, + 60, 64, 34, 0xffffffffc3ffffffLL, + 61, 64, 34, 0xffffffffc7ffffffLL, + 62, 64, 34, 0xffffffffcfffffffLL, + 63, 64, 34, 0xffffffffdfffffffLL, + 35, 64, 35, 0xffffffffe0000000LL, + 36, 64, 35, 0xffffffffe0000001LL, + 37, 64, 35, 0xffffffffe0000003LL, + 38, 64, 35, 0xffffffffe0000007LL, + 39, 64, 35, 0xffffffffe000000fLL, + 40, 64, 35, 0xffffffffe000001fLL, + 41, 64, 35, 0xffffffffe000003fLL, + 42, 64, 35, 0xffffffffe000007fLL, + 43, 64, 35, 0xffffffffe00000ffLL, + 44, 64, 35, 0xffffffffe00001ffLL, + 45, 64, 35, 0xffffffffe00003ffLL, + 46, 64, 35, 0xffffffffe00007ffLL, + 47, 64, 35, 0xffffffffe0000fffLL, + 48, 64, 35, 0xffffffffe0001fffLL, + 49, 64, 35, 0xffffffffe0003fffLL, + 50, 64, 35, 0xffffffffe0007fffLL, + 51, 64, 35, 0xffffffffe000ffffLL, + 52, 64, 35, 0xffffffffe001ffffLL, + 53, 64, 35, 0xffffffffe003ffffLL, + 54, 64, 35, 0xffffffffe007ffffLL, + 55, 64, 35, 0xffffffffe00fffffLL, + 56, 64, 35, 0xffffffffe01fffffLL, + 57, 64, 35, 0xffffffffe03fffffLL, + 58, 64, 35, 0xffffffffe07fffffLL, + 59, 64, 35, 0xffffffffe0ffffffLL, + 60, 64, 35, 0xffffffffe1ffffffLL, + 61, 64, 35, 0xffffffffe3ffffffLL, + 62, 64, 35, 0xffffffffe7ffffffLL, + 63, 64, 35, 0xffffffffefffffffLL, + 36, 64, 36, 0xfffffffff0000000LL, + 37, 64, 36, 0xfffffffff0000001LL, + 38, 64, 36, 0xfffffffff0000003LL, + 39, 64, 36, 0xfffffffff0000007LL, + 40, 64, 36, 0xfffffffff000000fLL, + 41, 64, 36, 0xfffffffff000001fLL, + 42, 64, 36, 0xfffffffff000003fLL, + 43, 64, 36, 0xfffffffff000007fLL, + 44, 64, 36, 0xfffffffff00000ffLL, + 45, 64, 36, 0xfffffffff00001ffLL, + 46, 64, 36, 0xfffffffff00003ffLL, + 47, 64, 36, 0xfffffffff00007ffLL, + 48, 64, 36, 0xfffffffff0000fffLL, + 49, 64, 36, 0xfffffffff0001fffLL, + 50, 64, 36, 0xfffffffff0003fffLL, + 51, 64, 36, 0xfffffffff0007fffLL, + 52, 64, 36, 0xfffffffff000ffffLL, + 53, 64, 36, 0xfffffffff001ffffLL, + 54, 64, 36, 0xfffffffff003ffffLL, + 55, 64, 36, 0xfffffffff007ffffLL, + 56, 64, 36, 0xfffffffff00fffffLL, + 57, 64, 36, 0xfffffffff01fffffLL, + 58, 64, 36, 0xfffffffff03fffffLL, + 59, 64, 36, 0xfffffffff07fffffLL, + 60, 64, 36, 0xfffffffff0ffffffLL, + 61, 64, 36, 0xfffffffff1ffffffLL, + 62, 64, 36, 0xfffffffff3ffffffLL, + 63, 64, 36, 0xfffffffff7ffffffLL, + 37, 64, 37, 0xfffffffff8000000LL, + 38, 64, 37, 0xfffffffff8000001LL, + 39, 64, 37, 0xfffffffff8000003LL, + 40, 64, 37, 0xfffffffff8000007LL, + 41, 64, 37, 0xfffffffff800000fLL, + 42, 64, 37, 0xfffffffff800001fLL, + 43, 64, 37, 0xfffffffff800003fLL, + 44, 64, 37, 0xfffffffff800007fLL, + 45, 64, 37, 0xfffffffff80000ffLL, + 46, 64, 37, 0xfffffffff80001ffLL, + 47, 64, 37, 0xfffffffff80003ffLL, + 48, 64, 37, 0xfffffffff80007ffLL, + 49, 64, 37, 0xfffffffff8000fffLL, + 50, 64, 37, 0xfffffffff8001fffLL, + 51, 64, 37, 0xfffffffff8003fffLL, + 52, 64, 37, 0xfffffffff8007fffLL, + 53, 64, 37, 0xfffffffff800ffffLL, + 54, 64, 37, 0xfffffffff801ffffLL, + 55, 64, 37, 0xfffffffff803ffffLL, + 56, 64, 37, 0xfffffffff807ffffLL, + 57, 64, 37, 0xfffffffff80fffffLL, + 58, 64, 37, 0xfffffffff81fffffLL, + 59, 64, 37, 0xfffffffff83fffffLL, + 60, 64, 37, 0xfffffffff87fffffLL, + 61, 64, 37, 0xfffffffff8ffffffLL, + 62, 64, 37, 0xfffffffff9ffffffLL, + 63, 64, 37, 0xfffffffffbffffffLL, + 38, 64, 38, 0xfffffffffc000000LL, + 39, 64, 38, 0xfffffffffc000001LL, + 40, 64, 38, 0xfffffffffc000003LL, + 41, 64, 38, 0xfffffffffc000007LL, + 42, 64, 38, 0xfffffffffc00000fLL, + 43, 64, 38, 0xfffffffffc00001fLL, + 44, 64, 38, 0xfffffffffc00003fLL, + 45, 64, 38, 0xfffffffffc00007fLL, + 46, 64, 38, 0xfffffffffc0000ffLL, + 47, 64, 38, 0xfffffffffc0001ffLL, + 48, 64, 38, 0xfffffffffc0003ffLL, + 49, 64, 38, 0xfffffffffc0007ffLL, + 50, 64, 38, 0xfffffffffc000fffLL, + 51, 64, 38, 0xfffffffffc001fffLL, + 52, 64, 38, 0xfffffffffc003fffLL, + 53, 64, 38, 0xfffffffffc007fffLL, + 54, 64, 38, 0xfffffffffc00ffffLL, + 55, 64, 38, 0xfffffffffc01ffffLL, + 56, 64, 38, 0xfffffffffc03ffffLL, + 57, 64, 38, 0xfffffffffc07ffffLL, + 58, 64, 38, 0xfffffffffc0fffffLL, + 59, 64, 38, 0xfffffffffc1fffffLL, + 60, 64, 38, 0xfffffffffc3fffffLL, + 61, 64, 38, 0xfffffffffc7fffffLL, + 62, 64, 38, 0xfffffffffcffffffLL, + 63, 64, 38, 0xfffffffffdffffffLL, + 39, 64, 39, 0xfffffffffe000000LL, + 40, 64, 39, 0xfffffffffe000001LL, + 41, 64, 39, 0xfffffffffe000003LL, + 42, 64, 39, 0xfffffffffe000007LL, + 43, 64, 39, 0xfffffffffe00000fLL, + 44, 64, 39, 0xfffffffffe00001fLL, + 45, 64, 39, 0xfffffffffe00003fLL, + 46, 64, 39, 0xfffffffffe00007fLL, + 47, 64, 39, 0xfffffffffe0000ffLL, + 48, 64, 39, 0xfffffffffe0001ffLL, + 49, 64, 39, 0xfffffffffe0003ffLL, + 50, 64, 39, 0xfffffffffe0007ffLL, + 51, 64, 39, 0xfffffffffe000fffLL, + 52, 64, 39, 0xfffffffffe001fffLL, + 53, 64, 39, 0xfffffffffe003fffLL, + 54, 64, 39, 0xfffffffffe007fffLL, + 55, 64, 39, 0xfffffffffe00ffffLL, + 56, 64, 39, 0xfffffffffe01ffffLL, + 57, 64, 39, 0xfffffffffe03ffffLL, + 58, 64, 39, 0xfffffffffe07ffffLL, + 59, 64, 39, 0xfffffffffe0fffffLL, + 60, 64, 39, 0xfffffffffe1fffffLL, + 61, 64, 39, 0xfffffffffe3fffffLL, + 62, 64, 39, 0xfffffffffe7fffffLL, + 63, 64, 39, 0xfffffffffeffffffLL, + 40, 64, 40, 0xffffffffff000000LL, + 41, 64, 40, 0xffffffffff000001LL, + 42, 64, 40, 0xffffffffff000003LL, + 43, 64, 40, 0xffffffffff000007LL, + 44, 64, 40, 0xffffffffff00000fLL, + 45, 64, 40, 0xffffffffff00001fLL, + 46, 64, 40, 0xffffffffff00003fLL, + 47, 64, 40, 0xffffffffff00007fLL, + 48, 64, 40, 0xffffffffff0000ffLL, + 49, 64, 40, 0xffffffffff0001ffLL, + 50, 64, 40, 0xffffffffff0003ffLL, + 51, 64, 40, 0xffffffffff0007ffLL, + 52, 64, 40, 0xffffffffff000fffLL, + 53, 64, 40, 0xffffffffff001fffLL, + 54, 64, 40, 0xffffffffff003fffLL, + 55, 64, 40, 0xffffffffff007fffLL, + 56, 64, 40, 0xffffffffff00ffffLL, + 57, 64, 40, 0xffffffffff01ffffLL, + 58, 64, 40, 0xffffffffff03ffffLL, + 59, 64, 40, 0xffffffffff07ffffLL, + 60, 64, 40, 0xffffffffff0fffffLL, + 61, 64, 40, 0xffffffffff1fffffLL, + 62, 64, 40, 0xffffffffff3fffffLL, + 63, 64, 40, 0xffffffffff7fffffLL, + 41, 64, 41, 0xffffffffff800000LL, + 42, 64, 41, 0xffffffffff800001LL, + 43, 64, 41, 0xffffffffff800003LL, + 44, 64, 41, 0xffffffffff800007LL, + 45, 64, 41, 0xffffffffff80000fLL, + 46, 64, 41, 0xffffffffff80001fLL, + 47, 64, 41, 0xffffffffff80003fLL, + 48, 64, 41, 0xffffffffff80007fLL, + 49, 64, 41, 0xffffffffff8000ffLL, + 50, 64, 41, 0xffffffffff8001ffLL, + 51, 64, 41, 0xffffffffff8003ffLL, + 52, 64, 41, 0xffffffffff8007ffLL, + 53, 64, 41, 0xffffffffff800fffLL, + 54, 64, 41, 0xffffffffff801fffLL, + 55, 64, 41, 0xffffffffff803fffLL, + 56, 64, 41, 0xffffffffff807fffLL, + 57, 64, 41, 0xffffffffff80ffffLL, + 58, 64, 41, 0xffffffffff81ffffLL, + 59, 64, 41, 0xffffffffff83ffffLL, + 60, 64, 41, 0xffffffffff87ffffLL, + 61, 64, 41, 0xffffffffff8fffffLL, + 62, 64, 41, 0xffffffffff9fffffLL, + 63, 64, 41, 0xffffffffffbfffffLL, + 42, 64, 42, 0xffffffffffc00000LL, + 43, 64, 42, 0xffffffffffc00001LL, + 44, 64, 42, 0xffffffffffc00003LL, + 45, 64, 42, 0xffffffffffc00007LL, + 46, 64, 42, 0xffffffffffc0000fLL, + 47, 64, 42, 0xffffffffffc0001fLL, + 48, 64, 42, 0xffffffffffc0003fLL, + 49, 64, 42, 0xffffffffffc0007fLL, + 50, 64, 42, 0xffffffffffc000ffLL, + 51, 64, 42, 0xffffffffffc001ffLL, + 52, 64, 42, 0xffffffffffc003ffLL, + 53, 64, 42, 0xffffffffffc007ffLL, + 54, 64, 42, 0xffffffffffc00fffLL, + 55, 64, 42, 0xffffffffffc01fffLL, + 56, 64, 42, 0xffffffffffc03fffLL, + 57, 64, 42, 0xffffffffffc07fffLL, + 58, 64, 42, 0xffffffffffc0ffffLL, + 59, 64, 42, 0xffffffffffc1ffffLL, + 60, 64, 42, 0xffffffffffc3ffffLL, + 61, 64, 42, 0xffffffffffc7ffffLL, + 62, 64, 42, 0xffffffffffcfffffLL, + 63, 64, 42, 0xffffffffffdfffffLL, + 43, 64, 43, 0xffffffffffe00000LL, + 44, 64, 43, 0xffffffffffe00001LL, + 45, 64, 43, 0xffffffffffe00003LL, + 46, 64, 43, 0xffffffffffe00007LL, + 47, 64, 43, 0xffffffffffe0000fLL, + 48, 64, 43, 0xffffffffffe0001fLL, + 49, 64, 43, 0xffffffffffe0003fLL, + 50, 64, 43, 0xffffffffffe0007fLL, + 51, 64, 43, 0xffffffffffe000ffLL, + 52, 64, 43, 0xffffffffffe001ffLL, + 53, 64, 43, 0xffffffffffe003ffLL, + 54, 64, 43, 0xffffffffffe007ffLL, + 55, 64, 43, 0xffffffffffe00fffLL, + 56, 64, 43, 0xffffffffffe01fffLL, + 57, 64, 43, 0xffffffffffe03fffLL, + 58, 64, 43, 0xffffffffffe07fffLL, + 59, 64, 43, 0xffffffffffe0ffffLL, + 60, 64, 43, 0xffffffffffe1ffffLL, + 61, 64, 43, 0xffffffffffe3ffffLL, + 62, 64, 43, 0xffffffffffe7ffffLL, + 63, 64, 43, 0xffffffffffefffffLL, + 44, 64, 44, 0xfffffffffff00000LL, + 45, 64, 44, 0xfffffffffff00001LL, + 46, 64, 44, 0xfffffffffff00003LL, + 47, 64, 44, 0xfffffffffff00007LL, + 48, 64, 44, 0xfffffffffff0000fLL, + 49, 64, 44, 0xfffffffffff0001fLL, + 50, 64, 44, 0xfffffffffff0003fLL, + 51, 64, 44, 0xfffffffffff0007fLL, + 52, 64, 44, 0xfffffffffff000ffLL, + 53, 64, 44, 0xfffffffffff001ffLL, + 54, 64, 44, 0xfffffffffff003ffLL, + 55, 64, 44, 0xfffffffffff007ffLL, + 56, 64, 44, 0xfffffffffff00fffLL, + 57, 64, 44, 0xfffffffffff01fffLL, + 58, 64, 44, 0xfffffffffff03fffLL, + 59, 64, 44, 0xfffffffffff07fffLL, + 60, 64, 44, 0xfffffffffff0ffffLL, + 61, 64, 44, 0xfffffffffff1ffffLL, + 62, 64, 44, 0xfffffffffff3ffffLL, + 63, 64, 44, 0xfffffffffff7ffffLL, + 45, 64, 45, 0xfffffffffff80000LL, + 46, 64, 45, 0xfffffffffff80001LL, + 47, 64, 45, 0xfffffffffff80003LL, + 48, 64, 45, 0xfffffffffff80007LL, + 49, 64, 45, 0xfffffffffff8000fLL, + 50, 64, 45, 0xfffffffffff8001fLL, + 51, 64, 45, 0xfffffffffff8003fLL, + 52, 64, 45, 0xfffffffffff8007fLL, + 53, 64, 45, 0xfffffffffff800ffLL, + 54, 64, 45, 0xfffffffffff801ffLL, + 55, 64, 45, 0xfffffffffff803ffLL, + 56, 64, 45, 0xfffffffffff807ffLL, + 57, 64, 45, 0xfffffffffff80fffLL, + 58, 64, 45, 0xfffffffffff81fffLL, + 59, 64, 45, 0xfffffffffff83fffLL, + 60, 64, 45, 0xfffffffffff87fffLL, + 61, 64, 45, 0xfffffffffff8ffffLL, + 62, 64, 45, 0xfffffffffff9ffffLL, + 63, 64, 45, 0xfffffffffffbffffLL, + 46, 64, 46, 0xfffffffffffc0000LL, + 47, 64, 46, 0xfffffffffffc0001LL, + 48, 64, 46, 0xfffffffffffc0003LL, + 49, 64, 46, 0xfffffffffffc0007LL, + 50, 64, 46, 0xfffffffffffc000fLL, + 51, 64, 46, 0xfffffffffffc001fLL, + 52, 64, 46, 0xfffffffffffc003fLL, + 53, 64, 46, 0xfffffffffffc007fLL, + 54, 64, 46, 0xfffffffffffc00ffLL, + 55, 64, 46, 0xfffffffffffc01ffLL, + 56, 64, 46, 0xfffffffffffc03ffLL, + 57, 64, 46, 0xfffffffffffc07ffLL, + 58, 64, 46, 0xfffffffffffc0fffLL, + 59, 64, 46, 0xfffffffffffc1fffLL, + 60, 64, 46, 0xfffffffffffc3fffLL, + 61, 64, 46, 0xfffffffffffc7fffLL, + 62, 64, 46, 0xfffffffffffcffffLL, + 63, 64, 46, 0xfffffffffffdffffLL, + 47, 64, 47, 0xfffffffffffe0000LL, + 48, 64, 47, 0xfffffffffffe0001LL, + 49, 64, 47, 0xfffffffffffe0003LL, + 50, 64, 47, 0xfffffffffffe0007LL, + 51, 64, 47, 0xfffffffffffe000fLL, + 52, 64, 47, 0xfffffffffffe001fLL, + 53, 64, 47, 0xfffffffffffe003fLL, + 54, 64, 47, 0xfffffffffffe007fLL, + 55, 64, 47, 0xfffffffffffe00ffLL, + 56, 64, 47, 0xfffffffffffe01ffLL, + 57, 64, 47, 0xfffffffffffe03ffLL, + 58, 64, 47, 0xfffffffffffe07ffLL, + 59, 64, 47, 0xfffffffffffe0fffLL, + 60, 64, 47, 0xfffffffffffe1fffLL, + 61, 64, 47, 0xfffffffffffe3fffLL, + 62, 64, 47, 0xfffffffffffe7fffLL, + 63, 64, 47, 0xfffffffffffeffffLL, + 48, 64, 48, 0xffffffffffff0000LL, + 49, 64, 48, 0xffffffffffff0001LL, + 50, 64, 48, 0xffffffffffff0003LL, + 51, 64, 48, 0xffffffffffff0007LL, + 52, 64, 48, 0xffffffffffff000fLL, + 53, 64, 48, 0xffffffffffff001fLL, + 54, 64, 48, 0xffffffffffff003fLL, + 55, 64, 48, 0xffffffffffff007fLL, + 56, 64, 48, 0xffffffffffff00ffLL, + 57, 64, 48, 0xffffffffffff01ffLL, + 58, 64, 48, 0xffffffffffff03ffLL, + 59, 64, 48, 0xffffffffffff07ffLL, + 60, 64, 48, 0xffffffffffff0fffLL, + 61, 64, 48, 0xffffffffffff1fffLL, + 62, 64, 48, 0xffffffffffff3fffLL, + 63, 64, 48, 0xffffffffffff7fffLL, + 49, 64, 49, 0xffffffffffff8000LL, + 50, 64, 49, 0xffffffffffff8001LL, + 51, 64, 49, 0xffffffffffff8003LL, + 52, 64, 49, 0xffffffffffff8007LL, + 53, 64, 49, 0xffffffffffff800fLL, + 54, 64, 49, 0xffffffffffff801fLL, + 55, 64, 49, 0xffffffffffff803fLL, + 56, 64, 49, 0xffffffffffff807fLL, + 57, 64, 49, 0xffffffffffff80ffLL, + 58, 64, 49, 0xffffffffffff81ffLL, + 59, 64, 49, 0xffffffffffff83ffLL, + 60, 64, 49, 0xffffffffffff87ffLL, + 61, 64, 49, 0xffffffffffff8fffLL, + 62, 64, 49, 0xffffffffffff9fffLL, + 63, 64, 49, 0xffffffffffffbfffLL, + 50, 64, 50, 0xffffffffffffc000LL, + 51, 64, 50, 0xffffffffffffc001LL, + 52, 64, 50, 0xffffffffffffc003LL, + 53, 64, 50, 0xffffffffffffc007LL, + 54, 64, 50, 0xffffffffffffc00fLL, + 55, 64, 50, 0xffffffffffffc01fLL, + 56, 64, 50, 0xffffffffffffc03fLL, + 57, 64, 50, 0xffffffffffffc07fLL, + 58, 64, 50, 0xffffffffffffc0ffLL, + 59, 64, 50, 0xffffffffffffc1ffLL, + 60, 64, 50, 0xffffffffffffc3ffLL, + 61, 64, 50, 0xffffffffffffc7ffLL, + 62, 64, 50, 0xffffffffffffcfffLL, + 63, 64, 50, 0xffffffffffffdfffLL, + 51, 64, 51, 0xffffffffffffe000LL, + 52, 64, 51, 0xffffffffffffe001LL, + 53, 64, 51, 0xffffffffffffe003LL, + 54, 64, 51, 0xffffffffffffe007LL, + 55, 64, 51, 0xffffffffffffe00fLL, + 56, 64, 51, 0xffffffffffffe01fLL, + 57, 64, 51, 0xffffffffffffe03fLL, + 58, 64, 51, 0xffffffffffffe07fLL, + 59, 64, 51, 0xffffffffffffe0ffLL, + 60, 64, 51, 0xffffffffffffe1ffLL, + 61, 64, 51, 0xffffffffffffe3ffLL, + 62, 64, 51, 0xffffffffffffe7ffLL, + 63, 64, 51, 0xffffffffffffefffLL, + 52, 64, 52, 0xfffffffffffff000LL, + 53, 64, 52, 0xfffffffffffff001LL, + 54, 64, 52, 0xfffffffffffff003LL, + 55, 64, 52, 0xfffffffffffff007LL, + 56, 64, 52, 0xfffffffffffff00fLL, + 57, 64, 52, 0xfffffffffffff01fLL, + 58, 64, 52, 0xfffffffffffff03fLL, + 59, 64, 52, 0xfffffffffffff07fLL, + 60, 64, 52, 0xfffffffffffff0ffLL, + 61, 64, 52, 0xfffffffffffff1ffLL, + 62, 64, 52, 0xfffffffffffff3ffLL, + 63, 64, 52, 0xfffffffffffff7ffLL, + 53, 64, 53, 0xfffffffffffff800LL, + 54, 64, 53, 0xfffffffffffff801LL, + 55, 64, 53, 0xfffffffffffff803LL, + 56, 64, 53, 0xfffffffffffff807LL, + 57, 64, 53, 0xfffffffffffff80fLL, + 58, 64, 53, 0xfffffffffffff81fLL, + 59, 64, 53, 0xfffffffffffff83fLL, + 60, 64, 53, 0xfffffffffffff87fLL, + 61, 64, 53, 0xfffffffffffff8ffLL, + 62, 64, 53, 0xfffffffffffff9ffLL, + 63, 64, 53, 0xfffffffffffffbffLL, + 54, 64, 54, 0xfffffffffffffc00LL, + 55, 64, 54, 0xfffffffffffffc01LL, + 56, 64, 54, 0xfffffffffffffc03LL, + 57, 64, 54, 0xfffffffffffffc07LL, + 58, 64, 54, 0xfffffffffffffc0fLL, + 59, 64, 54, 0xfffffffffffffc1fLL, + 60, 64, 54, 0xfffffffffffffc3fLL, + 61, 64, 54, 0xfffffffffffffc7fLL, + 62, 64, 54, 0xfffffffffffffcffLL, + 63, 64, 54, 0xfffffffffffffdffLL, + 55, 64, 55, 0xfffffffffffffe00LL, + 56, 64, 55, 0xfffffffffffffe01LL, + 57, 64, 55, 0xfffffffffffffe03LL, + 58, 64, 55, 0xfffffffffffffe07LL, + 59, 64, 55, 0xfffffffffffffe0fLL, + 60, 64, 55, 0xfffffffffffffe1fLL, + 61, 64, 55, 0xfffffffffffffe3fLL, + 62, 64, 55, 0xfffffffffffffe7fLL, + 63, 64, 55, 0xfffffffffffffeffLL, + 56, 64, 56, 0xffffffffffffff00LL, + 57, 64, 56, 0xffffffffffffff01LL, + 58, 64, 56, 0xffffffffffffff03LL, + 59, 64, 56, 0xffffffffffffff07LL, + 60, 64, 56, 0xffffffffffffff0fLL, + 61, 64, 56, 0xffffffffffffff1fLL, + 62, 64, 56, 0xffffffffffffff3fLL, + 63, 64, 56, 0xffffffffffffff7fLL, + 57, 64, 57, 0xffffffffffffff80LL, + 58, 64, 57, 0xffffffffffffff81LL, + 59, 64, 57, 0xffffffffffffff83LL, + 60, 64, 57, 0xffffffffffffff87LL, + 61, 64, 57, 0xffffffffffffff8fLL, + 62, 64, 57, 0xffffffffffffff9fLL, + 63, 64, 57, 0xffffffffffffffbfLL, + 58, 64, 58, 0xffffffffffffffc0LL, + 59, 64, 58, 0xffffffffffffffc1LL, + 60, 64, 58, 0xffffffffffffffc3LL, + 61, 64, 58, 0xffffffffffffffc7LL, + 62, 64, 58, 0xffffffffffffffcfLL, + 63, 64, 58, 0xffffffffffffffdfLL, + 59, 64, 59, 0xffffffffffffffe0LL, + 60, 64, 59, 0xffffffffffffffe1LL, + 61, 64, 59, 0xffffffffffffffe3LL, + 62, 64, 59, 0xffffffffffffffe7LL, + 63, 64, 59, 0xffffffffffffffefLL, + 60, 64, 60, 0xfffffffffffffff0LL, + 61, 64, 60, 0xfffffffffffffff1LL, + 62, 64, 60, 0xfffffffffffffff3LL, + 63, 64, 60, 0xfffffffffffffff7LL, + 61, 64, 61, 0xfffffffffffffff8LL, + 62, 64, 61, 0xfffffffffffffff9LL, + 63, 64, 61, 0xfffffffffffffffbLL, + 62, 64, 62, 0xfffffffffffffffcLL, + 63, 64, 62, 0xfffffffffffffffdLL, + 63, 64, 63, 0xfffffffffffffffeLL, +}; + +Mask* +findmask(uvlong v) +{ + int top, bot, mid; + Mask *m; + + bot = 0; + top = nelem(bitmasks); + while(bot < top){ + mid = (bot+top)/2; + m = &bitmasks[mid]; + if(v == m->v) + return m; + if(v < m->v) + top = mid; + else + bot = mid+1; + } + return nil; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/cnam.c Sun Mar 8 21:35:30 2026 @@ -0,0 +1,62 @@ +char *cnames[] = +{ + "NONE", + "REG", + "RSP", + "SHIFT", + "EXTREG", + "FREG", + "SPR", + "COND", + "ZCON", + "ADDCON0", + "ADDCON", + "MOVCON", + "BITCON", + "BITCON32", + "BITCON64", + "ABCON", + "MBCON", + "LCON", + "FCON", + "VCON", + "AACON", + "LACON", + "AECON", + "SBRA", + "LBRA", + "NPAUTO", + "NSAUTO", + "PSAUTO", + "PPAUTO", + "UAUTO4K", + "UAUTO8K", + "UAUTO16K", + "UAUTO32K", + "UAUTO64K", + "LAUTO", + "SEXT1", + "SEXT2", + "SEXT4", + "SEXT8", + "SEXT16", + "LEXT", + "NPOREG", + "NSOREG", + "ZOREG", + "PSOREG", + "PPOREG", + "UOREG4K", + "UOREG8K", + "UOREG16K", + "UOREG32K", + "UOREG64K", + "LOREG", + "ADDR", + "ROFF", + "XPOST", + "XPRE", + "VREG", + "GOK", + "NCLASS", +}; --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/compat.c Sun Mar 8 21:38:20 2026 @@ -0,0 +1,192 @@ +#include "l.h" + +/* 9front: #include "../cc/compat" */ + +int +myaccess(char *f) +{ + return access(f, AEXIST); +} + +int +mycreat(char *n, int p) +{ + + return create(n, 1, p); +} + +int +mywait(int *s) +{ + int p; + Waitmsg *w; + + if((w = wait()) == nil) + return -1; + else{ + p = w->pid; + *s = 0; + if(w->msg[0]) + *s = 1; + free(w); + return p; + } +} + +int +mydup(int f1, int f2) +{ + return dup(f1,f2); +} + +int +mypipe(int *fd) +{ + return pipe(fd); +} + +int +pathchar(void) +{ + return '/'; +} + +char* +mygetwd(char *path, int len) +{ + return getwd(path, len); +} + +int +myexec(char *path, char *argv[]) +{ + return exec(path, argv); +} + +int +myfork(void) +{ + return fork(); +} + + +/* + * real allocs + */ + +extern char end[]; + +static char* hunk = end; +static long nhunk; +static uintptr thunk; + +static void +gethunk(void) +{ + long nh; + + if(thunk < NHUNK) + nh = NHUNK; + else if(thunk < 1000*NHUNK) + nh = thunk; + else + nh = 1000*NHUNK; + + if(nhunk < 0) + nhunk = 0; + nhunk += nh; + thunk += nh; + if(brk(hunk+nhunk) < 0) + sysfatal("out of memory"); +} + +void* +alloc(long n) +{ + void *p; + + while((uintptr)hunk & 7) { + hunk++; + nhunk--; + } + while(nhunk < n) + gethunk(); + p = hunk; + nhunk -= n; + hunk += n; + return p; +} + +void* +allocn(void *p, long on, long n) +{ + void *q; + + q = (uchar*)p + on; + if(q != hunk || nhunk < n) { + while(nhunk < on+n) + gethunk(); + memmove(hunk, p, on); + p = hunk; + hunk += on; + nhunk -= on; + } + hunk += n; + nhunk -= n; + return p; +} + +/* + * fake mallocs + */ +void* +malloc(ulong n) +{ + return alloc(n); +} + +void* +calloc(ulong m, ulong n) +{ + return alloc(m*n); +} + +void* +realloc(void *o, ulong n) +{ + ulong m; + void *a; + + if(n == 0) + return nil; + if(o == nil) + return alloc(n); + a = alloc(n); + m = (char*)a - (char*)o; + if(m < n) + n = m; + memmove(a, o, n); + return a; +} + +void +free(void*) +{ +} + +/* needed when profiling */ +void* +mallocz(ulong size, int) +{ + return alloc(size); +} + +void +setmalloctag(void*, ulong) +{ +} + +void +setrealloctag(void*, ulong) +{ +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/dyn.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,157 @@ +#include "l.h" + +enum{ + ABSD = 0, + ABSU = 1, + RELD = 2, + RELU = 3, +}; + +int modemap[4] = { 0, 1, -1, 2, }; + +typedef struct Reloc Reloc; + +struct Reloc +{ + int n; + int t; + uchar *m; + ulong *a; +}; + +Reloc rels; + +static void +grow(Reloc *r) +{ + int t; + uchar *m, *nm; + ulong *a, *na; + + t = r->t; + r->t += 64; + m = r->m; + a = r->a; + r->m = nm = malloc(r->t*sizeof(uchar)); + r->a = na = malloc(r->t*sizeof(ulong)); + memmove(nm, m, t*sizeof(uchar)); + memmove(na, a, t*sizeof(ulong)); + free(m); + free(a); +} + +void +dynreloc(Sym *s, long v, int abs) +{ + int i, k, n; + uchar *m; + ulong *a; + Reloc *r; + + if(v&3) + diag("bad relocation address"); + v >>= 2; + if(s != S && s->type == SUNDEF) + k = abs ? ABSU : RELU; + else + k = abs ? ABSD : RELD; + /* Bprint(&bso, "R %s a=%ld(%lx) %d\n", s->name, a, a, k); */ + k = modemap[k]; + r = &rels; + n = r->n; + if(n >= r->t) + grow(r); + m = r->m; + a = r->a; + for(i = n; i > 0; i--){ + if(v < a[i-1]){ /* happens occasionally for data */ + m[i] = m[i-1]; + a[i] = a[i-1]; + } + else + break; + } + m[i] = k; + a[i] = v; + r->n++; +} + +static int +sput(char *s) +{ + char *p; + + p = s; + while(*s) + cput(*s++); + cput(0); + return s-p+1; +} + +void +asmdyn(void) +{ + int i, n, t, c; + Sym *s; + ulong la, ra, *a; + vlong off; + uchar *m; + Reloc *r; + + cflush(); + off = seek(cout, 0, 1); + lput(0); + t = 0; + lput(imports); + t += 4; + for(i = 0; i < NHASH; i++) + for(s = hash[i]; s != S; s = s->link) + if(s->type == SUNDEF){ + lput(s->sig); + t += 4; + t += sput(s->name); + } + + la = 0; + r = &rels; + n = r->n; + m = r->m; + a = r->a; + lput(n); + t += 4; + for(i = 0; i < n; i++){ + ra = *a-la; + if(*a < la) + diag("bad relocation order"); + if(ra < 256) + c = 0; + else if(ra < 65536) + c = 1; + else + c = 2; + cput((c<<6)|*m++); + t++; + if(c == 0){ + cput(ra); + t++; + } + else if(c == 1){ + wput(ra); + t += 2; + } + else{ + lput(ra); + t += 4; + } + la = *a++; + } + + cflush(); + seek(cout, off, 0); + lput(t); + + if(debug['v']){ + Bprint(&bso, "import table entries = %d\n", imports); + Bprint(&bso, "export table entries = %d\n", exports); + } +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/l.h Sun Mar 8 21:34:02 2026 @@ -0,0 +1,420 @@ +#include +#include +#include +#include "../7c/7.out.h" + +#ifndef EXTERN +#define EXTERN extern +#endif + +#define LIBNAMELEN 300 + +void addlibpath(char*); +int fileexists(char*); +int find1(long, int); +char* findlib(char*); + +typedef struct Adr Adr; +typedef struct Autom Auto; +typedef struct Count Count; +typedef struct Ieee Ieee; +typedef struct Prog Prog; +typedef struct Sym Sym; +typedef struct Mask Mask; +typedef struct Optab Optab; +typedef struct Oprang Oprang; +typedef uchar Opcross[32][2][32]; + +#define P ((Prog*)0) +#define S ((Sym*)0) +#define TNAME (curtext&&curtext->from.sym?curtext->from.sym->name:noname) + +struct Adr +{ + union + { + vlong u0offset; + char* u0sval; + Ieee* u0ieee; + } u0; + union + { + Auto* u1autom; + Sym* u1sym; + } u1; + char type; + char reg; + char name; + char class; +}; + +#define offset u0.u0offset +#define sval u0.u0sval +#define ieee u0.u0ieee + +#define autom u1.u1autom +#define sym u1.u1sym + +struct Prog +{ + Adr from; + Adr from3; /* third register operand */ + Adr to; + union + { + long u0regused; + Prog* u0forwd; + } u0; + Prog* cond; + Prog* link; + vlong pc; + long line; + uchar mark; + ushort optab; + ushort as; + uchar reg; +}; +#define regused u0.u0regused +#define forwd u0.u0forwd + +struct Sym +{ + char *name; + short type; + short version; + short become; + short frame; + char dupok; + uchar subtype; + ushort file; + vlong value; + long sig; + Sym* link; +}; + +#define SIGNINTERN (1729*325*1729) /* signature of internal functions such as _div */ + +struct Autom +{ + Sym* asym; + Auto* link; + long aoffset; + short type; +}; + +struct Optab +{ + ushort as; + char a1; + char a2; + char a3; + char type; + char size; + char param; + char flag; +}; +struct Oprang +{ + Optab* start; + Optab* stop; +}; +struct Mask +{ + uchar s; + uchar e; + uchar r; + uvlong v; +}; + +enum +{ + STEXT = 1, + SDATA, + SBSS, + SDATA1, + SXREF, + SLEAF, + SFILE, + SCONST, + SSTRING, + SUNDEF, + + SIMPORT, + SEXPORT, + + LFROM = 1<<0, + LTO = 1<<1, + LPOOL = 1<<2, + + C_NONE = 0, + C_REG, + C_RSP, /* D_REG or D_SP */ + C_SHIFT, /* D_SHIFT: shift type, amount, value */ + C_EXTREG, /* D_EXTREG: reg, ext type, shift */ + C_FREG, + C_SPR, + C_COND, + + C_ZCON, /* 0 (matching C_REG, not C_RSP, allowing REGZERO) */ + C_ADDCON0, /* 12-bit unsigned, unshifted */ + C_ADDCON, /* 12-bit unsigned, shifted left by 0 or 12 */ + C_MOVCON, /* generated by a 16-bit constant, optionally inverted and/or shifted by multiple of 16 */ + C_BITCON, /* bimm32/bimm64 */ + C_BITCON32, /* bimm32 */ + C_BITCON64, /* bimm64 */ + C_ABCON, /* could be C_ADDCON or C_BITCON */ + C_MBCON, /* could be C_MOVCON or C_BITCON */ + C_LCON, /* 32-bit constant */ + C_FCON, /* floating-point constant */ + C_VCON, /* 64-bit constant */ + + C_AACON, /* ADDCON offset in auto constant $a(FP) */ + C_LACON, /* 32-bit offset in auto constant $a(FP) */ + + C_AECON, /* ADDCON offset in extern constant $e(SB) */ + + C_SBRA, + C_LBRA, + + C_NPAUTO, /* -512 <= x < 0, 0 mod 8 */ + C_NSAUTO, /* -256 <= x < 0 */ + C_PSAUTO, /* 0 to 255 */ + C_PPAUTO, /* 0 to 504, 0 mod 8 */ + C_UAUTO4K, /* 0 to 4095 */ + C_UAUTO8K, /* 0 to 8190, 0 mod 2 */ + C_UAUTO16K, /* 0 to 16380, 0 mod 4 */ + C_UAUTO32K, /* 0 to 32760, 0 mod 8 */ + C_UAUTO64K, /* 0 to 65520, 0 mod 16 */ + C_LAUTO, /* any other 32-bit constant */ + + C_SEXT1, /* 0 to 4095, direct */ + C_SEXT2, /* 0 to 8190 */ + C_SEXT4, /* 0 to 16380 */ + C_SEXT8, /* 0 to 32760 */ + C_SEXT16, /* 0 to 65520 */ + C_LEXT, + + C_NPOREG, /* mirror NPAUTO etc, except for ZOREG */ + C_NSOREG, + C_ZOREG, + C_PSOREG, + C_PPOREG, + C_UOREG4K, + C_UOREG8K, + C_UOREG16K, + C_UOREG32K, + C_UOREG64K, + C_LOREG, + + C_ADDR, /* relocatable address for dynamic loading */ + C_ROFF, /* register offset (inc register extended) */ + C_XPOST, + C_XPRE, + + C_VREG, + + C_GOK, + C_NCLASS, /* must be last */ + +/* mark flags */ + FOLL = 1<<0, + LABEL = 1<<1, + LEAF = 1<<2, + FLOAT = 1<<3, + BRANCH = 1<<4, + LOAD = 1<<5, + SYNC = 1<<6, + NOSCHED = 1<<7, + + MINSIZ = 64, + + Roffset = 22, /* no. bits for offset in relocation address */ + Rindex = 10, /* no. bits for index in relocation address */ + + STACKALIGN = 16, /* alignment of stack */ + PCSZ= 8, /* size of PC */ +}; + +enum +{ + + STRINGSZ = 200, + NHASH = 10007, + NHUNK = 100000, + MAXIO = IOUNIT, + MAXHIST = 20, /* limit of path elements for history symbols */ +}; + +EXTERN struct +{ + uchar obuf[MAXIO]; /* output buffer */ + uchar ibuf[MAXIO]; /* input buffer */ +} buf; + +#define cbuf obuf +#define xbuf ibuf + +EXTERN long HEADR; /* length of header */ +EXTERN int HEADTYPE; /* type of header */ +EXTERN vlong INITDAT; /* data location */ +EXTERN long INITRND; /* data round above text location */ +EXTERN vlong INITTEXT; /* text location */ +EXTERN vlong INITTEXTP; /* text location (physical) */ +EXTERN char* INITENTRY; /* entry point */ +EXTERN long autosize; +EXTERN Biobuf bso; +EXTERN long bsssize; +EXTERN int cbc; +EXTERN uchar* cbp; +EXTERN int cout; +EXTERN Auto* curauto; +EXTERN Auto* curhist; +EXTERN Prog* curp; +EXTERN Prog* curtext; +EXTERN Prog* datap; +EXTERN long datsize; +EXTERN char debug[128]; +EXTERN Prog* etextp; +EXTERN Prog* firstp; + +EXTERN uchar fnuxi4[4]; +EXTERN uchar fnuxi8[8]; +EXTERN uchar inuxi[9][8]; + +EXTERN Sym* hash[NHASH]; +EXTERN Sym* histfrog[MAXHIST]; +EXTERN int histfrogp; +EXTERN int histgen; + +EXTERN char* library[50]; +EXTERN char* libraryobj[50]; +EXTERN int libraryp; +EXTERN Prog* lastp; +EXTERN long lcsize; +EXTERN char literal[32]; +EXTERN int nerrors; +EXTERN char* noname; +EXTERN vlong instoffset; +EXTERN Opcross opcross[8]; +EXTERN char* outfile; +EXTERN vlong pc; +EXTERN uchar repop[ALAST]; +EXTERN long symsize; +EXTERN Prog* textp; +EXTERN vlong textsize; +EXTERN int version; +EXTERN char xcmp[C_NCLASS][C_NCLASS]; +EXTERN int xrefresolv; +EXTERN Prog zprg; +EXTERN int dtype; + +EXTERN int doexp, dlm; +EXTERN int imports, nimports; +EXTERN int exports, nexports; +EXTERN char* EXPTAB; +EXTERN Prog undefp; + +#define UP (&undefp) + +extern char* anames[]; +extern char* cnames[]; +extern Optab optab[]; + +EXTERN Prog* blitrl; +EXTERN Prog* elitrl; + +#pragma varargck argpos diag 1 + +#pragma varargck type "A" int +#pragma varargck type "A" uint +#pragma varargck type "C" int +#pragma varargck type "D" Adr* +#pragma varargck type "N" Adr* +#pragma varargck type "P" Prog* +#pragma varargck type "S" char* + + +int Aconv(Fmt*); +int Cconv(Fmt*); +int Dconv(Fmt*); +int Nconv(Fmt*); +int Pconv(Fmt*); +int Rconv(Fmt*); +int Sconv(Fmt*); +int aclass(Adr*); +void addpool(Prog*, Adr*); +vlong atolwhex(char*); +void asmb(void); +void asmdyn(void); +void asmlc(void); +void asmout(Prog*, Optab*); +void asmsym(void); +Prog* brchain(Prog*); +Prog* brloop(Prog*); +void buildop(void); +void buildrep(int, int); +void cflush(void); +void ckoff(Sym*, long); +int chipfloat(Ieee*); +int cmp(int, int); +int compound(Prog*); +void cput(int); +void datfill(uchar*, long, uchar*, long); +void diag(char*, ...); +void dodata(void); +void doprof1(void); +void doprof2(void); +void dynreloc(Sym*, long, int); +vlong entryvalue(void); +void errorexit(void); +void export(void); +void follow(void); +void histtoauto(void); +int isnop(Prog*); +double ieeedtod(Ieee*); +long ieeedtof(Ieee*); +void import(void); +void ldobj(int, long, char*); +void listinit(void); +void llput(vlong); +void llputl(vlong); +void loadlib(void); +Sym* lookup(char*, int); +void lput(long); +void lputl(long); +void mkfwd(void); +int movcon(vlong); +void names(void); +void nocache(Prog*); +void nuxiinit(void); +void objfile(char*); +vlong offsetshift(vlong, int); +Optab* oplook(Prog*); +void patch(void); +int pseudo(Prog*); +void prasm(Prog*); +Prog* prg(void); +void putsymb(char*, int, vlong, int); +void readundefs(char*, int); +long regoff(Adr*); +int relinv(int); +vlong rnd(vlong, long); +void span(void); +void undef(void); +void wput(long); +void wputl(long); +void noops(void); +Mask* findmask(uvlong); +void xdefine(char*, int, long); +void xfol(Prog*); +void zerosig(char*); + + +#pragma varargck type "R" int + +/* for ../ld */ +#define isbranch(a) ((a) == AB) +#define iscall(a) ((a) == ABL) +#define isreturn(a) ((a) == ARETURN || (a) == ARET || (a) == AERET) +#define branchop() AB +#define canfollow(a) ((a) != ATEXT && (a) != ABCASE) --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/list.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,329 @@ +#include "l.h" + +void +listinit(void) +{ + + fmtinstall('A', Aconv); + fmtinstall('D', Dconv); + fmtinstall('P', Pconv); + fmtinstall('S', Sconv); + fmtinstall('N', Nconv); + fmtinstall('R', Rconv); +} + +int +Pconv(Fmt *fp) +{ + Prog *p; + int a; + + p = va_arg(fp->args, Prog*); + curp = p; + a = p->as; + switch(a) { + case ADATA: + case AINIT: + case ADYNT: + return fmtprint(fp, "(%ld) %A %D/%d,%D", + p->line, a, &p->from, p->reg, &p->to); + + default: + if(p->reg == NREG && p->from3.type == D_NONE) + return fmtprint(fp, "(%ld) %A %D,%D", + p->line, a, &p->from, &p->to); + + fmtprint(fp, "(%ld) %A %D", p->line, a, &p->from); + if(p->from3.type != D_NONE) + fmtprint(fp, ",%D", &p->from3); + if(p->reg != NREG) + fmtprint(fp, ",%c%d", p->from.type == D_FREG ? 'F' : 'R', p->reg); + fmtprint(fp, ",%D", &p->to); + return 0; + } +} + +int +Aconv(Fmt *fp) +{ + char *s; + int a; + + a = va_arg(fp->args, int); + s = "???"; + if(a >= AXXX && a < ALAST && anames[a]) + s = anames[a]; + return fmtstrcpy(fp, s); +} + +char* strcond[16] = +{ + "EQ", + "NE", + "HS", + "LO", + "MI", + "PL", + "VS", + "VC", + "HI", + "LS", + "GE", + "LT", + "GT", + "LE", + "AL", + "NV" +}; + +int +Dconv(Fmt *fp) +{ + char *op; + Adr *a; + long v; + static char *extop[] = {".UB", ".UH", ".UW", ".UX", ".SB", ".SH", ".SW", ".SX"}; + + a = va_arg(fp->args, Adr*); + switch(a->type) { + + default: + return fmtprint(fp, "GOK-type(%d)", a->type); + + case D_NONE: + if(a->name != D_NONE || a->reg != NREG || a->sym != S) + return fmtprint(fp, "%N(R%d)(NONE)", a, a->reg); + return 0; + + case D_CONST: + if(a->reg == NREG || a->reg == REGZERO) + return fmtprint(fp, "$%N", a); + else + return fmtprint(fp, "$%N(R%d)", a, a->reg); + + case D_SHIFT: + v = a->offset; + op = "<<>>->@>" + (((v>>22) & 3) << 1); + if(a->reg == NREG) + return fmtprint(fp, "R%ld%c%c%ld", + (v>>16)&0x1F, op[0], op[1], (v>>10)&0x3F); + else + return fmtprint(fp, "R%ld%c%c%ld(R%d)", + (v>>16)&0x1F, op[0], op[1], (v>>10)&0x3F, a->reg); + + case D_OCONST: + if(a->reg != NREG) + return fmtprint(fp, "$*$%N(R%d)(CONST)", a, a->reg); + else + return fmtprint(fp, "$*$%N", a); + + case D_OREG: + if(a->reg != NREG) + return fmtprint(fp, "%N(R%d)", a, a->reg); + else + return fmtprint(fp, "%N", a); + + case D_XPRE: + if(a->reg != NREG) + return fmtprint(fp, "%N(R%d)!", a, a->reg); + else + return fmtprint(fp, "%N!", a); + + case D_XPOST: + if(a->reg != NREG) + return fmtprint(fp, "(R%d)%N!", a->reg, a); + else + return fmtprint(fp, "%N!", a); + + case D_EXTREG: + v = a->offset; + if(v & (7<<10)) + return fmtprint(fp, "R%ld%s<<%ld", (v>>16)&31, extop[(v>>13)&7], (v>>10)&7); + else + return fmtprint(fp, "R%ld%s", (v>>16)&31, extop[(v>>13)&7]); + + case D_ROFF: + v = a->offset; + if(v & (1<<16)) + return fmtprint(fp, "(R%d)[R%ld%s]", a->reg, v&31, extop[(v>>8)&7]); + else + return fmtprint(fp, "(R%d)(R%ld%s)", a->reg, v&31, extop[(v>>8)&7]); + + case D_REG: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "R%d", a->reg); + + case D_SP: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "SP"); + + case D_COND: + return fmtprint(fp, "%s", strcond[a->reg & 0xF]); + + case D_FREG: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(R%d)(REG)", a, a->reg); + else + return fmtprint(fp, "F%d", a->reg); + + case D_SPR: + if(a->name != D_NONE || a->sym != S) + return fmtprint(fp, "%N(SPR%lld)(REG)", a, a->offset); + switch((ulong)a->offset){ + case D_FPSR: + return fmtprint(fp, "FPSR"); + case D_FPCR: + return fmtprint(fp, "FPCR"); + case D_NZCV: + return fmtprint(fp, "NZCV"); + default: + return fmtprint(fp, "SPR(%#llux)", a->offset); + } + + case D_BRANCH: /* botch */ + if(curp->cond != P) { + v = curp->cond->pc; + if(a->sym != S) + return fmtprint(fp, "%s+%#.5lux(BRANCH)", a->sym->name, v); + else + return fmtprint(fp, "%.5lux(BRANCH)", v); + } else { + if(a->sym != S) + return fmtprint(fp, "%s+%lld(APC)", a->sym->name, a->offset); + else + return fmtprint(fp, "%lld(APC)", a->offset); + } + + case D_FCONST: + return fmtprint(fp, "$%e", ieeedtod(a->ieee)); + + case D_SCONST: + return fmtprint(fp, "$\"%S\"", a->sval); + } +} + +int +Nconv(Fmt *fp) +{ + Adr *a; + Sym *s; + + a = va_arg(fp->args, Adr*); + s = a->sym; + switch(a->name) { + default: + return fmtprint(fp, "GOK-name(%d)", a->name); + + case D_NONE: + return fmtprint(fp, "%lld", a->offset); + + case D_EXTERN: + if(s == S) + return fmtprint(fp, "%lld(SB)", a->offset); + else + return fmtprint(fp, "%s+%lld(SB)", s->name, a->offset); + + case D_STATIC: + if(s == S) + return fmtprint(fp, "<>+%lld(SB)", a->offset); + else + return fmtprint(fp, "%s<>+%lld(SB)", s->name, a->offset); + + case D_AUTO: + if(s == S) + return fmtprint(fp, "%lld(SP)", a->offset); + else + return fmtprint(fp, "%s-%lld(SP)", s->name, -a->offset); + + case D_PARAM: + if(s == S) + return fmtprint(fp, "%lld(FP)", a->offset); + else + return fmtprint(fp, "%s+%lld(FP)", s->name, a->offset); + } +} + +int +Rconv(Fmt *fp) +{ + char *s; + int a; + + a = va_arg(fp->args, int); + s = "C_??"; + if(a >= C_NONE && a <= C_NCLASS) + s = cnames[a]; + return fmtstrcpy(fp, s); +} + +void +prasm(Prog *p) +{ + print("%P\n", p); +} + +int +Sconv(Fmt *fp) +{ + int i, c; + char str[STRINGSZ], *p, *a; + + a = va_arg(fp->args, char*); + p = str; + for(i=0; i= 'a' && c <= 'z' || + c >= 'A' && c <= 'Z' || + c >= '0' && c <= '9' || + c == ' ' || c == '%') { + *p++ = c; + continue; + } + *p++ = '\\'; + switch(c) { + case 0: + *p++ = 'z'; + continue; + case '\\': + case '"': + *p++ = c; + continue; + case '\n': + *p++ = 'n'; + continue; + case '\t': + *p++ = 't'; + continue; + } + *p++ = (c>>6) + '0'; + *p++ = ((c>>3) & 7) + '0'; + *p++ = (c & 7) + '0'; + } + *p = 0; + return fmtstrcpy(fp, str); +} + +void +diag(char *fmt, ...) +{ + char buf[STRINGSZ], *tn; + va_list arg; + + tn = "??none??"; + if(curtext != P && curtext->from.sym != S) + tn = curtext->from.sym->name; + va_start(arg, fmt); + vseprint(buf, buf+sizeof(buf), fmt, arg); + va_end(arg); + print("%s: %s\n", tn, buf); + + nerrors++; + if(nerrors > 10) { + print("too many errors\n"); + errorexit(); + } +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/mkcname Mon Dec 2 14:06:55 2024 @@ -0,0 +1,17 @@ +ed - l.h <<'!' +v/^ C_/d +g/^ C_NCLASS/s//&,/ +g/[ ]*=.*,/s//,/ +v/,/p +,s/^ C_/ "/ +,s/,.*$/",/ +1i +char *cnames[] = +{ +. +,a +}; +. +w cnam.c +Q +! --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/mkfile Fri Mar 6 19:59:55 2026 @@ -0,0 +1,40 @@ += sizeof(buf)){ + diag("%s: line too long", f); + errorexit(); + } + memmove(buf, l, n); + buf[n-1] = '\0'; + n = getfields(buf, fields, nelem(fields), 1, " \t\r\n"); + if(n == nelem(fields)){ + diag("%s: bad format", f); + errorexit(); + } + for(i = 0; i < n; i++){ + s = lookup(fields[i], 0); + s->type = SXREF; + s->subtype = t; + if(t == SIMPORT) + nimports++; + else + nexports++; + } + } + Bterm(b); +} + +void +undefsym(Sym *s) +{ + int n; + + n = imports; + if(s->value != 0) + diag("value != 0 on SXREF"); + if(n >= 1<value = n<type = SUNDEF; + imports++; +} + +void +zerosig(char *sp) +{ + Sym *s; + + s = lookup(sp, 0); + s->sig = 0; +} + +void +import(void) +{ + int i; + Sym *s; + + for(i = 0; i < NHASH; i++) + for(s = hash[i]; s != S; s = s->link) + if(s->sig != 0 && s->type == SXREF && (nimports == 0 || s->subtype == SIMPORT)){ + undefsym(s); + Bprint(&bso, "IMPORT: %s sig=%lux v=%lld\n", s->name, s->sig, (vlong)s->value); + } +} + +void +ckoff(Sym *s, long v) +{ + if(v < 0 || v >= 1<name); +} + +static Prog* +newdata(Sym *s, int o, int w, int t) +{ + Prog *p; + + p = prg(); + p->link = datap; + datap = p; + p->as = ADATA; + p->reg = w; + p->from.type = D_OREG; + p->from.name = t; + p->from.sym = s; + p->from.offset = o; + p->to.type = D_CONST; + p->to.name = D_NONE; + return p; +} + +void +export(void) +{ + int i, j, n, off, nb, sv, ne; + Sym *s, *et, *str, **esyms; + Prog *p; + char buf[NSNAME], *t; + + n = 0; + for(i = 0; i < NHASH; i++) + for(s = hash[i]; s != S; s = s->link) + if(s->sig != 0 && s->type != SXREF && s->type != SUNDEF && (nexports == 0 || s->subtype == SEXPORT)) + n++; + esyms = malloc(n*sizeof(Sym*)); + ne = n; + n = 0; + for(i = 0; i < NHASH; i++) + for(s = hash[i]; s != S; s = s->link) + if(s->sig != 0 && s->type != SXREF && s->type != SUNDEF && (nexports == 0 || s->subtype == SEXPORT)) + esyms[n++] = s; + for(i = 0; i < ne-1; i++) + for(j = i+1; j < ne; j++) + if(strcmp(esyms[i]->name, esyms[j]->name) > 0){ + s = esyms[i]; + esyms[i] = esyms[j]; + esyms[j] = s; + } + + nb = 0; + off = 0; + et = lookup(EXPTAB, 0); + if(et->type != 0 && et->type != SXREF) + diag("%s already defined", EXPTAB); + et->type = SDATA; + str = lookup(".string", 0); + if(str->type == 0) + str->type = SDATA; + sv = str->value; + for(i = 0; i < ne; i++){ + s = esyms[i]; + Bprint(&bso, "EXPORT: %s sig=%lux t=%d\n", s->name, s->sig, s->type); + + /* signature */ + p = newdata(et, off, sizeof(long), D_EXTERN); + off += sizeof(long); + p->to.offset = s->sig; + + /* address */ + p = newdata(et, off, sizeof(long), D_EXTERN); + off += sizeof(long); + p->to.name = D_EXTERN; + p->to.sym = s; + + /* string */ + t = s->name; + n = strlen(t)+1; + for(;;){ + buf[nb++] = *t; + sv++; + if(nb >= NSNAME){ + p = newdata(str, sv-NSNAME, NSNAME, D_STATIC); + p->to.type = D_SCONST; + p->to.sval = malloc(NSNAME); + memmove(p->to.sval, buf, NSNAME); + nb = 0; + } + if(*t++ == 0) + break; + } + + /* name */ + p = newdata(et, off, sizeof(long), D_EXTERN); + off += sizeof(long); + p->to.name = D_STATIC; + p->to.sym = str; + p->to.offset = sv-n; + } + + if(nb > 0){ + p = newdata(str, sv-nb, nb, D_STATIC); + p->to.type = D_SCONST; + p->to.sval = malloc(NSNAME); + memmove(p->to.sval, buf, nb); + } + + for(i = 0; i < 3; i++){ + newdata(et, off, sizeof(long), D_EXTERN); + off += sizeof(long); + } + et->value = off; + if(sv == 0) + sv = 1; + str->value = sv; + exports = ne; + free(esyms); +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/noop.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,328 @@ +#include "l.h" + +void +noops(void) +{ + Prog *p, *q, *q1; + int o, aoffset, curframe, curbecome, maxbecome; + + /* + * find leaf subroutines + * become sizes + * frame sizes + * strip NOPs + * expand RET + * expand BECOME pseudo + */ + + if(debug['v']) + Bprint(&bso, "%5.2f noops\n", cputime()); + Bflush(&bso); + + curframe = 0; + curbecome = 0; + maxbecome = 0; + curtext = 0; + + q = P; + for(p = firstp; p != P; p = p->link) { + + /* find out how much arg space is used in this TEXT */ + if(p->to.type == D_OREG && p->to.reg == REGSP) + if(p->to.offset > curframe) + curframe = p->to.offset; + + switch(p->as) { + case ATEXT: + if(curtext && curtext->from.sym) { + curtext->from.sym->frame = curframe; + curtext->from.sym->become = curbecome; + if(curbecome > maxbecome) + maxbecome = curbecome; + } + curframe = 0; + curbecome = 0; + + p->mark |= LEAF; + curtext = p; + break; + + case ARETURN: + /* special form of RETURN is BECOME */ + if(p->from.type == D_CONST) + if(p->from.offset > curbecome) + curbecome = p->from.offset; + break; + + case ANOP: + q1 = p->link; + q->link = q1; /* q is non-nop */ + q1->mark |= p->mark; + continue; + + case ABL: + if(curtext != P) + curtext->mark &= ~LEAF; + + case ACBNZ: + case ACBZ: + case ACBNZW: + case ACBZW: + case ATBZ: + case ATBNZ: + + case ABCASE: + case AB: + + case ABEQ: + case ABNE: + case ABCS: + case ABHS: + case ABCC: + case ABLO: + case ABMI: + case ABPL: + case ABVS: + case ABVC: + case ABHI: + case ABLS: + case ABGE: + case ABLT: + case ABGT: + case ABLE: + + case AADR: /* strange */ + case AADRP: + + q1 = p->cond; + if(q1 != P) { + while(q1->as == ANOP) { + q1 = q1->link; + p->cond = q1; + } + } + break; + } + q = p; + } + + if(curtext && curtext->from.sym) { + curtext->from.sym->frame = curframe; + curtext->from.sym->become = curbecome; + if(curbecome > maxbecome) + maxbecome = curbecome; + } + + if(debug['b']) + print("max become = %d\n", maxbecome); + xdefine("ALEFbecome", STEXT, maxbecome); + + curtext = 0; + for(p = firstp; p != P; p = p->link) { + switch(p->as) { + case ATEXT: + curtext = p; + break; + case ABL: + if(curtext != P && curtext->from.sym != S && curtext->to.offset >= 0) { + o = maxbecome - curtext->from.sym->frame; + if(o <= 0) + break; + /* calling a become or calling a variable */ + if(p->to.sym == S || p->to.sym->become) { + curtext->to.offset += o; + if(debug['b']) { + curp = p; + print("%D calling %D increase %d\n", + &curtext->from, &p->to, o); + } + } + } + break; + } + } + + for(p = firstp; p != P; p = p->link) { + o = p->as; + switch(o) { + case ATEXT: + curtext = p; + if(p->to.offset < 0) + autosize = 0; + else + autosize = p->to.offset + PCSZ; + if((curtext->mark & LEAF) && autosize <= PCSZ) + autosize = 0; + else if(autosize & (STACKALIGN-1)) + autosize += STACKALIGN - (autosize&(STACKALIGN-1)); + p->to.offset = autosize - PCSZ; + + if(autosize == 0 && !(curtext->mark & LEAF)) { + if(debug['v']) + Bprint(&bso, "save suppressed in: %s\n", + curtext->from.sym->name); + Bflush(&bso); + curtext->mark |= LEAF; + } + + aoffset = autosize; + if(aoffset > 0xF0) + aoffset = 0xF0; + + if(curtext->mark & LEAF) { + if(curtext->from.sym) + curtext->from.sym->type = SLEAF; + if(autosize == 0) + break; + aoffset = 0; + } + + q = p; + if(autosize > aoffset){ + q = prg(); + q->as = ASUB; + q->line = p->line; + q->from.type = D_CONST; + q->from.offset = autosize - aoffset; + q->to.type = D_REG; + q->to.reg = REGSP; + q->link = p->link; + p->link = q; + + if(curtext->mark & LEAF) + break; + } + + q1 = prg(); + q1->as = AMOV; + q1->line = p->line; + q1->from.type = D_REG; + q1->from.reg = REGLINK; + q1->to.type = D_XPRE; + q1->to.offset = -aoffset; + q1->to.reg = REGSP; + + q1->link = q->link; + q->link = q1; + break; + + case ARETURN: + nocache(p); + if(p->from.type == D_CONST) + goto become; + if(curtext->mark & LEAF) { + if(autosize != 0){ + p->as = AADD; + p->from.type = D_CONST; + p->from.offset = autosize; + p->to.type = D_REG; + p->to.reg = REGSP; + } + }else{ + /* want write-back pre-indexed SP+autosize -> SP, loading REGLINK*/ + aoffset = autosize; + if(aoffset > 0xF0) + aoffset = 0xF0; + + p->as = AMOV; + p->from.type = D_XPOST; + p->from.offset = aoffset; + p->from.reg = REGSP; + p->to.type = D_REG; + p->to.reg = REGLINK; + + if(autosize > aoffset) { + q = prg(); + q->as = AADD; + q->from.type = D_CONST; + q->from.offset = autosize - aoffset; + q->to.type = D_REG; + q->to.reg = REGSP; + + q->link = p->link; + p->link = q; + p = q; + } + } + + if(p->as != ARETURN) { + q = prg(); + q->line = p->line; + q->link = p->link; + p->link = q; + p = q; + } + + p->as = ARET; + p->line = p->line; + p->to.type = D_OREG; + p->to.offset = 0; + p->to.reg = REGLINK; + + break; + + become: + if(curtext->mark & LEAF) { + + if(!autosize) { + p->as = AB; + p->from = zprg.from; + break; + } + +#ifdef optimise_time + q = prg(); + q->line = p->line; + q->as = AB; + q->from = zprg.from; + q->from3 = zprg.from3; + q->to = p->to; + q->cond = p->cond; + q->link = p->link; + p->link = q; + + p->as = AADD; + p->from = zprg.from; + p->from.type = D_CONST; + p->from.offset = autosize; + p->from3 = zprg.from3; + p->to = zprg.to; + p->to.type = D_REG; + p->to.reg = REGSP; + + break; +#endif + } + q = prg(); + q->line = p->line; + q->as = AB; + q->from = zprg.from; + q->from3 = zprg.from3; + q->to = p->to; + q->cond = p->cond; + q->link = p->link; + p->link = q; + + p->as = AMOV; + p->from = zprg.from; + p->from.type = D_XPRE; + p->from.offset = -autosize; + p->from.reg = REGSP; + p->from3 = zprg.from3; + p->to = zprg.to; + p->to.type = D_REG; + p->to.reg = REGLINK; + + break; + + } + } +} + +void +nocache(Prog *p) +{ + p->optab = 0; + p->from.class = 0; + p->to.class = 0; +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/obj.c Fri Mar 6 20:20:08 2026 @@ -0,0 +1,1462 @@ +#define EXTERN +#include "l.h" +#include + +#ifndef DEFAULT +#define DEFAULT '9' +#endif + +char *noname = ""; +char symname[] = SYMDEF; +char thechar = '7'; +char *thestring = "arm64"; + +static int +isobjfile(char *f) +{ + int n, v; + Biobuf *b; + char buf1[5], buf2[SARMAG]; + + b = Bopen(f, OREAD); + if(b == nil) + return 0; + n = Bread(b, buf1, 5); + if(n == 5 && (buf1[2] == 1 && buf1[3] == '<' || buf1[3] == 1 && buf1[4] == '<')) + v = 1; /* good enough for our purposes */ + else{ + Bseek(b, 0, 0); + n = Bread(b, buf2, SARMAG); + v = n == SARMAG && strncmp(buf2, ARMAG, SARMAG) == 0; + } + Bterm(b); + return v; +} + +/* + * -H0 no header + * -H2 -T0x100028 -R0x100000 is plan9 format + * -H6 -R0x10000 no header with segments padded to pages + * -H7 is elf + */ + +void +usage(void) +{ + diag("usage: %s [-options] objects", argv0); + errorexit(); +} + +void +main(int argc, char *argv[]) +{ + int c; + char *a; + + Binit(&bso, 1, OWRITE); + cout = -1; + listinit(); + outfile = 0; + nerrors = 0; + curtext = P; + INITTEXT = -1; + INITDAT = -1; + HEADTYPE = -1; + INITTEXTP = -1; + INITRND = -1; + INITENTRY = 0; + + ARGBEGIN { + default: + c = ARGC(); + if(c >= 0 && c < sizeof(debug)) + debug[c]++; + break; + case 'o': + outfile = ARGF(); + break; + case 'E': + a = ARGF(); + if(a) + INITENTRY = a; + break; +// case 'L': +// addlibpath(EARGF(usage())); +// break; + case 'T': + a = ARGF(); + if(a) + INITTEXT = atolwhex(a); + break; + case 'P': + a = ARGF(); + if(a) + INITTEXTP = atolwhex(a); + break; + case 'D': + a = ARGF(); + if(a) + INITDAT = atolwhex(a); + break; + case 'R': + a = ARGF(); + if(a) + INITRND = atolwhex(a); + break; + case 'H': + a = ARGF(); + if(a) + HEADTYPE = atolwhex(a); + break; + case 'x': /* produce export table */ + doexp = 1; + if(argv[1] != nil && argv[1][0] != '-' && !isobjfile(argv[1])) + readundefs(ARGF(), SEXPORT); + break; + case 'u': /* produce dynamically loadable module */ + dlm = 1; + if(argv[1] != nil && argv[1][0] != '-' && !isobjfile(argv[1])) + readundefs(ARGF(), SIMPORT); + break; + } ARGEND + + USED(argc); + + if(*argv == 0) + usage(); + if(!debug['9'] && !debug['U'] && !debug['B']) + debug[DEFAULT] = 1; +// addlibroot(); + if(HEADTYPE == -1) { + if(debug['U']) + HEADTYPE = 0; + if(debug['B']) + HEADTYPE = 1; + if(debug['9']) + HEADTYPE = 2; + } + switch(HEADTYPE) { + default: + diag("unknown -H option"); + errorexit(); + case 0: /* no header */ + case 6: /* no header, padded segments */ + HEADR = 0L; + if(INITTEXT == -1) + INITTEXT = 0; + if(INITDAT == -1) + INITDAT = 0; + if(INITRND == -1) + INITRND = 4; + break; + case 2: /* plan 9 */ + HEADR = 40L; + if(INITTEXT == -1) + INITTEXT = 0x10000+HEADR; + if(INITDAT == -1) + INITDAT = 0; + if(INITRND == -1) + INITRND = 0x10000; + break; + } + if (INITTEXTP == -1) + INITTEXTP = INITTEXT; + if(INITDAT != 0 && INITRND != 0) + print("warning: -D0x%llux is ignored because of -R0x%lux\n", + INITDAT, INITRND); + if(debug['v']) + Bprint(&bso, "HEADER = -H0x%d -T0x%llux -D0x%llux -R0x%lux\n", + HEADTYPE, INITTEXT, INITDAT, INITRND); + Bflush(&bso); + zprg.as = AGOK; + zprg.reg = NREG; + zprg.from.name = D_NONE; + zprg.from.type = D_NONE; + zprg.from.reg = NREG; + zprg.to = zprg.from; + zprg.from3 = zprg.from; + buildop(); + histgen = 0; + textp = P; + datap = P; + pc = 0; + dtype = 4; + if(outfile == 0) + outfile = "7.out"; + cout = create(outfile, 1, 0775); + if(cout < 0) { + diag("cannot create %s: %r", outfile); + errorexit(); + } + nuxiinit(); + + version = 0; + cbp = buf.cbuf; + cbc = sizeof(buf.cbuf); + firstp = prg(); + lastp = firstp; + + if(INITENTRY == 0) { + INITENTRY = "_main"; + if(debug['p']) + INITENTRY = "_mainp"; + if(!debug['l']) + lookup(INITENTRY, 0)->type = SXREF; + } else if(!(*INITENTRY >= '0' && *INITENTRY <= '9')) + lookup(INITENTRY, 0)->type = SXREF; + + while(*argv) + objfile(*argv++); + if(!debug['l']) + loadlib(); + firstp = firstp->link; + if(firstp == P) + goto out; + if(doexp || dlm){ + EXPTAB = "_exporttab"; + zerosig(EXPTAB); + zerosig("etext"); + zerosig("edata"); + zerosig("end"); + if(dlm){ + import(); + HEADTYPE = 2; + INITTEXT = 0; + INITDAT = 0; + INITRND = 8; + INITENTRY = EXPTAB; + } + export(); + } + patch(); + if(debug['p']) + if(debug['1']) + doprof1(); + else + doprof2(); + dodata(); + follow(); + if(firstp == P) + goto out; + noops(); + span(); + asmb(); + undef(); + +out: + if(debug['v']) { + Bprint(&bso, "%5.2f cpu time\n", cputime()); + Bprint(&bso, "%d sizeof adr\n", sizeof(Adr)); + Bprint(&bso, "%d sizeof prog\n", sizeof(Prog)); + } + Bflush(&bso); + errorexit(); +} + +void +errorexit(void) +{ + + if(nerrors) { + if(cout >= 0) + remove(outfile); + exits("error"); + } + exits(0); +} + +void +loadlib(void) +{ + int i; + long h; + Sym *s; + +loop: + xrefresolv = 0; + for(i=0; ilink) + if(s->type == SXREF) + goto loop; +} + +void +objfile(char *file) +{ + long off, esym, cnt, l; + int f, work; + Sym *s; + char magbuf[SARMAG]; + char name[100], pname[150]; + struct ar_hdr arhdr; + char *e, *start, *stop; + + if(file[0] == '-' && file[1] == 'l') { + if(debug['9']) + snprint(name, sizeof name, "/%s/lib/lib%s.a", thestring, file+2); + else + snprint(name, sizeof name, "/usr/%clib/lib%s.a", thechar, file+2); + file = name; + } + if(debug['v']) + Bprint(&bso, "%5.2f ldobj: %s\n", cputime(), file); + Bflush(&bso); + f = open(file, 0); + if(f < 0) { + diag("cannot open file: %s", file); + errorexit(); + } + l = read(f, magbuf, SARMAG); + if(l != SARMAG || strncmp(magbuf, ARMAG, SARMAG)){ + /* load it as a regular file */ + l = seek(f, 0L, 2); + seek(f, 0L, 0); + ldobj(f, l, file); + close(f); + return; + } + + if(debug['v']) + Bprint(&bso, "%5.2f ldlib: %s\n", cputime(), file); + l = read(f, &arhdr, SAR_HDR); + if(l != SAR_HDR) { + diag("%s: short read on archive file symbol header", file); + goto out; + } + if(strncmp(arhdr.name, symname, strlen(symname))) { + diag("%s: first entry not symbol header: %s", file, arhdr.name); + goto out; + } + + esym = SARMAG + SAR_HDR + atolwhex(arhdr.size); + off = SARMAG + SAR_HDR; + + /* + * just bang the whole symbol file into memory + */ + seek(f, off, 0); + cnt = esym - off; + start = malloc(cnt + 10); + cnt = read(f, start, cnt); + if(cnt <= 0){ + close(f); + return; + } + stop = &start[cnt]; + memset(stop, 0, 10); + + work = 1; + while(work){ + if(debug['v']) + Bprint(&bso, "%5.2f library pass: %s\n", cputime(), file); + Bflush(&bso); + work = 0; + for(e = start; e < stop; e = strchr(e+5, 0) + 1) { + s = lookup(e+5, 0); + if(s->type != SXREF) + continue; + snprint(pname, sizeof pname, "%s(%s)", file, s->name); + if(debug['v']) + Bprint(&bso, "%5.2f library: %s\n", cputime(), pname); + Bflush(&bso); + l = e[1] & 0xff; + l |= (e[2] & 0xff) << 8; + l |= (e[3] & 0xff) << 16; + l |= (e[4] & 0xff) << 24; + seek(f, l, 0); + l = read(f, &arhdr, SAR_HDR); + if(l != SAR_HDR) + goto bad; + if(strncmp(arhdr.fmag, ARFMAG, sizeof(arhdr.fmag))) + goto bad; + l = atolwhex(arhdr.size); + ldobj(f, l, pname); + if(s->type == SXREF) { + diag("%s: failed to load: %s", file, s->name); + errorexit(); + } + work = 1; + xrefresolv = 1; + } + } + return; + +bad: + diag("%s: bad or out of date archive", file); +out: + close(f); +} + +int +zaddr(uchar *p, Adr *a, Sym *h[]) +{ + int i, c; + long l; + Sym *s; + Auto *u; + + c = p[2]; + if(c < 0 || c > NSYM){ + print("sym out of range: %d\n", c); + p[0] = ALAST+1; + return 0; + } + a->type = p[0]; + a->reg = p[1]; + a->sym = h[c]; + a->name = p[3]; + c = 4; + + if(a->reg < 0 || a->reg > NREG) { + print("register out of range %d\n", a->reg); + p[0] = ALAST+1; + return 0; /* force real diagnostic */ + } + + switch(a->type) { + default: + print("unknown type %d\n", a->type); + p[0] = ALAST+1; + return 0; /* force real diagnostic */ + + case D_NONE: + case D_REG: + case D_SP: + case D_FREG: + case D_VREG: + case D_COND: + break; + + case D_OREG: + case D_XPRE: + case D_XPOST: + case D_CONST: + case D_BRANCH: + case D_SHIFT: + case D_EXTREG: + case D_ROFF: + case D_SPR: + l = p[4] | (p[5]<<8) | (p[6]<<16) | (p[7]<<24); + a->offset = l; + c += 4; + if(a->type == D_CONST && l == 0) + a->reg = REGZERO; + break; + + case D_DCONST: + l = p[4] | (p[5]<<8) | (p[6]<<16) | (p[7]<<24); + a->offset = (uvlong)l & 0xFFFFFFFFUL; + l = p[8] | (p[9]<<8) | (p[10]<<16) | (p[11]<<24); + a->offset |= (vlong)l << 32; + c += 8; + a->type = D_CONST; + if(a->offset == 0) + a->reg = REGZERO; + break; + + case D_SCONST: + a->sval = malloc(NSNAME); + memmove(a->sval, p+4, NSNAME); + c += NSNAME; + break; + + case D_FCONST: + a->ieee = malloc(sizeof(Ieee)); + a->ieee->l = p[4] | (p[5]<<8) | + (p[6]<<16) | (p[7]<<24); + a->ieee->h = p[8] | (p[9]<<8) | + (p[10]<<16) | (p[11]<<24); + c += 8; + break; + } + s = a->sym; + if(s == S) + return c; + i = a->name; + if(i != D_AUTO && i != D_PARAM) + return c; + + l = a->offset; + for(u=curauto; u; u=u->link) + if(u->asym == s) + if(u->type == i) { + if(u->aoffset > l) + u->aoffset = l; + return c; + } + + u = malloc(sizeof(Auto)); + memset(u, 0, sizeof(Auto)); + u->link = curauto; + curauto = u; + u->asym = s; + u->aoffset = l; + u->type = i; + return c; +} + +void +histtoauto(void) +{ + Auto *l; + + while(l = curhist) { + curhist = l->link; + l->link = curauto; + curauto = l; + } +} + +static void +collapsefrog(Sym *s) +{ + int i; + + /* + * bad encoding of path components only allows + * MAXHIST components. if there is an overflow, + * first try to collapse xxx/.. + */ + for(i=1; iname+1, "..") == 0) { + memmove(histfrog+i-1, histfrog+i+1, + (histfrogp-i-1)*sizeof(histfrog[0])); + histfrogp--; + goto out; + } + + /* + * next try to collapse . + */ + for(i=0; iname+1, ".") == 0) { + memmove(histfrog+i, histfrog+i+1, + (histfrogp-i-1)*sizeof(histfrog[0])); + goto out; + } + + /* + * last chance, just truncate from front + */ + memmove(histfrog+0, histfrog+1, + (histfrogp-1)*sizeof(histfrog[0])); + +out: + histfrog[histfrogp-1] = s; +} + +void +nopout(Prog *p) +{ + p->as = ANOP; + p->from.type = D_NONE; + p->from3.type = D_NONE; + p->to.type = D_NONE; +} + +static int +isnegoff(Prog *p) +{ + if(p->from.type == D_CONST && + p->from.name == D_NONE && + p->from.offset < 0) + return 1; + return 0; +} + +static uchar* +readsome(int f, uchar *buf, uchar *good, uchar *stop, int max) +{ + int n; + + n = stop - good; + memmove(buf, good, stop - good); + stop = buf + n; + n = MAXIO - n; + if(n > max) + n = max; + n = read(f, stop, n); + if(n <= 0) + return 0; + return stop + n; +} + +void +addlib(char *obj) +{ + char name[1024], comp[256], *p; + int i; + + if(histfrogp <= 0) + return; + + if(histfrog[0]->name[1] == '/') { + name[0] = 0; + i = 1; + } else + if(histfrog[0]->name[1] == '.') { + snprint(name, sizeof name, "."); + i = 0; + } else { + if(debug['9']) + snprint(name, sizeof name, "/%s/lib", thestring); + else + snprint(name, sizeof name, "/usr/%clib", thechar); + i = 0; + } + + for(; iname+1); + for(;;) { + p = strstr(comp, "$O"); + if(p == 0) + break; + memmove(p+1, p+2, strlen(p+2)+1); + p[0] = thechar; + } + for(;;) { + p = strstr(comp, "$M"); + if(p == 0) + break; + if(strlen(comp)+strlen(thestring)-2+1 >= sizeof comp) { + diag("library component too long"); + return; + } + memmove(p+strlen(thestring), p+2, strlen(p+2)+1); + memmove(p, thestring, strlen(thestring)); + } + if(strlen(name) + strlen(comp) + 3 >= sizeof(name)) { + diag("library component too long"); + return; + } + strcat(name, "/"); + strcat(name, comp); + } + for(i=0; iname = malloc(2*(histfrogp+1) + 1); + + u->asym = s; + u->type = type; + u->aoffset = line; + u->link = curhist; + curhist = u; + + j = 1; + s->name[0] = 0; + for(i=0; ivalue; + s->name[j+0] = k>>8; + s->name[j+1] = k; + j += 2; + } + s->name[j+0] = 0; + s->name[j+1] = 0; +} + +void +ldobj(int f, long c, char *pn) +{ + vlong ipc; + Prog *p, *t; + uchar *bloc, *bsize, *stop; + Sym *h[NSYM], *s, *di; + int v, o, r, skip; + ulong sig; + static int files; + static char **filen; + char **nfilen; + + if((files&15) == 0){ + nfilen = malloc((files+16)*sizeof(char*)); + memmove(nfilen, filen, files*sizeof(char*)); + free(filen); + filen = nfilen; + } + filen[files++] = strdup(pn); + + bsize = buf.xbuf; + bloc = buf.xbuf; + di = S; + +newloop: + memset(h, 0, sizeof(h)); + version++; + histfrogp = 0; + ipc = pc; + skip = 0; + +loop: + if(c <= 0) + goto eof; + r = bsize - bloc; + if(r < 100 && r < c) { /* enough for largest prog */ + bsize = readsome(f, buf.xbuf, bloc, bsize, c); + if(bsize == 0) + goto eof; + bloc = buf.xbuf; + goto loop; + } + o = bloc[0] | (bloc[1] << 8); /* as */ + if(o <= AXXX || o >= ALAST) { + diag("%s: line %lld: opcode out of range %d", pn, pc-ipc, o); + print(" probably not a .7 file\n"); + errorexit(); + } + if(o == ANAME || o == ASIGNAME) { + sig = 0; + if(o == ASIGNAME){ + sig = bloc[2] | (bloc[3]<<8) | (bloc[4]<<16) | (bloc[5]<<24); + bloc += 4; + c -= 4; + } + stop = memchr(&bloc[4], 0, bsize-&bloc[4]); + if(stop == 0){ + bsize = readsome(f, buf.xbuf, bloc, bsize, c); + if(bsize == 0) + goto eof; + bloc = buf.xbuf; + stop = memchr(&bloc[4], 0, bsize-&bloc[4]); + if(stop == 0){ + fprint(2, "%s: name too long\n", pn); + errorexit(); + } + } + v = bloc[2]; /* type */ + o = bloc[3]; /* sym */ + bloc += 4; + c -= 4; + + r = 0; + if(v == D_STATIC) + r = version; + s = lookup((char*)bloc, r); + c -= &stop[1] - bloc; + bloc = stop + 1; + + if(sig != 0){ + if(s->sig != 0 && s->sig != sig) + diag("incompatible type signatures %lux(%s) and %lux(%s) for %s", s->sig, filen[s->file], sig, pn, s->name); + s->sig = sig; + s->file = files-1; + } + + if(debug['W']) + print(" ANAME %s\n", s->name); + h[o] = s; + if((v == D_EXTERN || v == D_STATIC) && s->type == 0) + s->type = SXREF; + if(v == D_FILE) { + if(s->type != SFILE) { + histgen++; + s->type = SFILE; + s->value = histgen; + } + if(histfrogp < MAXHIST) { + histfrog[histfrogp] = s; + histfrogp++; + } else + collapsefrog(s); + } + goto loop; + } + + p = prg(); + p->as = o; + p->reg = bloc[2] & 0x3F; + if(bloc[2] & 0x80) + p->mark = NOSCHED; + p->line = bloc[3] | (bloc[4]<<8) | (bloc[5]<<16) | (bloc[6]<<24); + + r = zaddr(bloc+7, &p->from, h) + 7; + if(bloc[2] & 0x40) + r += zaddr(bloc+r, &p->from3, h); + else + p->from3 = zprg.from3; + r += zaddr(bloc+r, &p->to, h); + bloc += r; + c -= r; + + if(p->reg > NREG) + diag("register out of range %d", p->reg); + + p->link = P; + p->cond = P; + + if(debug['W']) + print("%P\n", p); + + switch(o) { + case AHISTORY: + if(p->to.offset == -1) { + addlib(pn); + histfrogp = 0; + goto loop; + } + addhist(p->line, D_FILE); /* 'z' */ + if(p->to.offset) + addhist(p->to.offset, D_FILE1); /* 'Z' */ + histfrogp = 0; + goto loop; + + case AEND: + histtoauto(); + if(curtext != P) + curtext->to.autom = curauto; + curauto = 0; + curtext = P; + if(c) + goto newloop; + return; + + case AGLOBL: + s = p->from.sym; + if(s == S) { + diag("GLOBL must have a name\n%P", p); + errorexit(); + } + if(p->reg & DUPOK) + s->dupok = 1; + if(s->type == 0 || s->type == SXREF) { + s->type = SBSS; + s->value = 0; + } + if(s->type != SBSS) { + diag("redefinition: %s\n%P", s->name, p); + s->type = SBSS; + s->value = 0; + } + if(p->to.offset > s->value) + s->value = p->to.offset; + break; + + case ADYNT: + if(p->to.sym == S) { + diag("DYNT without a sym\n%P", p); + break; + } + di = p->to.sym; + p->reg = 4; + if(di->type == SXREF) { + if(debug['z']) + Bprint(&bso, "%P set to %d\n", p, dtype); + di->type = SCONST; + di->value = dtype; + dtype += 4; + } + if(p->from.sym == S) + break; + + p->from.offset = di->value; + p->from.sym->type = SDATA; + if(curtext == P) { + diag("DYNT not in text: %P", p); + break; + } + p->to.sym = curtext->from.sym; + p->to.type = D_CONST; + p->link = datap; + datap = p; + break; + + case AINIT: + if(p->from.sym == S) { + diag("INIT without a sym\n%P", p); + break; + } + if(di == S) { + diag("INIT without previous DYNT\n%P", p); + break; + } + p->from.offset = di->value; + p->from.sym->type = SDATA; + p->link = datap; + datap = p; + break; + + case ADATA: + if(p->from.sym == S) { + diag("DATA without a sym\n%P", p); + break; + } + p->link = datap; + datap = p; + break; + + case AGOK: + diag("unknown opcode\n%P", p); + p->pc = pc; + pc++; + break; + + case ATEXT: + if(curtext != P) { + histtoauto(); + curtext->to.autom = curauto; + curauto = 0; + } + skip = 0; + curtext = p; + if(p->to.offset > 0){ + autosize = (p->to.offset+7L) & ~7L; + p->to.offset = autosize; + autosize += PCSZ; + }else + autosize = 0; + s = p->from.sym; + if(s == S) { + diag("TEXT must have a name\n%P", p); + errorexit(); + } + if(s->type != 0 && s->type != SXREF) { + if(p->reg & DUPOK) { + skip = 1; + goto casedef; + } + diag("redefinition: %s\n%P", s->name, p); + } + s->type = STEXT; + s->value = pc; + lastp->link = p; + lastp = p; + p->pc = pc; + pc++; + if(textp == P) { + textp = p; + etextp = p; + goto loop; + } + etextp->cond = p; + etextp = p; + break; + + case ASUB: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = AADD; + } + goto casedef; + + case ASUBW: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = AADDW; + } + goto casedef; + + case ASUBS: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = AADDS; + } + goto casedef; + + case ASUBSW: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = AADDSW; + } + goto casedef; + + case AADD: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = ASUB; + } + goto casedef; + + case AADDW: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = ASUBW; + } + goto casedef; + + case AADDS: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = ASUBS; + } + goto casedef; + + case AADDSW: + if(isnegoff(p)){ + p->from.offset = -p->from.offset; + p->as = ASUBSW; + } + goto casedef; + + case AFCVTDS: + if(p->from.type != D_FCONST) + goto casedef; + p->as = AFMOVS; + /* fall through */ + case AFMOVS: + if(skip) + goto casedef; + + if(p->from.type == D_FCONST && chipfloat(p->from.ieee) < 0) { + /* size sb 9 max */ + snprint(literal, sizeof(literal), "$%lux", ieeedtof(p->from.ieee)); + s = lookup(literal, 0); + if(s->type == 0) { + s->type = SBSS; + s->value = 4; + t = prg(); + t->as = ADATA; + t->line = p->line; + t->from.type = D_OREG; + t->from.sym = s; + t->from.name = D_EXTERN; + t->reg = 4; + t->to = p->from; + t->link = datap; + datap = t; + } + p->from.type = D_OREG; + p->from.sym = s; + p->from.name = D_EXTERN; + p->from.offset = 0; + } + goto casedef; + + case AFMOVD: + if(skip) + goto casedef; + + if(p->from.type == D_FCONST && chipfloat(p->from.ieee) < 0) { + /* size sb 18 max */ + snprint(literal, sizeof(literal), "$%lux.%lux", + p->from.ieee->l, p->from.ieee->h); + s = lookup(literal, 0); + if(s->type == 0) { + s->type = SBSS; + s->value = 8; + t = prg(); + t->as = ADATA; + t->line = p->line; + t->from.type = D_OREG; + t->from.sym = s; + t->from.name = D_EXTERN; + t->reg = 8; + t->to = p->from; + t->link = datap; + datap = t; + } + p->from.type = D_OREG; + p->from.sym = s; + p->from.name = D_EXTERN; + p->from.offset = 0; + } + goto casedef; + + default: + casedef: + if(skip) + nopout(p); + + if(p->to.type == D_BRANCH) + p->to.offset += ipc; + if(p->from.type == D_BRANCH) + p->from.offset += ipc; + lastp->link = p; + lastp = p; + p->pc = pc; + pc++; + break; + } + goto loop; + +eof: + diag("truncated object file: %s", pn); +} + +Sym* +lookup(char *symb, int v) +{ + Sym *s; + char *p; + long h; + int c, l; + + h = v; + for(p=symb; c = *p; p++) + h = h+h+h + c; + l = (p - symb) + 1; + if(h < 0) + h = ~h; + h %= NHASH; + for(s = hash[h]; s != S; s = s->link) + if(s->version == v) + if(memcmp(s->name, symb, l) == 0) + return s; + + s = malloc(sizeof(Sym)); + memset(s, 0, sizeof(Sym)); + s->name = malloc(l); + memmove(s->name, symb, l); + + s->link = hash[h]; + s->version = v; + hash[h] = s; + return s; +} + +Prog* +prg(void) +{ + Prog *p = malloc(sizeof(Prog)); + *p = zprg; + return p; +} + +void +doprof1(void) +{ + Sym *s; + long n; + Prog *p, *q; + + if(debug['v']) + Bprint(&bso, "%5.2f profile 1\n", cputime()); + Bflush(&bso); + s = lookup("__mcount", 0); + n = 1; + for(p = firstp->link; p != P; p = p->link) { + if(p->as == ATEXT) { + q = prg(); + q->line = p->line; + q->link = datap; + datap = q; + q->as = ADATA; + q->from.type = D_OREG; + q->from.name = D_EXTERN; + q->from.offset = n*4; + q->from.sym = s; + q->reg = 4; + q->to = p->from; + q->to.type = D_CONST; + + q = prg(); + q->line = p->line; + q->pc = p->pc; + q->link = p->link; + p->link = q; + p = q; + p->as = AMOVW; + p->from.type = D_OREG; + p->from.name = D_EXTERN; + p->from.sym = s; + p->from.offset = n*PCSZ + PCSZ; + p->to.type = D_REG; + p->to.reg = REGTMP; + + q = prg(); + q->line = p->line; + q->pc = p->pc; + q->link = p->link; + p->link = q; + p = q; + p->as = AADD; + p->from.type = D_CONST; + p->from.offset = 1; + p->to.type = D_REG; + p->to.reg = REGTMP; + + q = prg(); + q->line = p->line; + q->pc = p->pc; + q->link = p->link; + p->link = q; + p = q; + p->as = AMOVW; + p->from.type = D_REG; + p->from.reg = REGTMP; + p->to.type = D_OREG; + p->to.name = D_EXTERN; + p->to.sym = s; + p->to.offset = n*PCSZ + PCSZ; + + n += 2; + continue; + } + } + q = prg(); + q->line = 0; + q->link = datap; + datap = q; + + q->as = ADATA; + q->from.type = D_OREG; + q->from.name = D_EXTERN; + q->from.sym = s; + q->reg = 4; + q->to.type = D_CONST; + q->to.offset = n; + + s->type = SBSS; + s->value = n*4; +} + +void +doprof2(void) +{ + Sym *s2, *s4; + Prog *p, *q, *q2, *ps2, *ps4; + + if(debug['v']) + Bprint(&bso, "%5.2f profile 2\n", cputime()); + Bflush(&bso); + + if(debug['e']){ + s2 = lookup("_tracein", 0); + s4 = lookup("_traceout", 0); + }else{ + s2 = lookup("_profin", 0); + s4 = lookup("_profout", 0); + } + if(s2->type != STEXT || s4->type != STEXT) { + if(debug['e']) + diag("_tracein/_traceout not defined %d %d", s2->type, s4->type); + else + diag("_profin/_profout not defined"); + return; + } + + ps2 = P; + ps4 = P; + for(p = firstp; p != P; p = p->link) { + if(p->as == ATEXT) { + if(p->from.sym == s2) { + ps2 = p; + p->reg = NOPROF; + } + if(p->from.sym == s4) { + ps4 = p; + p->reg = NOPROF; + } + } + } + for(p = firstp; p != P; p = p->link) { + if(p->as == ATEXT) { + if(p->reg & NOPROF) { + for(;;) { + q = p->link; + if(q == P) + break; + if(q->as == ATEXT) + break; + p = q; + } + continue; + } + + /* + * BL profin + */ + q = prg(); + q->line = p->line; + q->pc = p->pc; + q->link = p->link; + if(debug['e']){ /* embedded tracing */ + q2 = prg(); + p->link = q2; + q2->link = q; + + q2->line = p->line; + q2->pc = p->pc; + + q2->as = AB; + q2->to.type = D_BRANCH; + q2->to.sym = p->to.sym; + q2->cond = q->link; + }else + p->link = q; + p = q; + p->as = ABL; + p->to.type = D_BRANCH; + p->cond = ps2; + p->to.sym = s2; + + continue; + } + if(p->as == ARETURN) { + /* + * RET (default) + */ + if(debug['e']){ /* embedded tracing */ + q = prg(); + q->line = p->line; + q->pc = p->pc; + q->link = p->link; + p->link = q; + p = q; + } + + /* + * RETURN + */ + q = prg(); + q->as = p->as; + q->from = p->from; + q->to = p->to; + q->cond = p->cond; + q->link = p->link; + q->reg = p->reg; + p->link = q; + + /* + * BL profout + */ + p->as = ABL; + p->from = zprg.from; + p->from3 = zprg.from3; + p->to = zprg.to; + p->to.type = D_BRANCH; + p->cond = ps4; + p->to.sym = s4; + + p = q; + continue; + } + } +} + +void +nuxiinit(void) +{ + + int i, c; + + for(i=0; i<4; i++) { + c = find1(0x04030201L, i+1); + if(i < 2) + inuxi[2][i] = c; + if(i < 1) + inuxi[1][i] = c; + inuxi[4][i] = c; + fnuxi4[i] = c; + inuxi[8][i] = c; + inuxi[8][i+4] = c+4; + fnuxi8[i] = c; + fnuxi8[i+4] = c+4; + } + if(debug['v']) { + Bprint(&bso, "inuxi = "); + for(i=0; i<1; i++) + Bprint(&bso, "%d", inuxi[1][i]); + Bprint(&bso, " "); + for(i=0; i<2; i++) + Bprint(&bso, "%d", inuxi[2][i]); + Bprint(&bso, " "); + for(i=0; i<4; i++) + Bprint(&bso, "%d", inuxi[4][i]); + Bprint(&bso, " "); + for(i=0; i<8; i++) + Bprint(&bso, "%d", inuxi[8][i]); + Bprint(&bso, "\nfnuxi = "); + for(i=0; i<4; i++) + Bprint(&bso, "%d", fnuxi4[i]); + Bprint(&bso, " "); + for(i=0; i<8; i++) + Bprint(&bso, "%d", fnuxi8[i]); + Bprint(&bso, "\n"); + } + Bflush(&bso); +} + +int +find1(long l, int c) +{ + char *p; + int i; + + p = (char*)&l; + for(i=0; i<4; i++) + if(*p++ == c) + return i; + return 0; +} + +long +ieeedtof(Ieee *ieeep) +{ + int exp; + long v; + + if(ieeep->h == 0) + return 0; + exp = (ieeep->h>>20) & ((1L<<11)-1L); + exp -= (1L<<10) - 2L; + v = (ieeep->h & 0xfffffL) << 3; + v |= (ieeep->l >> 29) & 0x7L; + if((ieeep->l >> 28) & 1) { + v++; + if(v & 0x800000L) { + v = (v & 0x7fffffL) >> 1; + exp++; + } + } + if(exp <= -126 || exp >= 130) + diag("double fp to single fp overflow"); + v |= ((exp + 126) & 0xffL) << 23; + v |= ieeep->h & 0x80000000L; + return v; +} + +double +ieeedtod(Ieee *ieeep) +{ + Ieee e; + double fr; + int exp; + + if(ieeep->h & (1L<<31)) { + e.h = ieeep->h & ~(1L<<31); + e.l = ieeep->l; + return -ieeedtod(&e); + } + if(ieeep->l == 0 && ieeep->h == 0) + return 0; + fr = ieeep->l & ((1L<<16)-1L); + fr /= 1L<<16; + fr += (ieeep->l>>16) & ((1L<<16)-1L); + fr /= 1L<<16; + fr += (ieeep->h & (1L<<20)-1L) | (1L<<20); + fr /= 1L<<21; + exp = (ieeep->h>>20) & ((1L<<11)-1L); + exp -= (1L<<10) - 2L; + return ldexp(fr, exp); +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/optab.c Tue Dec 30 17:28:54 2025 @@ -0,0 +1,478 @@ +#include "l.h" + +Optab optab[] = +{ + { ATEXT, C_LEXT, C_NONE, C_LCON, 0, 0, 0 }, + { ATEXT, C_LEXT, C_REG, C_LCON, 0, 0, 0 }, + { ATEXT, C_ADDR, C_NONE, C_LCON, 0, 0, 0 }, + { ATEXT, C_ADDR, C_REG, C_LCON, 0, 0, 0 }, + + /* arithmetic operations */ + { AADD, C_REG, C_REG, C_REG, 1, 4, 0 }, + { AADD, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { AADC, C_REG, C_REG, C_REG, 1, 4, 0 }, + { AADC, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { ANEG, C_REG, C_NONE, C_REG, 25, 4, 0 }, + { ANGC, C_REG, C_NONE, C_REG, 17, 4, 0 }, + { ACMP, C_REG, C_RSP, C_NONE, 1, 4, 0 }, + + { AADD, C_ADDCON, C_RSP, C_RSP, 2, 4, 0 }, + { AADD, C_ADDCON, C_NONE, C_RSP, 2, 4, 0 }, + { ACMP, C_ADDCON, C_RSP, C_NONE, 2, 4, 0 }, + + { AADD, C_LCON, C_REG, C_REG, 13, 8, 0, LFROM }, + { AADD, C_LCON, C_NONE, C_REG, 13, 8, 0, LFROM }, + { ACMP, C_LCON, C_REG, C_NONE, 13, 8, 0, LFROM }, + + { AADD, C_SHIFT,C_REG, C_REG, 3, 4, 0 }, + { AADD, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + { AMVN, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + { ACMP, C_SHIFT,C_REG, C_NONE, 3, 4, 0 }, + { ANEG, C_SHIFT,C_NONE, C_REG, 26, 4, 0 }, + + { AADD, C_REG, C_RSP, C_RSP, 27, 4, 0 }, + { AADD, C_REG, C_NONE, C_RSP, 27, 4, 0 }, + { AADD, C_EXTREG,C_RSP, C_RSP, 27, 4, 0 }, + { AADD, C_EXTREG,C_NONE, C_RSP, 27, 4, 0 }, + { AMVN, C_EXTREG,C_NONE, C_RSP, 27, 4, 0 }, + { ACMP, C_EXTREG,C_RSP, C_NONE, 27, 4, 0 }, + + { AADD, C_REG, C_REG, C_REG, 1, 4, 0 }, + { AADD, C_REG, C_NONE, C_REG, 1, 4, 0 }, + + /* logical operations */ + { AAND, C_REG, C_REG, C_REG, 1, 4, 0 }, + { AANDW, C_REG, C_REG, C_REG, 1, 4, 0 }, + { AAND, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { AANDW, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { ABIC, C_REG, C_REG, C_REG, 1, 4, 0 }, + { ABICW, C_REG, C_REG, C_REG, 1, 4, 0 }, + { ABIC, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { ABICW, C_REG, C_NONE, C_REG, 1, 4, 0 }, + + { AAND, C_BITCON64,C_REG,C_REG, 53, 4, 0 }, + { AANDW, C_BITCON32,C_REG,C_REG, 53, 4, 0 }, + { AAND, C_BITCON64,C_NONE,C_REG, 53, 4, 0 }, + { AANDW, C_BITCON32,C_NONE,C_REG, 53, 4, 0 }, + + { AAND, C_LCON, C_REG, C_REG, 28, 8, 0, LFROM }, + { AANDW, C_LCON, C_REG, C_REG, 28, 8, 0, LFROM }, + { AAND, C_LCON, C_NONE, C_REG, 28, 8, 0, LFROM }, + { AANDW, C_LCON, C_NONE, C_REG, 28, 8, 0, LFROM }, + { ABIC, C_LCON, C_REG, C_REG, 28, 8, 0, LFROM }, + { ABICW, C_LCON, C_REG, C_REG, 28, 8, 0, LFROM }, + { ABIC, C_LCON, C_NONE, C_REG, 28, 8, 0, LFROM }, + { ABICW, C_LCON, C_NONE, C_REG, 28, 8, 0, LFROM }, + + { AAND, C_SHIFT,C_REG, C_REG, 3, 4, 0 }, + { AANDW, C_SHIFT,C_REG, C_REG, 3, 4, 0 }, + { AAND, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + { AANDW, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + { ABIC, C_SHIFT,C_REG, C_REG, 3, 4, 0 }, + { ABICW, C_SHIFT,C_REG, C_REG, 3, 4, 0 }, + { ABIC, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + { ABICW, C_SHIFT,C_NONE, C_REG, 3, 4, 0 }, + + /* moves */ + { AMOV, C_RSP, C_NONE, C_RSP, 24, 4, 0 }, + { AMVN, C_REG, C_NONE, C_REG, 24, 4, 0 }, + { AMOVB, C_REG, C_NONE, C_REG, 45, 4, 0 }, + { AMOVBU, C_REG, C_NONE, C_REG, 45, 4, 0 }, + { AMOVH, C_REG, C_NONE, C_REG, 45, 4, 0 }, /* also MOVHU */ + { AMOVW, C_REG, C_NONE, C_REG, 45, 4, 0 }, /* also MOVWU */ + /* TO DO: MVN C_SHIFT */ + + /* MOVs that become MOVK/MOVN/MOVZ/ADD/SUB/OR */ + { AMOVW, C_MOVCON, C_NONE, C_REG, 32, 4, 0 }, + { AMOV, C_MOVCON, C_NONE, C_REG, 32, 4, 0 }, +// { AMOVW, C_ADDCON, C_NONE, C_REG, 2, 4, 0 }, +// { AMOV, C_ADDCON, C_NONE, C_REG, 2, 4, 0 }, + + { AMOV, C_BITCON64, C_NONE, C_REG, 53, 4, 0 }, + { AMOVW, C_BITCON32, C_NONE, C_REG, 53, 4, 0 }, + + { AMOVK, C_LCON, C_NONE, C_REG, 33, 4, 0 }, + + { AMOV, C_AECON,C_NONE, C_REG, 4, 4, REGSB }, + { AMOV, C_AACON,C_NONE, C_REG, 4, 4, REGSP }, + + { ASDIV, C_REG, C_NONE, C_REG, 1, 4, 0 }, + { ASDIV, C_REG, C_REG, C_REG, 1, 4, 0 }, + + { AB, C_NONE, C_NONE, C_SBRA, 5, 4, 0 }, + { ABL, C_NONE, C_NONE, C_SBRA, 5, 4, 0 }, + + { AB, C_NONE, C_NONE, C_ZOREG, 6, 4, 0 }, + { ABL, C_NONE, C_NONE, C_ZOREG, 6, 4, 0 }, + { ARET, C_NONE, C_NONE, C_REG, 6, 4, 0 }, + { ARET, C_NONE, C_NONE, C_ZOREG, 6, 4, 0 }, + + { AADRP, C_SBRA, C_NONE, C_REG, 60, 4, 0 }, + { AADR, C_SBRA, C_NONE, C_REG, 61, 4, 0 }, + + { ABFM, C_LCON, C_REG, C_REG, 42, 4, 0 }, + { ABFI, C_LCON, C_REG, C_REG, 43, 4, 0 }, + + { AEXTR, C_LCON, C_REG, C_REG, 44, 4, 0 }, + { ASXTB, C_REG, C_NONE, C_REG, 45, 4, 0 }, + { ACLS, C_REG, C_NONE, C_REG, 46, 4, 0 }, + + { ABEQ, C_NONE, C_NONE, C_SBRA, 7, 4, 0 }, + + { ALSL, C_LCON, C_REG, C_REG, 8, 4, 0 }, + { ALSL, C_LCON, C_NONE, C_REG, 8, 4, 0 }, + + { ALSL, C_REG, C_NONE, C_REG, 9, 4, 0 }, + { ALSL, C_REG, C_REG, C_REG, 9, 4, 0 }, + + { ASVC, C_NONE, C_NONE, C_LCON, 10, 4, 0 }, + { ASVC, C_NONE, C_NONE, C_NONE, 10, 4, 0 }, + + { ADWORD, C_NONE, C_NONE, C_VCON, 11, 8, 0 }, + { ADWORD, C_NONE, C_NONE, C_LEXT, 11, 8, 0 }, + { ADWORD, C_NONE, C_NONE, C_ADDR, 11, 8, 0 }, + + { AWORD, C_NONE, C_NONE, C_LCON, 14, 4, 0 }, + { AWORD, C_NONE, C_NONE, C_LEXT, 14, 4, 0 }, + { AWORD, C_NONE, C_NONE, C_ADDR, 14, 4, 0 }, + + { AMOVW, C_LCON, C_NONE, C_REG, 12, 4, 0, LFROM }, + { AMOV, C_LCON, C_NONE, C_REG, 12, 4, 0, LFROM }, + + { AMOVW, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO }, + { AMOVB, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO }, + { AMOVBU, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO }, + { AMOVW, C_ADDR, C_NONE, C_REG, 65, 8, 0, LFROM }, + { AMOVBU, C_ADDR, C_NONE, C_REG, 65, 8, 0, LFROM }, + + { AMUL, C_REG, C_REG, C_REG, 15, 4, 0 }, + { AMUL, C_REG, C_NONE, C_REG, 15, 4, 0 }, + { AMADD, C_REG, C_REG, C_REG, 15, 4, 0 }, + { AMADD, C_REG, C_NONE, C_REG, 15, 4, 0 }, + + { AREM, C_REG, C_REG, C_REG, 16, 8, 0 }, + { AREM, C_REG, C_NONE, C_REG, 16, 8, 0 }, + + { ACSEL, C_COND, C_REG, C_REG, 18, 4, 0 }, /* from3 optional */ + { ACSET, C_COND, C_NONE, C_REG, 18, 4, 0 }, + + { ACCMN, C_COND, C_REG, C_LCON, 19, 4, 0 }, /* from3 either C_REG or C_LCON */ + + /* register offset load */ + + { AMOV, C_ROFF, C_NONE, C_REG, 68, 4, 0 }, + { AMOVW, C_ROFF, C_NONE, C_REG, 68, 4, 0 }, + { AMOVH, C_ROFF, C_NONE, C_REG, 68, 4, 0 }, + { AMOVB, C_ROFF, C_NONE, C_REG, 68, 4, 0 }, + { AMOVBU, C_ROFF, C_NONE, C_REG, 68, 4, 0 }, + { AFMOVS, C_ROFF, C_NONE, C_FREG, 68, 4, 0 }, + { AFMOVD, C_ROFF, C_NONE, C_FREG, 68, 4, 0 }, + + /* register offset store */ + + { AMOV, C_REG, C_NONE, C_ROFF, 69, 4, 0 }, + { AMOVW, C_REG, C_NONE, C_ROFF, 69, 4, 0 }, + { AMOVH, C_REG, C_NONE, C_ROFF, 69, 4, 0 }, + { AMOVB, C_REG, C_NONE, C_ROFF, 69, 4, 0 }, + { AMOVBU, C_REG, C_NONE, C_ROFF, 69, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_ROFF, 69, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_ROFF, 69, 4, 0 }, + + /* scaled 12-bit unsigned displacement store */ + + { AMOVB, C_REG, C_NONE, C_SEXT1, 20, 4, REGSB }, // + { AMOVB, C_REG, C_NONE, C_UAUTO4K, 20, 4, REGSP }, // + { AMOVB, C_REG, C_NONE, C_UOREG4K, 20, 4, 0 }, // + { AMOVBU, C_REG, C_NONE, C_SEXT1, 20, 4, REGSB }, // + { AMOVBU, C_REG, C_NONE, C_UAUTO4K, 20, 4, REGSP }, // + { AMOVBU, C_REG, C_NONE, C_UOREG4K, 20, 4, 0 }, // + + { AMOVH, C_REG, C_NONE, C_SEXT2, 20, 4, REGSB }, // + { AMOVH, C_REG, C_NONE, C_UAUTO8K, 20, 4, REGSP }, // + { AMOVH, C_REG, C_NONE, C_ZOREG, 20, 4, 0 }, // + { AMOVH, C_REG, C_NONE, C_UOREG8K, 20, 4, 0 }, // + + { AMOVW, C_REG, C_NONE, C_SEXT4, 20, 4, REGSB }, // + { AMOVW, C_REG, C_NONE, C_UAUTO16K, 20, 4, REGSP }, // + { AMOVW, C_REG, C_NONE, C_ZOREG, 20, 4, 0 }, // + { AMOVW, C_REG, C_NONE, C_UOREG16K, 20, 4, 0 }, // + + /* unscaled 9-bit signed displacement store */ + { AMOVB, C_REG, C_NONE, C_NSAUTO, 20, 4, REGSP }, // + { AMOVB, C_REG, C_NONE, C_NSOREG, 20, 4, 0 }, // + { AMOVBU, C_REG, C_NONE, C_NSAUTO, 20, 4, REGSP }, // + { AMOVBU, C_REG, C_NONE, C_NSOREG, 20, 4, 0 }, // + + { AMOVH, C_REG, C_NONE, C_NSAUTO, 20, 4, REGSP }, // + { AMOVH, C_REG, C_NONE, C_NSOREG, 20, 4, 0 }, // + { AMOVW, C_REG, C_NONE, C_NSAUTO, 20, 4, REGSP }, // + { AMOVW, C_REG, C_NONE, C_NSOREG, 20, 4, 0 }, // + + { AMOV, C_REG, C_NONE, C_SEXT8, 20, 4, REGSB }, + { AMOV, C_REG, C_NONE, C_UAUTO32K, 20, 4, REGSP }, + { AMOV, C_REG, C_NONE, C_ZOREG, 20, 4, 0 }, + { AMOV, C_REG, C_NONE, C_UOREG32K, 20, 4, 0 }, + + { AMOV, C_REG, C_NONE, C_NSOREG, 20, 4, 0 }, // + { AMOV, C_REG, C_NONE, C_NSAUTO, 20, 4, REGSP }, // + + /* short displacement load */ + + { AMOVB, C_SEXT1, C_NONE, C_REG, 21, 4, REGSB }, // + { AMOVB, C_UAUTO4K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVB, C_NSAUTO,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVB, C_ZOREG,C_NONE, C_REG, 21, 4, 0 }, // + { AMOVB, C_UOREG4K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVB, C_NSOREG,C_NONE, C_REG, 21, 4, REGSP }, // + + { AMOVBU, C_SEXT1, C_NONE, C_REG, 21, 4, REGSB }, // + { AMOVBU, C_UAUTO4K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVBU, C_NSAUTO,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVBU, C_ZOREG,C_NONE, C_REG, 21, 4, 0 }, // + { AMOVBU, C_UOREG4K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVBU, C_NSOREG,C_NONE, C_REG, 21, 4, REGSP }, // + + { AMOVH, C_SEXT2, C_NONE, C_REG, 21, 4, REGSB }, // + { AMOVH, C_UAUTO8K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVH, C_NSAUTO,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVH, C_ZOREG,C_NONE, C_REG, 21, 4, 0 }, // + { AMOVH, C_UOREG8K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVH, C_NSOREG,C_NONE, C_REG, 21, 4, REGSP }, // + + { AMOVW, C_SEXT4, C_NONE, C_REG, 21, 4, REGSB }, // + { AMOVW, C_UAUTO16K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVW, C_NSAUTO,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVW, C_ZOREG,C_NONE, C_REG, 21, 4, 0 }, // + { AMOVW, C_UOREG16K,C_NONE, C_REG, 21, 4, REGSP }, // + { AMOVW, C_NSOREG,C_NONE, C_REG, 21, 4, REGSP }, // + + { AMOV, C_SEXT8, C_NONE, C_REG, 21, 4, REGSB }, + { AMOV, C_UAUTO32K,C_NONE, C_REG, 21, 4, REGSP }, + { AMOV, C_NSAUTO,C_NONE, C_REG, 21, 4, REGSP }, + { AMOV, C_ZOREG,C_NONE, C_REG, 21, 4, 0 }, + { AMOV, C_UOREG32K,C_NONE, C_REG, 21, 4, REGSP }, + { AMOV, C_NSOREG,C_NONE, C_REG, 21, 4, REGSP }, + + /* large displacement store */ + { AMOVB, C_REG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AMOVB, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AMOVB, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + { AMOVBU, C_REG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AMOVBU, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AMOVBU, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + { AMOVH, C_REG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AMOVH, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AMOVH, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + { AMOVW, C_REG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AMOVW, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AMOVW, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + { AMOV, C_REG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AMOV, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AMOV, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + /* large displacement load */ + { AMOVB, C_LEXT, C_NONE, C_REG, 31, 8, REGSB, LFROM }, + { AMOVB, C_LAUTO,C_NONE, C_REG, 31, 8, REGSP, LFROM }, + { AMOVB, C_LOREG,C_NONE, C_REG, 31, 8, 0, LFROM }, + { AMOVBU, C_LEXT, C_NONE, C_REG, 31, 8, REGSB, LFROM }, + { AMOVBU, C_LAUTO,C_NONE, C_REG, 31, 8, REGSP, LFROM }, + { AMOVBU, C_LOREG,C_NONE, C_REG, 31, 8, 0, LFROM }, + + { AMOVH, C_LEXT, C_NONE, C_REG, 31, 8, REGSB, LFROM }, + { AMOVH, C_LAUTO,C_NONE, C_REG, 31, 8, REGSP, LFROM }, + { AMOVH, C_LOREG,C_NONE, C_REG, 31, 8, 0, LFROM }, + + { AMOVW, C_LEXT, C_NONE, C_REG, 31, 8, REGSB, LFROM }, + { AMOVW, C_LAUTO,C_NONE, C_REG, 31, 8, REGSP, LFROM }, + { AMOVW, C_LOREG,C_NONE, C_REG, 31, 8, 0, LFROM }, + + { AMOV, C_LEXT, C_NONE, C_REG, 31, 8, REGSB, LFROM }, + { AMOV, C_LAUTO,C_NONE, C_REG, 31, 8, REGSP, LFROM }, + { AMOV, C_LOREG,C_NONE, C_REG, 31, 8, 0, LFROM }, + + /* load large effective stack address (load large offset and add) */ + { AMOV, C_LACON,C_NONE, C_REG, 34, 8, REGSP, LFROM }, + + /* pre/post-indexed load (unscaled, signed 9-bit offset) */ + { AMOV, C_XPOST, C_NONE, C_REG, 22, 4, 0 }, + { AMOVW, C_XPOST, C_NONE, C_REG, 22, 4, 0 }, + { AMOVH, C_XPOST, C_NONE, C_REG, 22, 4, 0 }, + { AMOVB, C_XPOST, C_NONE, C_REG, 22, 4, 0 }, + { AMOVBU, C_XPOST, C_NONE, C_REG, 22, 4, 0 }, + { AFMOVS, C_XPOST, C_NONE, C_FREG, 22, 4, 0 }, + { AFMOVD, C_XPOST, C_NONE, C_FREG, 22, 4, 0 }, + + { AMOV, C_XPRE, C_NONE, C_REG, 22, 4, 0 }, + { AMOVW, C_XPRE, C_NONE, C_REG, 22, 4, 0 }, + { AMOVH, C_XPRE, C_NONE, C_REG, 22, 4, 0 }, + { AMOVB, C_XPRE, C_NONE, C_REG, 22, 4, 0 }, + { AMOVBU, C_XPRE, C_NONE, C_REG, 22, 4, 0 }, + { AFMOVS, C_XPRE, C_NONE, C_FREG, 22, 4, 0 }, + { AFMOVD, C_XPRE, C_NONE, C_FREG, 22, 4, 0 }, + + /* pre/post-indexed store (unscaled, signed 9-bit offset) */ + { AMOV, C_REG, C_NONE, C_XPOST, 23, 4, 0 }, + { AMOVW, C_REG, C_NONE, C_XPOST, 23, 4, 0 }, + { AMOVH, C_REG, C_NONE, C_XPOST, 23, 4, 0 }, + { AMOVB, C_REG, C_NONE, C_XPOST, 23, 4, 0 }, + { AMOVBU, C_REG, C_NONE, C_XPOST, 23, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_XPOST, 23, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_XPOST, 23, 4, 0 }, + + { AMOV, C_REG, C_NONE, C_XPRE, 23, 4, 0 }, + { AMOVW, C_REG, C_NONE, C_XPRE, 23, 4, 0 }, + { AMOVH, C_REG, C_NONE, C_XPRE, 23, 4, 0 }, + { AMOVB, C_REG, C_NONE, C_XPRE, 23, 4, 0 }, + { AMOVBU, C_REG, C_NONE, C_XPRE, 23, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_XPRE, 23, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_XPRE, 23, 4, 0 }, + + { AMOVP, C_PPAUTO, C_REG, C_REG, 66, 4, 0 }, + { AMOVP, C_PPOREG, C_REG, C_REG, 66, 4, 0 }, + { AMOVP, C_NPAUTO, C_REG, C_REG, 66, 4, 0 }, + { AMOVP, C_NPOREG, C_REG, C_REG, 66, 4, 0 }, + { AMOVP, C_XPOST, C_REG, C_REG, 66, 4, 0 }, + { AMOVP, C_XPRE, C_REG, C_REG, 66, 4, 0 }, + + { AMOVP, C_REG, C_REG, C_PPAUTO, 67, 4, 0 }, + { AMOVP, C_REG, C_REG, C_PPOREG, 67, 4, 0 }, + { AMOVP, C_REG, C_REG, C_NPAUTO, 67, 4, 0 }, + { AMOVP, C_REG, C_REG, C_NPOREG, 67, 4, 0 }, + { AMOVP, C_REG, C_REG, C_XPOST, 67, 4, 0 }, + { AMOVP, C_REG, C_REG, C_XPRE, 67, 4, 0 }, + + { AMOVPS, C_PPAUTO, C_FREG, C_FREG, 66, 4, 0 }, + { AMOVPS, C_PPOREG, C_FREG, C_FREG, 66, 4, 0 }, + { AMOVPS, C_NPAUTO, C_FREG, C_FREG, 66, 4, 0 }, + { AMOVPS, C_NPOREG, C_FREG, C_FREG, 66, 4, 0 }, + { AMOVPS, C_XPOST, C_FREG, C_FREG, 66, 4, 0 }, + { AMOVPS, C_XPRE, C_FREG, C_FREG, 66, 4, 0 }, + + { AMOVPS, C_FREG, C_FREG, C_PPAUTO, 67, 4, 0 }, + { AMOVPS, C_FREG, C_FREG, C_PPOREG, 67, 4, 0 }, + { AMOVPS, C_FREG, C_FREG, C_NPAUTO, 67, 4, 0 }, + { AMOVPS, C_FREG, C_FREG, C_NPOREG, 67, 4, 0 }, + { AMOVPS, C_FREG, C_FREG, C_XPOST, 67, 4, 0 }, + { AMOVPS, C_FREG, C_FREG, C_XPRE, 67, 4, 0 }, + + /* special */ + { AMOV, C_SPR, C_NONE, C_REG, 35, 4, 0 }, + { AMRS, C_SPR, C_NONE, C_REG, 35, 4, 0 }, + + { AMOV, C_REG, C_NONE, C_SPR, 36, 4, 0 }, + { AMSR, C_REG, C_NONE, C_SPR, 36, 4, 0 }, + + { AMOV, C_LCON, C_NONE, C_SPR, 37, 4, 0 }, + { AMSR, C_LCON, C_NONE, C_SPR, 37, 4, 0 }, + + { AERET, C_NONE, C_NONE, C_NONE, 41, 4, 0 }, + + { AFMOVS, C_FREG, C_NONE, C_SEXT4, 20, 4, REGSB }, + { AFMOVS, C_FREG, C_NONE, C_UAUTO16K, 20, 4, REGSP }, + { AFMOVS, C_FREG, C_NONE, C_NSAUTO, 20, 4, REGSP }, + { AFMOVS, C_FREG, C_NONE, C_ZOREG, 20, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_UOREG16K, 20, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_NSOREG, 20, 4, 0 }, + + { AFMOVD, C_FREG, C_NONE, C_SEXT8, 20, 4, REGSB }, + { AFMOVD, C_FREG, C_NONE, C_UAUTO32K, 20, 4, REGSP }, + { AFMOVD, C_FREG, C_NONE, C_NSAUTO, 20, 4, REGSP }, + { AFMOVD, C_FREG, C_NONE, C_ZOREG, 20, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_UOREG32K, 20, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_NSOREG, 20, 4, 0 }, + + { AFMOVS, C_SEXT4, C_NONE, C_FREG, 21, 4, REGSB }, + { AFMOVS, C_UAUTO16K,C_NONE, C_FREG, 21, 4, REGSP }, + { AFMOVS, C_NSAUTO,C_NONE, C_FREG, 21, 4, REGSP }, + { AFMOVS, C_ZOREG,C_NONE, C_FREG, 21, 4, 0 }, + { AFMOVS, C_UOREG16K,C_NONE, C_FREG, 21, 4, 0 }, + { AFMOVS, C_NSOREG,C_NONE, C_FREG, 21, 4, 0 }, + + { AFMOVD, C_SEXT8, C_NONE, C_FREG, 21, 4, REGSB }, + { AFMOVD, C_UAUTO32K,C_NONE, C_FREG, 21, 4, REGSP }, + { AFMOVD, C_NSAUTO,C_NONE, C_FREG, 21, 4, REGSP }, + { AFMOVD, C_ZOREG,C_NONE, C_FREG, 21, 4, 0 }, + { AFMOVD, C_UOREG32K,C_NONE, C_FREG, 21, 4, 0 }, + { AFMOVD, C_NSOREG,C_NONE, C_FREG, 21, 4, 0 }, + + { AFMOVS, C_FREG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AFMOVS, C_FREG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AFMOVS, C_FREG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + { AFMOVD, C_FREG, C_NONE, C_LEXT, 30, 8, REGSB, LTO }, + { AFMOVD, C_FREG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO }, + { AFMOVD, C_FREG, C_NONE, C_LOREG, 30, 8, 0, LTO }, + + { AFMOVS, C_LEXT, C_NONE, C_FREG, 31, 8, REGSB, LFROM }, + { AFMOVS, C_LAUTO,C_NONE, C_FREG, 31, 8, REGSP, LFROM }, + { AFMOVS, C_LOREG,C_NONE, C_FREG, 31, 8, 0, LFROM }, + + { AFMOVD, C_LEXT, C_NONE, C_FREG, 31, 8, REGSB, LFROM }, + { AFMOVD, C_LAUTO,C_NONE, C_FREG, 31, 8, REGSP, LFROM }, + { AFMOVD, C_LOREG,C_NONE, C_FREG, 31, 8, 0, LFROM }, + + { AFMOVS, C_FREG, C_NONE, C_ADDR, 64, 8, 0, LTO }, + { AFMOVS, C_ADDR, C_NONE, C_FREG, 65, 8, 0, LFROM }, + + { AFMADDD, C_FREG, C_FREG, C_FREG, 70, 4, 0 }, + { AFMADDD, C_FREG, C_NONE, C_FREG, 70, 4, 0 }, + + { AFADDS, C_FREG, C_NONE, C_FREG, 54, 4, 0 }, + { AFADDS, C_FREG, C_REG, C_FREG, 54, 4, 0 }, + { AFADDS, C_FCON, C_NONE, C_FREG, 54, 4, 0 }, + { AFADDS, C_FCON, C_REG, C_FREG, 54, 4, 0 }, + + { AFMOVS, C_FCON, C_NONE, C_FREG, 54, 4, 0 }, + { AFMOVS, C_FREG, C_NONE, C_FREG, 54, 4, 0 }, + { AFMOVD, C_FCON, C_NONE, C_FREG, 54, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_FREG, 54, 4, 0 }, + + { AFMOVS, C_FREG, C_NONE, C_REG, 55, 4, 0 }, + { AFMOVS, C_REG, C_NONE, C_FREG, 55, 4, 0 }, + { AFMOVD, C_FREG, C_NONE, C_REG, 55, 4, 0 }, + { AFMOVD, C_REG, C_NONE, C_FREG, 55, 4, 0 }, + + { AFCVTZSD, C_FREG, C_NONE, C_REG, 29, 4, 0 }, + { ASCVTFD, C_REG, C_NONE, C_FREG, 29, 4, 0 }, + + { AFCMPS, C_FREG, C_REG, C_NONE, 56, 4, 0 }, + { AFCMPS, C_FCON, C_REG, C_NONE, 56, 4, 0 }, + + { AFCCMPS, C_COND, C_REG, C_LCON, 57, 4, 0 }, + + { AFCSELD, C_COND, C_REG, C_FREG, 18, 4, 0 }, + + { AFCVTSD, C_FREG, C_NONE, C_FREG, 29, 4, 0 }, + + { ACASE, C_REG, C_NONE, C_REG, 62, 4*4, 0 }, + { ABCASE, C_NONE, C_NONE, C_SBRA, 63, 4, 0 }, + + { ACLREX, C_NONE, C_NONE, C_LCON, 38, 4, 0 }, + { ACLREX, C_NONE, C_NONE, C_NONE, 38, 4, 0 }, + + { ACBZ, C_REG, C_NONE, C_SBRA, 39, 4, 0 }, + { ATBZ, C_LCON, C_REG, C_SBRA, 40, 4, 0 }, + + { ASYS, C_LCON, C_NONE, C_NONE, 50, 4, 0 }, + { ASYS, C_LCON, C_REG, C_NONE, 50, 4, 0 }, + { ASYSL, C_LCON, C_NONE, C_REG, 50, 4, 0 }, + + { ADMB, C_LCON, C_NONE, C_NONE, 51, 4, 0 }, + { AHINT, C_LCON, C_NONE, C_NONE, 52, 4, 0 }, + + { ALDAR, C_ZOREG, C_NONE, C_REG, 58, 4, 0 }, + { ALDXR, C_ZOREG, C_NONE, C_REG, 58, 4, 0 }, + { ALDAXR, C_ZOREG, C_NONE, C_REG, 58, 4, 0 }, + + { ASTLR, C_REG, C_NONE, C_ZOREG, 59, 4, 0 }, + { ASTXR, C_REG, C_REG, C_ZOREG, 59, 4, 0 }, + { ASTLXR, C_REG, C_REG, C_ZOREG, 59, 4, 0 }, + + { AAESD, C_VREG, C_NONE, C_VREG, 29, 4, 0 }, + { ASHA1C, C_VREG, C_REG, C_VREG, 1, 4, 0 }, + + { AXXX, C_NONE, C_NONE, C_NONE, 0, 4, 0 }, +}; --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/pass.c Mon Dec 2 14:06:55 2024 @@ -0,0 +1,448 @@ +#include "l.h" + +vlong +atolwhex(char *s) +{ + vlong n; + int f; + + n = 0; + f = 0; + while(*s == ' ' || *s == '\t') + s++; + if(*s == '-' || *s == '+') { + if(*s++ == '-') + f = 1; + while(*s == ' ' || *s == '\t') + s++; + } + if(s[0]=='0' && s[1]){ + if(s[1]=='x' || s[1]=='X'){ + s += 2; + for(;;){ + if(*s >= '0' && *s <= '9') + n = n*16 + *s++ - '0'; + else if(*s >= 'a' && *s <= 'f') + n = n*16 + *s++ - 'a' + 10; + else if(*s >= 'A' && *s <= 'F') + n = n*16 + *s++ - 'A' + 10; + else + break; + } + } else + while(*s >= '0' && *s <= '7') + n = n*8 + *s++ - '0'; + } else + while(*s >= '0' && *s <= '9') + n = n*10 + *s++ - '0'; + if(f) + n = -n; + return n; +} + +vlong +rnd(vlong v, long r) +{ + long c; + + if(r <= 0) + return v; + v += r - 1; + c = v % r; + if(c < 0) + c += r; + v -= c; + return v; +} + +void +dodata(void) +{ + int i, t; + Sym *s; + Prog *p; + long orig, v; + + if(debug['v']) + Bprint(&bso, "%5.2f dodata\n", cputime()); + Bflush(&bso); + for(p = datap; p != P; p = p->link) { + s = p->from.sym; + if(p->as == ADYNT || p->as == AINIT) + s->value = dtype; + if(s->type == SBSS) + s->type = SDATA; + if(s->type != SDATA) + diag("initialize non-data (%d): %s\n%P", + s->type, s->name, p); + v = p->from.offset + p->reg; + if(v > s->value) + diag("initialize bounds (%lld): %s\n%P", + (vlong)s->value, s->name, p); + } + + if(debug['t']) { + /* + * pull out string constants + */ + for(p = datap; p != P; p = p->link) { + s = p->from.sym; + if(p->to.type == D_SCONST) + s->type = SSTRING; + } + } + + /* + * pass 1 + * assign 'small' variables to data segment + * (rationale is that data segment is more easily + * addressed through offset on REGSB) + */ + orig = 0; + for(i=0; ilink) { + t = s->type; + if(t != SDATA && t != SBSS) + continue; + v = s->value; + if(v == 0) { + diag("%s: no size", s->name); + v = 1; + } + v = rnd(v, 4); + s->value = v; + if(v > MINSIZ) + continue; + if(v >= 16) + orig = rnd(orig, 16); + else if(v >= 8) + orig = rnd(orig, 8); + s->value = orig; + orig += v; + s->type = SDATA1; + } + + /* + * pass 2 + * assign large 'data' variables to data segment + */ + for(i=0; ilink) { + t = s->type; + if(t != SDATA) { + if(t == SDATA1) + s->type = SDATA; + continue; + } + v = s->value; + if(v >= 16) + orig = rnd(orig, 16); + else if(v >= 8) + orig = rnd(orig, 8); + s->value = orig; + orig += v; + } + + while(orig & 7) + orig++; + datsize = orig; + + /* + * pass 3 + * everything else to bss segment + */ + for(i=0; ilink) { + if(s->type != SBSS) + continue; + v = s->value; + if(v >= 16) + orig = rnd(orig, 16); + else if(v >= 8) + orig = rnd(orig, 8); + s->value = orig; + orig += v; + } + while(orig & 7) + orig++; + bsssize = orig-datsize; + + xdefine("setSB", SDATA, 0L); + xdefine("bdata", SDATA, 0L); + xdefine("edata", SDATA, datsize); + xdefine("end", SBSS, datsize+bsssize); + xdefine("etext", STEXT, 0L); +} + +Prog* +brchain(Prog *p) +{ + int i; + + for(i=0; i<20; i++) { + if(p == P || !isbranch(p->as)) + return p; + p = p->cond; + } + return P; +} + +void +follow(void) +{ + if(debug['v']) + Bprint(&bso, "%5.2f follow\n", cputime()); + Bflush(&bso); + + firstp = prg(); + lastp = firstp; + xfol(textp); + + firstp = firstp->link; + lastp->link = P; +} + +void +xfol(Prog *p) +{ + Prog *q, *r; + int a, i; + +loop: + if(p == P) + return; + a = p->as; + if(a == ATEXT) + curtext = p; + if(isbranch(a)) { + q = p->cond; + if(q != P) { + p->mark |= FOLL; + p = q; + if(!(p->mark & FOLL)) + goto loop; + } + } + if(p->mark & FOLL) { + for(i=0,q=p; i<4; i++,q=q->link) { + if(q == lastp) + break; + a = q->as; + if(a == ANOP) { + i--; + continue; + } + if(isbranch(a) || isreturn(a)) + goto copy; + if(q->cond == P || (q->cond->mark&FOLL)) + continue; + if(a != ABEQ && a != ABNE) + continue; + copy: + for(;;) { + r = prg(); + *r = *p; + if(!(r->mark&FOLL)) + print("cant happen 1\n"); + r->mark |= FOLL; + if(p != q) { + p = p->link; + lastp->link = r; + lastp = r; + continue; + } + lastp->link = r; + lastp = r; + if(isbranch(a) || isreturn(a)) + return; + r->as = a == ABNE? ABEQ: ABNE; + r->cond = p->link; + r->link = p->cond; + if(!(r->link->mark&FOLL)) + xfol(r->link); + if(!(r->cond->mark&FOLL)) + print("cant happen 2\n"); + return; + } + } + a = branchop(); + q = prg(); + q->as = a; + q->line = p->line; + q->to.type = D_BRANCH; + q->to.offset = p->pc; + q->cond = p; + p = q; + } + p->mark |= FOLL; + lastp->link = p; + lastp = p; + if(isbranch(a) || isreturn(a)) + return; + if(p->cond != P) + if(!iscall(a) && p->link != P) { + q = brchain(p->link); + if(canfollow(a)) + if(q != P && (q->mark&FOLL)) { + p->as = relinv(a); + p->link = p->cond; + p->cond = q; + } + xfol(p->link); + q = brchain(p->cond); + if(q == P) + q = p->cond; + if(q->mark&FOLL) { + p->cond = q; + return; + } + p = q; + goto loop; + } + p = p->link; + goto loop; +} + +void +patch(void) +{ + long c, vexit; + Prog *p, *q; + Sym *s; + int a; + + if(debug['v']) + Bprint(&bso, "%5.2f patch\n", cputime()); + Bflush(&bso); + mkfwd(); + s = lookup("exit", 0); + vexit = s->value; + for(p = firstp; p != P; p = p->link) { + a = p->as; + if(a == ATEXT) + curtext = p; + if((iscall(a) || isbranch(a) || isreturn(a)) && + p->to.type != D_BRANCH && p->to.sym != S) { + s = p->to.sym; + switch(s->type) { + default: + diag("undefined: %s\n%P", s->name, p); + s->type = STEXT; + s->value = vexit; + break; + case STEXT: + p->to.offset = s->value; + break; + case SUNDEF: + if(!iscall(p->as)) + diag("help: SUNDEF in AB || ARET"); + p->to.offset = 0; + p->cond = UP; + break; + } + p->to.type = D_BRANCH; + } + if(p->cond == UP) + continue; + if(p->to.type == D_BRANCH) + c = p->to.offset; + else if(p->from.type == D_BRANCH) + c = p->from.offset; + else + continue; + for(q = firstp; q != P;) { + if(q->forwd != P) + if(c >= q->forwd->pc) { + q = q->forwd; + continue; + } + if(c == q->pc) + break; + q = q->link; + } + if(q == P) { + diag("branch out of range %ld\n%P", c, p); + p->to.type = D_NONE; + } + p->cond = q; + } + + for(p = firstp; p != P; p = p->link) { + if(p->as == ATEXT) + curtext = p; + if(p->cond != P && p->cond != UP) { + p->cond = brloop(p->cond); + if(p->cond != P){ + if(p->to.type == D_BRANCH) + p->to.offset = p->cond->pc; + if(p->from.type == D_BRANCH) + p->from.offset = p->cond->pc; + } + } + } +} + +#define LOG 6 +void +mkfwd(void) +{ + Prog *p; + long dwn[LOG], cnt[LOG], i; + Prog *lst[LOG]; + + for(i=0; ilink) { + if(p->as == ATEXT) + curtext = p; + i--; + if(i < 0) + i = LOG-1; + p->forwd = P; + dwn[i]--; + if(dwn[i] <= 0) { + dwn[i] = cnt[i]; + if(lst[i] != P) + lst[i]->forwd = p; + lst[i] = p; + } + } +} + +Prog* +brloop(Prog *p) +{ + Prog *q; + int c; + + for(c=0; p!=P;) { + if(!isbranch(p->as)) + return p; + q = p->cond; + if(q <= p) { + c++; + if(q == p || c > 5000) + break; + } + p = q; + } + return P; +} + +void +undef(void) +{ + int i; + Sym *s; + + for(i=0; ilink) + if(s->type == SXREF) + diag("%s: not defined", s->name); +} --- /dev/null Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/7l/span.c Tue Dec 30 17:28:54 2025 @@ -0,0 +1,1423 @@ +#include "l.h" + +#define BIT(n) ((uvlong)1<<(n)) + +static struct { + vlong start; + vlong size; +} pool; + +static void checkpool(Prog*, int); +static void flushpool(Prog*, int); +static int ispcdisp(vlong); + +static Optab *badop; +static Oprang oprange[ALAST]; + +void +span(void) +{ + Prog *p; + Sym *setext, *s; + Optab *o; + int m, bflag, i; + vlong c, otxt; + long v; + + if(debug['v']) + Bprint(&bso, "%5.2f span\n", cputime()); + Bflush(&bso); + + bflag = 0; + c = INITTEXT; + otxt = c; + for(p = firstp; p != P; p = p->link) { + if(p->as == ADWORD && (c&7) != 0) + c += 4; + p->pc = c; + o = oplook(p); + m = o->size; + if(m == 0) { + if(p->as == ATEXT) { + curtext = p; + autosize = p->to.offset + PCSZ; + if(p->from.sym != S) + p->from.sym->value = c; + /* need passes to resolve branches */ + if(c-otxt >= 1L<<20) + bflag = 1; + otxt = c; + continue; + } + diag("zero-width instruction\n%P", p); + continue; + } + switch(o->flag & (LFROM|LTO)) { + case LFROM: + addpool(p, &p->from); + break; + case LTO: + addpool(p, &p->to); + break; + } + if(p->as == AB || p->as == ARET || p->as == AERET || p->as == ARETURN) /* TO DO: other unconditional operations */ + checkpool(p, 0); + c += m; + if(blitrl) + checkpool(p, 1); + } + + /* + * if any procedure is large enough to + * generate a large SBRA branch, then + * generate extra passes putting branches + * around jmps to fix. this is rare. + */ + while(bflag) { + if(debug['v']) + Bprint(&bso, "%5.2f span1\n", cputime()); + bflag = 0; + c = INITTEXT; + for(p = firstp; p != P; p = p->link) { + if(p->as == ADWORD && (c&7) != 0) + c += 4; + p->pc = c; + o = oplook(p); +/* very large branches + if(o->type == 6 && p->cond) { + otxt = p->cond->pc - c; + if(otxt < 0) + otxt = -otxt; + if(otxt >= (1L<<17) - 10) { + q = prg(); + q->link = p->link; + p->link = q; + q->as = AB; + q->to.type = D_BRANCH; + q->cond = p->cond; + p->cond = q; + q = prg(); + q->link = p->link; + p->link = q; + q->as = AB; + q->to.type = D_BRANCH; + q->cond = q->link->link; + bflag = 1; + } + } + */ + m = o->size; + if(m == 0) { + if(p->as == ATEXT) { + curtext = p; + autosize = p->to.offset + PCSZ; + if(p->from.sym != S) + p->from.sym->value = c; + continue; + } + diag("zero-width instruction\n%P", p); + continue; + } + c += m; + } + } + + if(debug['t']) { + /* + * add strings to text segment + */ + c = rnd(c, 8); + for(i=0; ilink) { + if(s->type != SSTRING) + continue; + v = s->value; + while(v & 3) + v++; + s->value = c; + c += v; + } + } + + c = rnd(c, 8); + + setext = lookup("etext", 0); + if(setext != S) { + setext->value = c; + textsize = c - INITTEXT; + } + if(INITRND) + INITDAT = rnd(c, INITRND); + if(debug['v']) + Bprint(&bso, "tsize = %#llux\n", textsize); + Bflush(&bso); +} + +/* + * when the first reference to the literal pool threatens + * to go out of range of a 1MB PC-relative offset + * drop the pool now, and branch round it. + */ +static void +checkpool(Prog *p, int skip) +{ + if(pool.size >= 0xffff0 || !ispcdisp(p->pc+4+pool.size - pool.start+8)) + flushpool(p, skip); + else if(p->link == P || p->link->as == ACASE) + flushpool(p, 2); +} + +static void +flushpool(Prog *p, int skip) +{ + Prog *q; + + if(blitrl) { + if(skip){ + if(debug['v'] && skip == 1) + print("note: flush literal pool at %#llux: len=%lld ref=%llx\n", p->pc+4, pool.size, pool.start); + q = prg(); + q->as = AB; + q->to.type = D_BRANCH; + q->cond = p->link; + q->link = blitrl; + blitrl = q; + } + else if(p->pc+pool.size-pool.start < 0x100000) + return; + elitrl->link = p->link; + p->link = blitrl; + blitrl = P; /* BUG: should refer back to values until out-of-range */ + elitrl = P; + pool.size = 0; + pool.start = 0; + } +} + +/* + * TO DO: hash + */ +void +addpool(Prog *p, Adr *a) +{ + Prog *q, t; + int sz; + + + t = zprg; + t.as = AWORD; + sz = 4; + switch(aclass(a)) { + default: + if(p->as == AMOV && (a->name == D_EXTERN || a->name == D_STATIC) + || (a->offset >> 32) != 0 && (a->offset >> 31) != -1){ + t.as = ADWORD; + sz = 8; + } + t.to = *a; + break; + case C_PSAUTO: + case C_PPAUTO: + case C_UAUTO4K: + case C_UAUTO8K: + case C_UAUTO16K: + case C_UAUTO32K: + case C_UAUTO64K: + case C_NSAUTO: + case C_NPAUTO: + case C_LAUTO: + case C_PPOREG: + case C_PSOREG: + case C_UOREG4K: + case C_UOREG8K: + case C_UOREG16K: + case C_UOREG32K: + case C_UOREG64K: + case C_NSOREG: + case C_NPOREG: + case C_LOREG: + case C_LACON: + if((instoffset >> 32) != 0 && (instoffset >> 31) != -1) + diag("offset too large\n%P", p); + t.to.type = D_CONST; + t.to.offset = instoffset; + break; + } + + for(q = blitrl; q != P; q = q->link) /* could hash on t.t0.offset */ + if(memcmp(&q->to, &t.to, sizeof(t.to)) == 0) { + p->cond = q; + return; + } + + q = prg(); + *q = t; + q->pc = pool.size; + + if(blitrl == P) { + blitrl = q; + pool.start = p->pc; + } else + elitrl->link = q; + elitrl = q; + pool.size = rnd(pool.size, sz); + pool.size += sz; + + p->cond = q; +} + +int +relinv(int a) +{ + switch(a) { + case ABEQ: return ABNE; + case ABNE: return ABEQ; + case ABCS: return ABCC; + case ABHS: return ABLO; + case ABCC: return ABCS; + case ABLO: return ABHS; + case ABMI: return ABPL; + case ABPL: return ABMI; + case ABVS: return ABVC; + case ABVC: return ABVS; + case ABHI: return ABLS; + case ABLS: return ABHI; + case ABGE: return ABLT; + case ABLT: return ABGE; + case ABGT: return ABLE; + case ABLE: return ABGT; + case ACBZ: return ACBNZ; + case ACBNZ: return ACBZ; + case ACBZW: return ACBNZW; + case ACBNZW: return ACBZW; + case ATBZ: return ATBNZ; + case ATBNZ: return ATBZ; + } + diag("unknown relation: %A", a); + return a; +} + +void +xdefine(char *p, int t, long v) +{ + Sym *s; + + s = lookup(p, 0); + if(s->type == 0 || s->type == SXREF) { + s->type = t; + s->value = v; + } +} + +long +regoff(Adr *a) +{ + + instoffset = 0; + aclass(a); + return instoffset; +} + +static int +ispcdisp(vlong v) +{ + /* pc-relative addressing (using TBZ imm14) will reach? */ + return v >= -0x7fff && v <= 0x7fff && (v&3) == 0; +} + +static int +isaddcon(vlong v) +{ + /* uimm12 or uimm24? */ + if(v < 0) + return 0; + if((v & 0xFFF) == 0) + v >>= 12; + return v <= 0xFFF; +} + +static int +isbitcon64(uvlong v) +{ + return findmask(v) != nil; +} + +static int +isbitcon32(uvlong v) +{ + return (v >> 32) == 0 && findmask(v | v<<32) != nil; +} + +static int +isbitcon(uvlong v) +{ + Mask *m; + + if((v >> 32) != 0) + return 0; + m = findmask(v); + if(m == nil) + return 0; + if(m->s >= 32) + return 0; + return 1; +} + +static int +maxstr1(uvlong x) +{ + int i; + + for(i = 0; x != 0; i++) + x &= x<<1; + return i; +} + +static uvlong +findrotl(uvlong x, int *l) +{ + int i; + + for(i = 0; (x&1) == 0 || (x&BIT(63)) != 0; i++) + x = (x<<1) | ((x&BIT(63))!=0); + *l = i; + return x; +} + +static int +findmask64(Mask *m, uvlong v) +{ + uvlong x, f, fm; + int i, lr, l0, l1, e; + + if(v == 0 || v == ~(uvlong)0) + return 0; + x = findrotl(v, &lr); + l1 = maxstr1(x); + l0 = maxstr1(~x); + e = l0+l1; + if(e == 0 || l1 == 64 || l0 == 64 || 64%e != 0) + return 0; + if(e != 64){ + f = BIT(l1)-1; + fm = BIT(e)-1; + if(e > 32 && x != f) + return 0; + for(i = 0; i < 64; i += e) + if(((x>>i) & fm) != f) + return 0; + } + print("%#llux %#llux 1:%d 0:%d r:%d\n", v, x, l1, l0, lr%e); + m->v = v; + m->s = l1; + m->e = e; + m->r = lr%e; + return 1; +} + +/* + * internal class codes for different constant classes: + * they partition the constant/offset range into disjoint ranges that + * are somehow treated specially by one or more load/store instructions. + */ +static int autoclass[] = {C_PSAUTO, C_NSAUTO, C_NPAUTO, C_PSAUTO, C_PPAUTO, C_UAUTO4K, C_UAUTO8K, C_UAUTO16K, C_UAUTO32K, C_UAUTO64K, C_LAUTO}; +static int oregclass[] = {C_ZOREG, C_NSOREG, C_NPOREG, C_PSOREG, C_PPOREG, C_UOREG4K, C_UOREG8K, C_UOREG16K, C_UOREG32K, C_UOREG64K, C_LOREG}; +static int sextclass[] = {C_SEXT1, C_LEXT, C_LEXT, C_SEXT1, C_SEXT1, C_SEXT1, C_SEXT2, C_SEXT4, C_SEXT8, C_SEXT16, C_LEXT}; + +/* + * return appropriate index into tables above + */ +static int +constclass(vlong l) +{ + if(l == 0) + return 0; + if(l < 0){ + if(l >= -256) + return 1; + if(l >= -512 && (l&7) == 0) + return 2; + return 10; + } + if(l <= 255) + return 3; + if(l <= 504 && (l&7) == 0) + return 4; + if(l <= 4095) + return 5; + if(l <= 8190 && (l&1) == 0) + return 6; + if(l <= 16380 && (l&3) == 0) + return 7; + if(l <= 32760 && (l&7) == 0) + return 8; + if(l <= 65520 && (l&0xF) == 0) + return 9; + return 10; +} + +/* + * given an offset v and a class c (see above) + * return the offset value to use in the instruction, + * scaled if necessary + */ +vlong +offsetshift(vlong v, int c) +{ + vlong vs; + int s; + static int shifts[] = {0, 1, 2, 3, 4}; + + s = 0; + if(c >= C_SEXT1 && c <= C_SEXT16) + s = shifts[c-C_SEXT1]; + else if(c >= C_UAUTO4K && c <= C_UAUTO64K) + s = shifts[c-C_UAUTO4K]; + else if(c >= C_UOREG4K && c <= C_UOREG64K) + s = shifts[c-C_UOREG4K]; + vs = v>>s; + if(vs<type) { + case D_NONE: + return C_NONE; + + case D_REG: + return C_REG; + + case D_VREG: + return C_VREG; + + case D_SP: + return C_RSP; + + case D_COND: + return C_COND; + + case D_SHIFT: + return C_SHIFT; + + case D_EXTREG: + return C_EXTREG; + + case D_ROFF: + return C_ROFF; + + case D_XPOST: + return C_XPOST; + + case D_XPRE: + return C_XPRE; + + case D_FREG: + return C_FREG; + + case D_OREG: + switch(a->name) { + case D_EXTERN: + case D_STATIC: + if(a->sym == 0 || a->sym->name == 0) { + print("null sym external\n"); + print("%D\n", a); + return C_GOK; + } + s = a->sym; + t = s->type; + if(t == 0 || t == SXREF) { + diag("undefined external: %s in %s", + s->name, TNAME); + s->type = SDATA; + } + if(dlm) { + switch(t) { + default: + instoffset = s->value + a->offset + INITDAT; + break; + case SUNDEF: + case STEXT: + case SCONST: + case SLEAF: + case SSTRING: + instoffset = s->value + a->offset; + break; + } + return C_ADDR; + } + instoffset = s->value + a->offset; + if(instoffset >= 0) + return sextclass[constclass(instoffset)]; + return C_LEXT; + + case D_AUTO: + instoffset = autosize + a->offset; + return autoclass[constclass(instoffset)]; + + case D_PARAM: + instoffset = autosize + a->offset + PCSZ; + return autoclass[constclass(instoffset)]; + + case D_NONE: + instoffset = a->offset; + return oregclass[constclass(instoffset)]; + } + return C_GOK; + + case D_SPR: + return C_SPR; + + case D_OCONST: + switch(a->name) { + case D_EXTERN: + case D_STATIC: + s = a->sym; + t = s->type; + if(t == 0 || t == SXREF) { + diag("undefined external: %s in %s", + s->name, TNAME); + s->type = SDATA; + } + instoffset = s->value + a->offset + INITDAT; + if(s->type == STEXT || s->type == SLEAF || s->type == SUNDEF) + instoffset = s->value + a->offset; + return C_LCON; + } + return C_GOK; + + case D_FCONST: + return C_FCON; + + case D_CONST: + switch(a->name) { + + case D_NONE: + instoffset = a->offset; + if(a->reg != NREG && a->reg != REGZERO) + goto aconsize; + + v = instoffset; + if(v == 0) + return C_ZCON; + if(isaddcon(v)){ + if(isbitcon(v)) + return C_ABCON; + if(v <= 0xFFF) + return C_ADDCON0; + return C_ADDCON; + } + t = movcon(v); + if(t >= 0){ + if(isbitcon(v)) + return C_MBCON; + return C_MOVCON; + } + t = movcon(~v); + if(t >= 0){ + if(isbitcon(v)) + return C_MBCON; + return C_MOVCON; + } + if(isbitcon(v)) + return C_BITCON; + if(isbitcon64(v)) + return C_BITCON64; + if(isbitcon32(v)) + return C_BITCON32; + return C_LCON; + + case D_EXTERN: + case D_STATIC: + s = a->sym; + if(s == S) + break; + t = s->type; + switch(t) { + case 0: + case SXREF: + diag("undefined external: %s in %s", + s->name, TNAME); + s->type = SDATA; + break; + case SUNDEF: + case STEXT: + case SSTRING: + case SCONST: + case SLEAF: + instoffset = s->value + a->offset; + return C_LCON; + } + if(!dlm) { + instoffset = s->value + a->offset; + if(instoffset != 0 && isaddcon(instoffset)) + return C_AECON; + } + instoffset = s->value + a->offset + INITDAT; + return C_LCON; + + case D_AUTO: + instoffset = autosize + a->offset; + goto aconsize; + + case D_PARAM: + instoffset = autosize + a->offset + PCSZ; + aconsize: + if(isaddcon(instoffset)) + return C_AACON; + return C_LACON; + } + return C_GOK; + + case D_BRANCH: + return C_SBRA; + } + return C_GOK; +} + +static int +asregclass(ushort as) +{ + switch(as){ + case AFMADDD: + case AFMADDS: + case AFMSUBD: + case AFMSUBS: + case AFNMADDS: + case AFNMADDD: + case AFNMSUBS: + case AFNMSUBD: + case AMOVPS: + case AMOVPD: + case AMOVPQ: return C_FREG; + } + return C_REG; +} + +Optab* +oplook(Prog *p) +{ + int a1, a2, a3, r; + char *c1, *c2, *c3; + Optab *o, *e; + + a1 = p->optab; + if(a1) + return optab+(a1-1); + a1 = p->from.class; + if(a1 == 0) { + a1 = aclass(&p->from) + 1; + p->from.class = a1; + } + a1--; + a3 = p->to.class; + if(a3 == 0) { + a3 = aclass(&p->to) + 1; + p->to.class = a3; + } + a3--; + a2 = C_NONE; + if(p->reg != NREG) + a2 = asregclass(p->as); + r = p->as; + o = oprange[r].start; + if(o == 0) { + a1 = opcross[repop[r]][a1][a2][a3]; + if(a1) { + p->optab = a1+1; + return optab+a1; + } + o = oprange[r].stop; /* just generate an error */ + } + if(0) { + print("oplook %A %d %d %d\n", + (int)p->as, a1, a2, a3); + print(" %d %d\n", p->from.type, p->to.type); + } + e = oprange[r].stop; + c1 = xcmp[a1]; + c2 = xcmp[a2]; + c3 = xcmp[a3]; + for(; oa2 == a2 || c2[o->a2]) + if(c1[o->a1]) + if(c3[o->a3]) { + if(0) + print("%P\t-> %d (%d %d %d)\n", p, o->type, + o->a1, o->a2, o->a3); + p->optab = (o-optab)+1; + return o; + } + diag("illegal combination %A %R %R %R", + p->as, a1, a2, a3); + prasm(p); + o = badop; + if(o == 0) + errorexit(); + return o; +} + +int +cmp(int a, int b) +{ + + if(a == b) + return 1; + switch(a) { + case C_RSP: + if(b == C_REG) + return 1; + break; + + case C_REG: + if(b == C_ZCON) + return 1; + break; + + case C_ADDCON0: + if(b == C_ZCON) + return 1; + break; + + case C_ADDCON: + if(b == C_ZCON || b == C_ADDCON0 || b == C_ABCON) + return 1; + break; + + case C_BITCON32: + case C_BITCON64: + if(b == C_BITCON) + return 1; + /* wet floor */ + case C_BITCON: + if(b == C_ABCON || b == C_MBCON) + return 1; + break; + + case C_MOVCON: + if(b == C_MBCON || b == C_ZCON || b == C_ADDCON0) + return 1; + break; + + case C_LCON: + if(b == C_ZCON || b == C_BITCON || b == C_BITCON32 || b == C_BITCON64 || b == C_ADDCON || b == C_ADDCON0 || b == C_ABCON || b == C_MBCON || b == C_MOVCON) + return 1; + break; + + case C_VCON: + return cmp(C_LCON, b); + + case C_LACON: + if(b == C_AACON) + return 1; + break; + + case C_SEXT2: + if(b == C_SEXT1) + return 1; + break; + + case C_SEXT4: + if(b == C_SEXT1 || b == C_SEXT2) + return 1; + break; + + case C_SEXT8: + if(b >= C_SEXT1 && b <= C_SEXT4) + return 1; + break; + + case C_SEXT16: + if(b >= C_SEXT1 && b <= C_SEXT8) + return 1; + break; + + case C_LEXT: + if(b >= C_SEXT1 && b <= C_SEXT16) + return 1; + break; + + case C_PPAUTO: + if(b == C_PSAUTO) + return 1; + break; + + case C_UAUTO4K: + if(b == C_PSAUTO || b == C_PPAUTO) + return 1; + break; + + case C_UAUTO8K: + return cmp(C_UAUTO4K, b); + + case C_UAUTO16K: + return cmp(C_UAUTO8K, b); + + case C_UAUTO32K: + return cmp(C_UAUTO16K, b); + + case C_UAUTO64K: + return cmp(C_UAUTO32K, b); + + case C_NPAUTO: + return cmp(C_NSAUTO, b); + + case C_LAUTO: + return cmp(C_NPAUTO, b) || cmp(C_UAUTO64K, b); + + case C_PSOREG: + if(b == C_ZOREG) + return 1; + break; + + case C_PPOREG: + if(b == C_ZOREG || b == C_PSOREG) + return 1; + break; + + case C_UOREG4K: + if(b == C_ZOREG || b == C_PSAUTO || b == C_PSOREG || b == C_PPAUTO || b == C_PPOREG) + return 1; + break; + + case C_UOREG8K: + return cmp(C_UOREG4K, b); + + case C_UOREG16K: + return cmp(C_UOREG8K, b); + + case C_UOREG32K: + return cmp(C_UOREG16K, b); + + case C_UOREG64K: + return cmp(C_UOREG32K, b); + + case C_NPOREG: + return cmp(C_NSOREG, b); + + case C_LOREG: + return cmp(C_NPOREG, b) || cmp(C_UOREG64K, b); + + case C_LBRA: + if(b == C_SBRA) + return 1; + break; + } + return 0; +} + +static int +ocmp(const void *a1, const void *a2) +{ + Optab *p1, *p2; + int n; + + p1 = (Optab*)a1; + p2 = (Optab*)a2; + n = p1->as - p2->as; + if(n) + return n; + n = p1->a1 - p2->a1; + if(n) + return n; + n = p1->a2 - p2->a2; + if(n) + return n; + n = p1->a3 - p2->a3; + if(n) + return n; + return 0; +} + +void +buildop(void) +{ + int i, n, r; + Oprang t; + + for(i=0; i +#include +#include +#include + +#include "/arm64/include/ureg.h" + +#define REGSIZE sizeof(struct Ureg) +#define FPREGSIZE 520 + +#define REGOFF(x) (uintptr)(&((struct Ureg *) 0)->x) +#define FP_REG(x) (REGSIZE+16*(x)) +#define FP_CTL(x) (FP_REG(32)+4*(x)) + +#define SP REGOFF(sp) +#define PC REGOFF(pc) + +Reglist arm64reglist[] = +{ + {"TYPE", REGOFF(type), RINT|RRDONLY, 'Y'}, + {"PSR", REGOFF(psr), RINT|RRDONLY, 'Y'}, + {"PC", PC, RINT, 'Y'}, + {"SP", SP, RINT, 'Y'}, + {"R30", REGOFF(r30), RINT, 'Y'}, + {"R29", REGOFF(r29), RINT, 'Y'}, + {"R28", REGOFF(r28), RINT, 'Y'}, + {"R27", REGOFF(r27), RINT, 'Y'}, + {"R26", REGOFF(r26), RINT, 'Y'}, + {"R25", REGOFF(r25), RINT, 'Y'}, + {"R24", REGOFF(r24), RINT, 'Y'}, + {"R23", REGOFF(r23), RINT, 'Y'}, + {"R22", REGOFF(r22), RINT, 'Y'}, + {"R21", REGOFF(r21), RINT, 'Y'}, + {"R20", REGOFF(r20), RINT, 'Y'}, + {"R19", REGOFF(r19), RINT, 'Y'}, + {"R18", REGOFF(r18), RINT, 'Y'}, + {"R17", REGOFF(r17), RINT, 'Y'}, + {"R16", REGOFF(r16), RINT, 'Y'}, + {"R15", REGOFF(r15), RINT, 'Y'}, + {"R14", REGOFF(r14), RINT, 'Y'}, + {"R13", REGOFF(r13), RINT, 'Y'}, + {"R12", REGOFF(r12), RINT, 'Y'}, + {"R11", REGOFF(r11), RINT, 'Y'}, + {"R10", REGOFF(r10), RINT, 'Y'}, + {"R9", REGOFF(r9), RINT, 'Y'}, + {"R8", REGOFF(r8), RINT, 'Y'}, + {"R7", REGOFF(r7), RINT, 'Y'}, + {"R6", REGOFF(r6), RINT, 'Y'}, + {"R5", REGOFF(r5), RINT, 'Y'}, + {"R4", REGOFF(r4), RINT, 'Y'}, + {"R3", REGOFF(r3), RINT, 'Y'}, + {"R2", REGOFF(r2), RINT, 'Y'}, + {"R1", REGOFF(r1), RINT, 'Y'}, + {"R0", REGOFF(r0), RINT, 'Y'}, + + {"FPSR", FP_CTL(1), RINT, 'X'}, + {"FPCR", FP_CTL(0), RINT, 'X'}, + + {"F31", FP_REG(31), RFLT, 'F'}, /* double */ + {"F30", FP_REG(30), RFLT, 'F'}, + {"F29", FP_REG(29), RFLT, 'F'}, + {"F28", FP_REG(28), RFLT, 'F'}, + {"F27", FP_REG(27), RFLT, 'F'}, + {"F26", FP_REG(26), RFLT, 'F'}, + {"F25", FP_REG(25), RFLT, 'F'}, + {"F24", FP_REG(24), RFLT, 'F'}, + {"F23", FP_REG(23), RFLT, 'F'}, + {"F22", FP_REG(22), RFLT, 'F'}, + {"F21", FP_REG(21), RFLT, 'F'}, + {"F20", FP_REG(20), RFLT, 'F'}, + {"F19", FP_REG(19), RFLT, 'F'}, + {"F18", FP_REG(18), RFLT, 'F'}, + {"F17", FP_REG(17), RFLT, 'F'}, + {"F16", FP_REG(16), RFLT, 'F'}, + {"F15", FP_REG(15), RFLT, 'F'}, + {"F14", FP_REG(14), RFLT, 'F'}, + {"F13", FP_REG(13), RFLT, 'F'}, + {"F12", FP_REG(12), RFLT, 'F'}, + {"F11", FP_REG(11), RFLT, 'F'}, + {"F10", FP_REG(10), RFLT, 'F'}, + {"F9", FP_REG(9), RFLT, 'F'}, + {"F8", FP_REG(8), RFLT, 'F'}, + {"F7", FP_REG(7), RFLT, 'F'}, + {"F6", FP_REG(6), RFLT, 'F'}, + {"F5", FP_REG(5), RFLT, 'F'}, + {"F4", FP_REG(4), RFLT, 'F'}, + {"F3", FP_REG(3), RFLT, 'F'}, + {"F2", FP_REG(2), RFLT, 'F'}, + {"F1", FP_REG(1), RFLT, 'F'}, + {"F0", FP_REG(0), RFLT, 'F'}, + + {"f31", FP_REG(31), RFLT, 'f'}, /* double */ + {"f30", FP_REG(30), RFLT, 'f'}, + {"f29", FP_REG(29), RFLT, 'f'}, + {"f28", FP_REG(28), RFLT, 'f'}, + {"f27", FP_REG(27), RFLT, 'f'}, + {"f26", FP_REG(26), RFLT, 'f'}, + {"f25", FP_REG(25), RFLT, 'f'}, + {"f24", FP_REG(24), RFLT, 'f'}, + {"f23", FP_REG(23), RFLT, 'f'}, + {"f22", FP_REG(22), RFLT, 'f'}, + {"f21", FP_REG(21), RFLT, 'f'}, + {"f20", FP_REG(20), RFLT, 'f'}, + {"f19", FP_REG(19), RFLT, 'f'}, + {"f18", FP_REG(18), RFLT, 'f'}, + {"f17", FP_REG(17), RFLT, 'f'}, + {"f16", FP_REG(16), RFLT, 'f'}, + {"f15", FP_REG(15), RFLT, 'f'}, + {"f14", FP_REG(14), RFLT, 'f'}, + {"f13", FP_REG(13), RFLT, 'f'}, + {"f12", FP_REG(12), RFLT, 'f'}, + {"f11", FP_REG(11), RFLT, 'f'}, + {"f10", FP_REG(10), RFLT, 'f'}, + {"f9", FP_REG(9), RFLT, 'f'}, + {"f8", FP_REG(8), RFLT, 'f'}, + {"f7", FP_REG(7), RFLT, 'f'}, + {"f6", FP_REG(6), RFLT, 'f'}, + {"f5", FP_REG(5), RFLT, 'f'}, + {"f4", FP_REG(4), RFLT, 'f'}, + {"f3", FP_REG(3), RFLT, 'f'}, + {"f2", FP_REG(2), RFLT, 'f'}, + {"f1", FP_REG(1), RFLT, 'f'}, + {"f0", FP_REG(0), RFLT, 'f'}, + { 0 } +}; + + /* the machine description */ +Mach marm64 = +{ + "arm64", + MARM64, /* machine type */ + arm64reglist, /* register set */ + REGSIZE, /* register set size */ + FPREGSIZE, /* fp register set size */ + "PC", /* name of PC */ + "SP", /* name of SP */ + "R30", /* name of link register */ + "setSB", /* static base register name */ + 0, /* static base register value */ + 0x10000, /* page size (for segment alignment) */ + 0x200100000ULL, /* kernel base */ + 0x200100000ULL, /* kernel text mask */ + 0x0BFFFFFFFULL, /* user stack top */ + 4, /* quantization of pc */ + 8, /* szaddr */ + 8, /* szreg */ + 4, /* szfloat */ + 8, /* szdouble */ +}; --- /dev/null Thu Mar 12 09:30:04 2026 +++ /sys/src/libmach/7db.c Sun Mar 8 13:38:34 2026 @@ -0,0 +1,800 @@ +#include +#include +#include +#include + +typedef struct Opcode Opcode; +struct Opcode +{ + char *p; + char *o; + char *a; +}; + +typedef struct Instr Instr; +struct Instr +{ + Opcode *op; + Map *map; + uvlong addr; + ulong w; + + char *curr; /* fill point in buffer */ + char *end; /* end of buffer */ +}; + +static void format(char*, Instr*, char*); +static char FRAMENAME[] = ".frame"; + +/* + * Arm64-specific debugger interface + */ +static char* arm64excep(Map*, Rgetter); +static int arm64foll(Map*, uvlong, Rgetter, uvlong*); +static int arm64inst(Map*, uvlong, char, char*, int); +static int arm64das(Map*, uvlong, char*, int); +static int arm64instlen(Map*, uvlong); + +/* + * Debugger interface + */ +Machdata arm64mach = +{ + {0x00, 0x00, 0x20, 0xD4}, /* break point 0xD4200000 */ + 4, /* break point size */ + leswab, /* short to local byte order */ + leswal, /* long to local byte order */ + leswav, /* long to local byte order */ + risctrace, /* C traceback */ + riscframe, /* Frame finder */ + arm64excep, /* print exception */ + 0, /* breakpoint fixup */ + leieeesftos, /* single precision float printer */ + leieeedftos, /* double precision float printer */ + arm64foll, /* following addresses */ + arm64inst, /* print instruction */ + arm64das, /* dissembler */ + arm64instlen, /* instruction size */ +}; + +static Opcode opcodes[] = +{ + "0AA10000AAAAAAAAAAAAAAAAAAAddddd", "ADR", "$%A,R%d", + "1PP10000PPPPPPPPPPPPPPPPPPPddddd", "ADRP", "$%P,R%d", + "00011000lllllllllllllllllllddddd", "MOVWU", "%l,R%d", + "01011000LLLLLLLLLLLLLLLLLLLddddd", "MOV", "%L,R%d", + "10011000lllllllllllllllllllddddd", "MOVW", "%l,R%d", + "11011000lllllllllllllllllllddddd", "PRFM", "%l,$%d", + "1111100100uuuuuuuuuuuu11111ddddd", "MOV", "R%d,%u(SP)", + "1111100100uuuuuuuuuuuunnnnnddddd", "MOV", "R%d,%u(R%n)", + "WW11100100uuuuuuuuuuuu11111ddddd", "MOV%WU", "R%d,%u(SP)", + "WW11100100uuuuuuuuuuuunnnnnddddd", "MOV%WU", "R%d,%u(R%n)", + "1111100101uuuuuuuuuuuu11111ddddd", "MOV", "%u(SP),R%d", + "1111100101uuuuuuuuuuuunnnnnddddd", "MOV", "%u(R%n),R%d", + "WW11100101uuuuuuuuuuuu11111ddddd", "MOV%WU", "%u(SP),R%d", + "WW11100101uuuuuuuuuuuunnnnnddddd", "MOV%WU", "%u(R%n),R%d", + "WW11100110uuuuuuuuuuuu11111ddddd", "MOV%W", "%u(SP),R%d", + "WW11100110uuuuuuuuuuuunnnnnddddd", "MOV%W", "%u(R%n),R%d", + "11111000000ooooooooo0011111ddddd", "MOV", "R%d,%o(SP)", + "11111000000ooooooooo00nnnnnddddd", "MOV", "R%d,%o(R%n)", + "WW111000000ooooooooo0011111ddddd", "MOV%W", "R%d,%o(SP)", + "WW111000000ooooooooo00nnnnnddddd", "MOV%W", "R%d,%o(R%n)", + "11111000010ooooooooo0011111ddddd", "MOV", "%o(SP),R%d", + "11111000010ooooooooo00nnnnnddddd", "MOV", "%o(R%n),R%d", + "WW111000010ooooooooo0011111ddddd", "MOV%WU", "%o(SP),R%d", + "WW111000010ooooooooo00nnnnnddddd", "MOV%WU", "%o(R%n),R%d", + "WW111000100ooooooooo0011111ddddd", "MOV%W", "%o(SP),R%d", + "WW111000100ooooooooo00nnnnnddddd", "MOV%W", "%o(R%n),R%d", + "11111000000ooooooooo0111111ddddd", "MOV", "R%d,(SP)%o!", + "WW111000000ooooooooo0111111ddddd", "MOV%WU", "R%d,(SP)%o!", + "WW111000000ooooooooo01nnnnnddddd", "MOV%WU", "R%d,(R%n)%o!", + "11111000000ooooooooo1111111ddddd", "MOV", "R%d,%o(SP)!", + "WW111000000ooooooooo1111111ddddd", "MOV%WU", "R%d,%o(SP)!", + "WW111000000ooooooooo11nnnnnddddd", "MOV%WU", "R%d,%o(R%n)!", + "11111000010ooooooooo0111111ddddd", "MOV", "(SP)%o!,R%d", + "11111000010ooooooooo01nnnnnddddd", "MOV", "(R%n)%o!,R%d", + "WW111000010ooooooooo0111111ddddd", "MOV%WU", "(SP)%o!,R%d", + "WW111000010ooooooooo01nnnnnddddd", "MOV%WU", "(R%n)%o!,R%d", + "WW111000100ooooooooo0111111ddddd", "MOV%W", "(SP)%o!,R%d", + "WW111000100ooooooooo01nnnnnddddd", "MOV%W", "(R%n)%o!,R%d", + "11111000010ooooooooo1111111ddddd", "MOV", "%o(SP)!,R%d", + "11111000010ooooooooo11nnnnnddddd", "MOV", "%o(R%n)!,R%d", + "WW111000010ooooooooo1111111ddddd", "MOV%WU", "%o(SP)!,R%d", + "WW111000010ooooooooo11nnnnnddddd", "MOV%WU", "%o(R%n)!,R%d", + "WW111000100ooooooooo1111111ddddd", "MOV%W", "%o(SP)!,R%d", + "WW111000100ooooooooo11nnnnnddddd", "MOV%W", "%o(R%n)!,R%d", + "11111000001mmmmmeeei10nnnnnddddd", "MOV", "R%d,(R%n)(R%m%e)", + "11111000111mmmmmeeei10nnnnnddddd", "MOV", "(R%n)(R%m%e),R%d", + "WW111000001mmmmmeeei10nnnnnddddd", "MOV%W", "R%d,(R%n)(R%m%e)", + "WW111000011mmmmmeeei10nnnnnddddd", "MOV%WU", "(R%n)(R%m%e),R%d", + "WW111000101mmmmmeeei10nnnnnddddd", "MOV%W", "(R%n)(R%m%e),R%d", + "WW111000111mmmmmeeei10nnnnnddddd", "MOV%WW", "(R%n)(R%m%e),R%d", + "W00100101ssKKKKKKKKKKKKKKKKddddd", "MOVN%W", "$%K,R%d", + "W10100101ssKKKKKKKKKKKKKKKKddddd", "MOVZ%W", "$%K,R%d", + "W11100101ssKKKKKKKKKKKKKKKKddddd", "MOVK%W", "$%K,R%d", + "W0010001--00000000000011111ddddd", "MOV%W", "SP,R%d", + "W0010001--000000000000nnnnn11111", "MOV%W", "R%n,SP", + "0110100011ooooooommmmm11111ddddd", "MOVPSW", "(SP)%o!,R%d,R%m", + "0110100011ooooooommmmmnnnnnddddd", "MOVPSW", "(R%n)%o!,R%d,R%m", + "0110100101ooooooommmmm11111ddddd", "MOVPSW", "%o(SP),R%d,R%m", + "0110100101ooooooommmmmnnnnnddddd", "MOVPSW", "%o(R%n),R%d,R%m", + "0110100111ooooooommmmm11111ddddd", "MOVPSW", "%o(SP)!,R%d,R%m", + "0110100111ooooooommmmmnnnnnddddd", "MOVPSW", "%o(R%n)!,R%d,R%m", + "W010100010ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,(SP)%o!", + "W010100010ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,(R%n)%o!", + "W010100100ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,%o(SP)", + "W010100100ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,%o(R%n)", + "W010100110ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,%o(SP)!", + "W010100110ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,%o(R%n)!", + "W010100011ooooooommmmm11111ddddd", "MOVP%W", "(SP)%o!,R%d,R%m", + "W010100011ooooooommmmmnnnnnddddd", "MOVP%W", "(R%n)%o!,R%d,R%m", + "W010100101ooooooommmmm11111ddddd", "MOVP%W", "%o(SP),R%d,R%m", + "W010100101ooooooommmmmnnnnnddddd", "MOVP%W", "%o(R%n),R%d,R%m", + "W010100111ooooooommmmm11111ddddd", "MOVP%W", "%o(SP)!,R%d,R%m", + "W010100111ooooooommmmmnnnnnddddd", "MOVP%W", "%o(R%n)!,R%d,R%m", + "W0010001ssIIIIIIIIIIII1111111111", "ADD%W", "$%I,SP,SP", + "W0010001ssIIIIIIIIIIII11111ddddd", "ADD%W", "$%I,SP,R%d", + "W0010001ssIIIIIIIIIIIInnnnn11111", "ADD%W", "$%I,R%n,SP", + "W0110001ssIIIIIIIIIIII1111111111", "ADDS%W", "$%I,SP,SP", + "W0110001ssIIIIIIIIIIII11111ddddd", "ADDS%W", "$%I,SP,R%d", + "W0110001ssIIIIIIIIIIIInnnnn11111", "ADDS%W", "$%I,R%n,SP", + "W1010001ssIIIIIIIIIIII1111111111", "SUB%W", "$%I,SP,SP", + "W1010001ssIIIIIIIIIIII11111ddddd", "SUB%W", "$%I,SP,R%d", + "W1010001ssIIIIIIIIIIIInnnnn11111", "SUB%W", "$%I,R%n,SP", + "W1110001ssIIIIIIIIIIII1111111111", "CMP%W", "$%I,SP", + "W1110001ssIIIIIIIIIIIInnnnn11111", "CMP%W", "$%I,R%n", + "W1110001ssIIIIIIIIIIII11111ddddd", "SUBS%W", "$%I,SP,R%d", + "W0010001ssIIIIIIIIIIIInnnnnddddd", "ADD%W", "$%I,R%n,R%d", + "W0110001ssIIIIIIIIIIIInnnnnddddd", "ADDS%W", "$%I,R%n,R%d", + "W1010001ssIIIIIIIIIIIInnnnnddddd", "SUB%W", "$%I,R%n,R%d", + "W1110001ssIIIIIIIIIIIInnnnnddddd", "SUBS%W", "$%I,R%n,R%d", + "W00100100MMMMMMMMMMMMMnnnnn11111", "AND%W", "$%M,R%n,SP", + "W01100100MMMMMMMMMMMMMnnnnn11111", "ORR%W", "$%M,R%n,SP", + "W10100100MMMMMMMMMMMMMnnnnn11111", "EOR%W", "$%M,R%n,SP", + "W11100100MMMMMMMMMMMMMnnnnn11111", "ANDS%W", "$%M,R%n,SP", + "W00100100MMMMMMMMMMMMMnnnnnddddd", "AND%W", "$%M,R%n,R%d", + "W01100100MMMMMMMMMMMMMnnnnnddddd", "ORR%W", "$%M,R%n,R%d", + "W10100100MMMMMMMMMMMMMnnnnnddddd", "EOR%W", "$%M,R%n,R%d", + "W11100100MMMMMMMMMMMMMnnnnnddddd", "ANDS%W", "$%M,R%n,R%d", + "1001001101000000011111nnnnnddddd", "SXTW", "R%n,R%d", + "0101001100iiiiii011111nnnnnddddd", "LSRW", "$%i,R%n,R%d", + "1101001101iiiiii111111nnnnnddddd", "LSR", "$%i,R%n,R%d", + "W00100111-0mmmmmiiiiiinnnnnddddd", "EXTR%W", "$%i,R%m,R%n,R%d", + "W00100110-iiiiiijjjjjjnnnnnddddd", "SBFM%W", "$%i,$%j,R%n,R%d", + "W01100110-iiiiiijjjjjjnnnnnddddd", "BFM%W", "$%i,$%j,R%n,R%d", + "W10100110-iiiiiijjjjjjnnnnnddddd", "UBFM%W", "$%i,$%j,R%n,R%d", + "W1011010000mmmmm00000011111ddddd", "NGC%W", "R%m,R%d", + "W1111010000mmmmm00000011111ddddd", "NGCS%W", "R%m,R%d", + "W0011010000mmmmm000000nnnnnddddd", "ADC%W", "R%m,R%n,R%d", + "W0111010000mmmmm000000nnnnnddddd", "ADCS%W", "R%m,R%n,R%d", + "W1011010000mmmmm000000nnnnnddddd", "SBC%W", "R%m,R%n,R%d", + "W1111010000mmmmm000000nnnnnddddd", "SBCS%W", "R%m,R%n,R%d", + "W0101011ss0mmmmmiiiiiinnnnn11111", "CMN%W", "R%m%s,R%n", + "W1101011ss0mmmmmiiiiiinnnnn11111", "CMP%W", "R%m%s,R%n", + "W1001011ss0mmmmmiiiiii11111ddddd", "NEG%W", "R%m%s,R%d", + "W1101011ss0mmmmmiiiiii11111ddddd", "NEGS%W", "R%m%s,R%d", + "W0001011ss0mmmmmiiiiiinnnnnddddd", "ADD%W", "R%m%s,R%n,R%d", + "W0101011ss0mmmmmiiiiiinnnnnddddd", "ADDS%W", "R%m%s,R%n,R%d", + "W1001011ss0mmmmmiiiiiinnnnnddddd", "SUB%W", "R%m%s,R%n,R%d", + "W1101011ss0mmmmmiiiiiinnnnnddddd", "SUBS%W", "R%m%s,R%n,R%d", + "W0001011001mmmmmeeeiii1111111111", "ADD%W", "R%m%e,SP,SP", + "W0001011001mmmmmeeeiii11111ddddd", "ADD%W", "R%m%e,SP,R%d", + "W0001011001mmmmmeeeiiinnnnn11111", "ADD%W", "R%m%e,R%n,SP", + "W0101011001mmmmmeeeiii1111111111", "ADDS%W", "R%m%e,SP,SP", + "W0101011001mmmmmeeeiii11111ddddd", "ADDS%W", "R%m%e,SP,R%d", + "W0101011001mmmmmeeeiiinnnnn11111", "ADDS%W", "R%m%e,R%n,SP", + "W1001011001mmmmmeeeiii1111111111", "SUB%W", "R%m%e,SP,SP", + "W1001011001mmmmmeeeiii11111ddddd", "SUB%W", "R%m%e,SP,R%d", + "W1001011001mmmmmeeeiiinnnnn11111", "SUB%W", "R%m%e,R%n,SP", + "W1101011001mmmmmeeeiii1111111111", "SUBS%W", "R%m%e,SP,SP", + "W1101011001mmmmmeeeiii11111ddddd", "SUBS%W", "R%m%e,SP,R%d", + "W1101011001mmmmmeeeiiinnnnn11111", "SUBS%W", "R%m%e,R%n,SP", + "W0001011001mmmmmeeeiiinnnnnddddd", "ADD%W", "R%m%e,R%n,R%d", + "W0101011001mmmmmeeeiiinnnnnddddd", "ADDS%W", "R%m%e,R%n,R%d", + "W1001011001mmmmmeeeiiinnnnnddddd", "SUB%W", "R%m%e,R%n,R%d", + "W1101011001mmmmmeeeiiinnnnnddddd", "SUBS%W", "R%m%e,R%n,R%d", + "W0101010000mmmmm-0000011111ddddd", "MOV%W", "R%m,R%d", + "W0101010ss1mmmmmiiiiii11111ddddd", "NVM%W", "R%m%s,R%d", + "W1101010ss0mmmmmiiiiiinnnnn11111", "TST%W", "R%m%s,R%n", + "W0001010ss0mmmmmiiiiiinnnnnddddd", "AND%W", "R%m%s,R%n,R%d", + "W1101010ss0mmmmmiiiiiinnnnnddddd", "ANDS%W", "R%m%s,R%n,R%d", + "W0001010ss1mmmmmiiiiiinnnnnddddd", "BIC%W", "R%m%s,R%n,R%d", + "W1101010ss1mmmmmiiiiiinnnnnddddd", "BICS%W", "R%m%s,R%n,R%d", + "W1001010ss0mmmmmiiiiiinnnnnddddd", "EOR%W", "R%m%s,R%n,R%d", + "W1001010ss1mmmmmiiiiiinnnnnddddd", "EON%W", "R%m%s,R%n,R%d", + "W0101010ss0mmmmmiiiiiinnnnnddddd", "ORR%W", "R%m%s,R%n,R%d", + "W0101010ss1mmmmmiiiiiinnnnnddddd", "ORN%W", "R%m%s,R%n,R%d", + "W0011010110mmmmm001000nnnnnddddd", "LSL%W", "R%m,R%n,R%d", + "W0011010110mmmmm001001nnnnnddddd", "LSR%W", "R%m,R%n,R%d", + "W0011010110mmmmm001010nnnnnddddd", "ASR%W", "R%m,R%n,R%d", + "W0011010110mmmmm001011nnnnnddddd", "ROR%W", "R%m,R%n,R%d", + "W0011010110mmmmm000010nnnnnddddd", "UDIV%W", "R%m,R%n,R%d", + "W0011010110mmmmm000011nnnnnddddd", "SDIV%W", "R%m,R%n,R%d", + "W0011011000mmmmm011111nnnnnddddd", "MUL%W", "R%m,R%n,R%d", + "W0011011000mmmmm111111nnnnnddddd", "MNEG%W", "R%m,R%n,R%d", + "W0011011000mmmmm0aaaaannnnnddddd", "MADD%W", "R%m,R%n,R%a,R%d", + "W0011011000mmmmm1aaaaannnnnddddd", "MSUB%W", "R%m,R%n,R%a,R%d", + "10011011001mmmmm011111nnnnnddddd", "SMULL", "R%m,R%n,R%d", + "10011011001mmmmm111111nnnnnddddd", "SMNEGL", "R%m,R%n,R%d", + "10011011001mmmmm0aaaaannnnnddddd", "SMADDL", "R%m,R%n,R%a,R%d", + "10011011001mmmmm1aaaaannnnnddddd", "SMSUBL", "R%m,R%n,R%a,R%d", + "10011011101mmmmm011111nnnnnddddd", "UMULL", "R%m,R%n,R%d", + "10011011101mmmmm111111nnnnnddddd", "UMNEGL", "R%m,R%n,R%d", + "10011011101mmmmm0aaaaannnnnddddd", "UMADDL", "R%m,R%n,R%a,R%d", + "10011011101mmmmm1aaaaannnnnddddd", "UMSUBL", "R%m,R%n,R%a,R%d", + "b0110110bbbbbTTTTTTTTTTTTTTddddd", "TBZ", "$%b,R%d,%T", + "b0110111bbbbbTTTTTTTTTTTTTTddddd", "TBNZ", "$%b,R%d,%T", + "W0110100TTTTTTTTTTTTTTTTTTTddddd", "CBZ%W", "R%d,%T", + "W0110101TTTTTTTTTTTTTTTTTTTddddd", "CBNZ%W", "R%d,%T", + "01010100TTTTTTTTTTTTTTTTTTT0CCCC", "B%C", "%T", + "000101TTTTTTTTTTTTTTTTTTTTTTTTTT", "B", "%T", + "100101TTTTTTTTTTTTTTTTTTTTTTTTTT", "BL", "%T", + "1101011000011111000000nnnnn00000", "BR", "R%n", + "1101011000111111000000nnnnn00000", "BLR", "R%n", + "11010110010111110000001111000000", "RETURN", nil, + "1101011001011111000000nnnnn00000", "RET", "R%n", + "11010110100111110000001111100000", "ERET", nil, + "11010110101111110000001111100000", "DRPS", nil, + "11010100000iiiiiiiiiiiiiiii00001", "SVC", "$%i", + "11010100000iiiiiiiiiiiiiiii00010", "HVC", "$%i", + "11010100000iiiiiiiiiiiiiiii00011", "SMC", "$%i", + "11010100001iiiiiiiiiiiiiiii00000", "BRK", "$%i", + "11010100010iiiiiiiiiiiiiiii00000", "HLT", "$%i", + "11010100101iiiiiiiiiiiiiiii00001", "DCPS1", "$%i", + "11010100101iiiiiiiiiiiiiiii00010", "DCPS2", "$%i", + "11010100101iiiiiiiiiiiiiiii00011", "DCPS3", "$%i", + "11010101000000110010000000011111", "NOP", nil, + "11010101000000110010000000111111", "YIELD", nil, + "11010101000000110010000001011111", "WFE", nil, + "11010101000000110010000001111111", "WFI", nil, + "11010101000000110010000010011111", "SEV", nil, + "11010101000000110010000010111111", "SEVL", nil, + "11010101000000110011xxxx01011111", "CLREX", "$%x", + "11010101000000110011xxxx10011111", "DSB", "$%x", + "11010101000000110011xxxx10111111", "DMB", "$%x", + "11010101000000110011xxxx11011111", "ISB", "$%x", + "1101010100001YYYYYYYYYYYYYY11111", "SYS", "%Y", + "1101010100001YYYYYYYYYYYYYYddddd", "SYS", "R%d,%Y", + "1101010100101YYYYYYYYYYYYYYddddd", "SYSL", "%Y,R%d", + "11010101000000000100xxxx10111111", "MSR", "$%x,SP", + "11010101000000110100xxxx11011111", "MSR", "$%x,DAIFSet", + "11010101000000110100xxxx11111111", "MSR", "$%x,DAIFClr", + "11010101000YYYYYYYYYYYYYYYYddddd", "MSR", "R%d,%Y", + "11010101001YYYYYYYYYYYYYYYYddddd", "MRS", "%Y,R%d", + "FF11110101uuuuuuuuuuuu11111ddddd", "FMOV%F", "%u(SP),F%d", + "FF11110101uuuuuuuuuuuunnnnnddddd", "FMOV%F", "%u(R%n),F%d", + "FF111100010ooooooooo0011111ddddd", "FMOV%F", "%o(SP),F%d", + "FF111100010ooooooooo00nnnnnddddd", "FMOV%F", "%o(R%n),F%d", + "FF11110100uuuuuuuuuuuu11111ddddd", "FMOV%F", "F%d,%u(SP)", + "FF11110100uuuuuuuuuuuunnnnnddddd", "FMOV%F", "F%d,%u(R%n)", + "00011110ZZ100000010000nnnnnddddd", "FMOV%Z", "F%m,F%d", + "00011110ZZ1ffffffff10000000ddddd", "FMOV%Z", "$%f,F%d", + "x0011110ZZ100110000000nnnnnddddd", "FMOV%Z", "F%n,R%d", + "x0011110ZZ100111000000nnnnnddddd", "FMOV%Z", "R%n,F%d", + "W0011110ZZ111000000000nnnnnddddd", "FCVTZS%Z%W", "F%n,R%d", + "W0011110ZZ111001000000nnnnnddddd", "FCVTZU%Z%W", "F%n,R%d", + "00011110ZZ10001zz10000nnnnnddddd", "FCVT%Z%z", "F%n,F%d", + "00011110ZZ100000001000nnnnn01000", "FCMP%Z", "$0.0,F%n", + "00011110ZZ1mmmmm001000nnnnn00000", "FCMP%Z", "F%m,F%n", + "W0011110ZZ100010000000nnnnnddddd", "SCVTF%W%Z", "R%n,F%d", + "00011110ZZ1mmmmm000010nnnnnddddd", "FMUL%Z", "F%m,F%n,F%d", + "00011110ZZ1mmmmm000110nnnnnddddd", "FDIV%Z", "F%m,F%n,F%d", + "00011110ZZ1mmmmm001010nnnnnddddd", "FADD%Z", "F%m,F%n,F%d", + "00011110ZZ1mmmmm001110nnnnnddddd", "FSUB%Z", "F%m,F%n,F%d", + "WW00100011011111111111nnnnnddddd", "LDAR%W", "(R%n),R%d", + "WW00100001011111111111nnnnnddddd", "LDAXR%W", "(R%n),R%d", + "WW00100001011111011111nnnnnddddd", "LDXR%W", "(R%n),R%d", + "WW00100010011111111111nnnnnddddd", "STLR%W", "R%n,(R%d)", + "WW001000000mmmmm111111nnnnnddddd", "STLXR%W", "R%n,(R%d),R%m", + "WW001000000mmmmm011111nnnnnddddd", "STXR%W", "R%n,(R%d),R%m", + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "WORD", "$%x", +}; + +#define SYSARG5(op0,op1,Cn,Cm,op2) ((op0)<<19|(op1)<<16|(Cn)<<12|(Cm)<<8|(op2)<<5) + +static ulong +smask(char *s, char c) +{ + ulong m; + int i; + + m = 0; + for(i=0; i<32 && *s != '\0'; i++, s++) + m |= (*s == c)<<(31-i); + return m; +} + +static int +nbits(ulong v) +{ + int n = 0; + while(v != 0){ + v &= v-1; + n++; + } + return n; +} + +static int +nones(ulong v) +{ + int n = 0; + while(v & 1){ + v >>= 1; + n++; + } + return n; +} + +static int +nshift(ulong m) +{ + if(m == 0 || m == ~0UL) + return 0; + return nones(~m); +} + +static ulong +unshift(ulong w, ulong m) +{ + int s = nshift(m); + w >>= s, m >>= s; + if((m+1 & m) != 0){ // 0bxxx0000yyyyyy -> 0byyyyyyxxx + ulong b = (1UL< 0){ + l <<= sizeof(l)*8 - n; + l >>= sizeof(l)*8 - n; + } + return l; +} + +static char* +arm64excep(Map *, Rgetter) +{ +// uvlong c = (*rget)(map, "TYPE"); + return "???"; +} + +static int +decode(Map *map, uvlong pc, Instr *i) +{ + static ulong tab[2*nelem(opcodes)]; + static int once; + ulong w, j; + + if(!once){ + Opcode *o; + + /* precalculate value/mask table */ + for(j=0, o=opcodes; jp, '1'); + tab[j|1] = tab[j] | smask(o->p, '0'); + } + + once = 1; + } + + if(get4(map, pc, &w) < 0) { + werrstr("can't read instruction: %r"); + return -1; + } + i->addr = pc; + i->map = map; + i->w = w; + + for(j=0; jop = &opcodes[j/2]; + return 1; + } + } + + /* should not happen */ + return 0; +} + +#pragma varargck argpos bprint 2 + +static void +bprint(Instr *i, char *fmt, ...) +{ + va_list arg; + + va_start(arg, fmt); + i->curr = vseprint(i->curr, i->end, fmt, arg); + va_end(arg); +} + +static +char* shtype[4] = +{ + "<<", ">>", "->", "@>" +}; + +static +char* rextype[8] = +{ + "UB", "UH", "UW", "UX", + "SB", "SH", "SW", "SX" +}; + +static +char* scond[16] = +{ + "EQ", "NE", "HS", "LO", + "MI", "PL", "VS", "VC", + "HI", "LS", "GE", "LT", + "GT", "LE", "", "NV", +}; + +static uvlong +decodebitmask(int n, int s, int r) +{ + uvlong w; + int e; + + if(n) + n = 6; + else { + for(n = 5; n >= 1 && ((~s & 0x3F) & (1<> r) | (w << (e-r)); + if(e < 64) + w &= (1ULL << e)-1; + } + while(e < 64){ + w |= w << e; + e <<= 1; + } + return w; +} + +static void +format(char *mnemonic, Instr *i, char *f) +{ + Symbol s; + uvlong v; + ulong w, u, m; + char sf[16]; + + if(mnemonic) + format(0, i, mnemonic); + if(f == 0) + return; + if(mnemonic) + if(i->curr < i->end) + *i->curr++ = '\t'; + for ( ; *f && i->curr < i->end; f++) { + if(*f != '%') { + *i->curr++ = *f; + continue; + } + m = smask(i->op->p, *++f); + u = unshift(i->w, m); + switch (*f) { + case 'C': // Condition + bprint(i, "%s", scond[u & 15]); + break; + + case 'W': // Width + if(nbits(m) == 1) u += 2; + u &= 3; + if(u < 3) + *i->curr++ = "BHW"[u]; + break; + + case 'F': // FP width + u &= 3; + *i->curr++ = "BHSD"[u]; + break; + + case 'b': // Bit position + u = (u & 1)<<5 | (u >> 1); + /* wet floor */ + case 'd': // Register Numbers + case 'n': + case 'a': + case 'm': + bprint(i, "%lud", u); + break; + + case 's': // Register shift + w = unshift(i->w, smask(i->op->p, 'i')); + if(w != 0) + bprint(i, "%s%lud", shtype[u & 3], w); + break; + + case 'e': // Register extension + u &= 7; + bprint(i, ".%s", rextype[u]); + w = unshift(i->w, smask(i->op->p, 'i')); + if(w != 0 && u == 2+(i->w>>31)) + bprint(i, "<<%lud", w); + break; + + case 'M': // Bitmask + v = decodebitmask((u>>12)&1, u&0x3F, (u>>6)&0x3F); + if((i->w & (1<<31)) == 0) + v &= 0xFFFFFFFF; + bprint(i, "%llux", v); + break; + + case 'I': // Shifted Immediate (12 bit) + case 'K': // Shifted Immediate (16 bit) + w = unshift(i->w, smask(i->op->p, 's')); + if(u != 0 && w != 0) + bprint(i, "(%lux<<%ld)", u, w*(*f == 'I' ? 12 : 16)); + else + bprint(i, "%lud", u); + break; + + case 'f': // Floating point immediate + u = ((u & 0x80)<<8 | ((u & 0x40) ? 0x3e00 : 0x4000) | (u & 0x3f)<<3) << 16; + strcpy(sf, "???"); + ieeesftos(sf, sizeof(sf), u); + bprint(i, "%s", sf + (*sf == ' ')); + break; + + case 'o': // Signed byte offset + w = nbits(m); + bprint(i, "%ld", sext(u, w) << (w == 7 ? 2 + (i->w>>31) : 0)); + break; + case 'u': // Unsigned offset + u <<= (i->w >> 30)&3; + /* wet floor */ + case 'i': // Decimal + case 'j': + bprint(i, "%lud", u); + break; + + case 'x': // Hex + bprint(i, "%lux", u); + break; + + case 'l': // 32-bit Literal + if(get4(i->map, i->addr + sext(u, nbits(m))*4, &w) < 0) + goto Ptext; + bprint(i, "$%lux", w); + break; + case 'L': // 64-bit Literal + if(get8(i->map, i->addr + sext(u, nbits(m))*4, &v) < 0) + goto Ptext; + bprint(i, "$%llux", v); + break; + case 'T': // Text address (PC relative) + Ptext: + v = i->addr + sext(u, nbits(m))*4; + if(findsym(v, CTEXT, &s)){ + bprint(i, "%s", s.name); + if(v < s.value) + bprint(i, "%llx", v - s.value); + else if(v > s.value) + bprint(i, "+%llx", v - s.value); + bprint(i, "(SB)"); + break; + } + bprint(i, "%llux(SB)", v); + break; + case 'A': // Data address (PC relative) + v = i->addr + sext(u, nbits(m)); + goto Pdata; + case 'P': // Page address (PC relative) + v = i->addr + ((vlong)sext(u, nbits(m)) << 12); + Pdata: + if(findsym(v, CANY, &s)){ + bprint(i, "%s", s.name); + if(v < s.value) + bprint(i, "%llx", v - s.value); + else if(v > s.value) + bprint(i, "+%llx", v - s.value); + bprint(i, "(SB)"); + break; + } + bprint(i, "%llux(SB)", v); + break; + + case 'Y': + if(nbits(m) == 14){ // SYS/SYSL operands + bprint(i, "%lud,%lud,%lud,%lud", + (u>>(4+4+3))&7, // op1 + (u>>(4+3))&15, // CRn + (u>>3)&15, // CRm + (u)&7); // op2 + break; + } + /* see /sys/src/cmd/7c/7.out.h */ + switch(i->w & m){ + case SYSARG5(3,3,4,2,1): bprint(i, "DAIF"); break; + case SYSARG5(3,3,4,2,0): bprint(i, "NZCV"); break; + case SYSARG5(3,3,4,4,1): bprint(i, "FPSR"); break; + case SYSARG5(3,3,4,4,0): bprint(i, "FPCR"); break; + case SYSARG5(3,0,4,0,0): bprint(i, "SPSR_EL1"); break; + case SYSARG5(3,0,4,0,1): bprint(i, "ELR_EL1"); break; + case SYSARG5(3,4,4,0,0): bprint(i, "SPSR_EL2"); break; + case SYSARG5(3,4,4,0,1): bprint(i, "ELR_EL2"); break; + case SYSARG5(3,0,4,2,2): bprint(i, "CurrentEL"); break; + case SYSARG5(3,0,4,1,0): bprint(i, "SP_EL0"); break; + case SYSARG5(3,0,4,2,0): bprint(i, "SPSel"); break; + default: bprint(i, "SPR(%lux)", i->w & m); + } + break; + + case 'Z': // FP type + case 'z': + *i->curr++ = "SD?H"[u]; + break; + + case '\0': + *i->curr++ = '%'; + return; + + default: + bprint(i, "%%%c", *f); + break; + } + } + *i->curr = 0; +} + +static int +printins(Map *map, uvlong pc, char *buf, int n) +{ + Instr i[1]; + + i->curr = buf; + i->end = buf+n-1; + if(decode(map, pc, i) < 0) + return -1; + format(i->op->o, i, i->op->a); + return 4; +} + +static int +arm64inst(Map *map, uvlong pc, char modifier, char *buf, int n) +{ + USED(modifier); + return printins(map, pc, buf, n); +} + +static int +arm64das(Map *map, uvlong pc, char *buf, int n) +{ + Instr i[1]; + + i->curr = buf; + i->end = buf+n; + if(decode(map, pc, i) < 0) + return -1; + if(i->end-i->curr > 8) + i->curr = _hexify(buf, i->w, 7); + *i->curr = 0; + return 4; +} + +static int +arm64instlen(Map*, uvlong) +{ + return 4; +} + +static uvlong +readreg(Instr *i, Rgetter rget, int rc) +{ + ulong m; + uvlong v; + char reg[4]; + snprint(reg, sizeof(reg), "R%lud", unshift(i->w, smask(i->op->p, rc))); + v = (*rget)(i->map, reg); + m = smask(i->op->p, 'W'); + if(m != 0 && unshift(i->w, m) == 0) + v &= 0xFFFFFFFFULL; + return v; +} + +static int +passcond(Instr *i, Rgetter rget) +{ + uvlong psr; + uchar n; + uchar z; + uchar c; + uchar v; + + psr = (*rget)(i->map, "PSR"); + n = (psr >> 31) & 1; + z = (psr >> 30) & 1; + c = (psr >> 29) & 1; + v = (psr >> 28) & 1; + + switch(unshift(i->w, smask(i->op->p, 'C'))) { + default: + case 0: return z; + case 1: return !z; + case 2: return c; + case 3: return !c; + case 4: return n; + case 5: return !n; + case 6: return v; + case 7: return !v; + case 8: return c && !z; + case 9: return !c || z; + case 10: return n == v; + case 11: return n != v; + case 12: return !z && (n == v); + case 13: return z || (n != v); + case 14: return 1; + case 15: return 0; + } +} + +static uvlong +jumptarg(Instr *i) +{ + ulong m = smask(i->op->p, 'T'); + return i->addr + sext(unshift(i->w, m), nbits(m))*4; +} + +static int +arm64foll(Map *map, uvlong pc, Rgetter rget, uvlong *foll) +{ + Instr i[1]; + char *o; + + if(decode(map, pc, i) < 0) + return -1; + + o = i->op->o; + if(strcmp(o, "ERET") == 0) + return -1; + if(strcmp(o, "RET") == 0 || strcmp(o, "BR") == 0 || strcmp(o, "BLR") == 0){ + foll[0] = readreg(i, rget, 'n'); + return 1; + } + if(strcmp(o, "RETURN") == 0){ + foll[0] = rget(i->map, "R30"); + return 1; + } + if(strcmp(o, "B") == 0 || strcmp(o, "BL") == 0){ + foll[0] = jumptarg(i); + return 1; + } + if(strcmp(o, "B%C") == 0){ + if(passcond(i, rget)){ + foll[0] = jumptarg(i); + return 1; + } + } + if(strcmp(o, "CBZ%W") == 0){ + if(readreg(i, rget, 'd') == 0){ + foll[0] = jumptarg(i); + return 1; + } + } + if(strcmp(o, "CBNZ%W") == 0){ + if(readreg(i, rget, 'd') != 0){ + foll[0] = jumptarg(i); + return 1; + } + } + + foll[0] = i->addr+4; + return 1; +} --- /dev/null Thu Mar 12 09:30:04 2026 +++ /sys/src/libmach/7obj.c Sun Mar 8 13:38:37 2026 @@ -0,0 +1,153 @@ +/* + * 7obj.c - identify and parse an arm64 object file + */ +#include +#include +#include +#include +#include "7c/7.out.h" +#include "obj.h" + +typedef struct Addr Addr; +struct Addr +{ + char type; + char sym; + char name; +}; +static Addr addr(Biobuf*); +static char type2char(int); +static void skip(Biobuf*, int); + +int +_is7(char *s) +{ + return s[0] == (ANAME&0xff) /* aslo = ANAME */ + && s[1] == ((ANAME>>8)&0xff) + && s[2] == D_FILE /* type */ + && s[3] == 1 /* sym */ + && s[4] == '<'; /* name of file */ +} + +int +_read7(Biobuf *bp, Prog *p) +{ + int as, n; + Addr a; + + as = (uchar)Bgetc(bp); /* as */ + as |= (uchar)Bgetc(bp)<<8; + if(as <= AXXX || as >= ALAST) + return 0; + p->kind = aNone; + p->sig = 0; + if(as == ANAME || as == ASIGNAME){ + if(as == ASIGNAME){ + Bread(bp, &p->sig, 4); + p->sig = leswal(p->sig); + } + p->kind = aName; + p->type = type2char(Bgetc(bp)); /* type */ + p->sym = Bgetc(bp); /* sym */ + n = 0; + for(;;) { + as = Bgetc(bp); + if(as < 0) + return 0; + n++; + if(as == 0) + break; + } + p->id = malloc(n); + if(p->id == 0) + return 0; + Bseek(bp, -n, 1); + if(Bread(bp, p->id, n) != n) + return 0; + return 1; + } + if(as == ATEXT) + p->kind = aText; + else if(as == AGLOBL) + p->kind = aData; + n = (uchar)Bgetc(bp); /* reg and flag (1) */ + skip(bp, 4); /* lineno(4) */ + a = addr(bp); + if(n & 0x40) + addr(bp); /* from3 */ + addr(bp); + if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN) + p->kind = aNone; + p->sym = a.sym; + return 1; +} + +static Addr +addr(Biobuf *bp) +{ + Addr a; + long off; + + a.type = Bgetc(bp); /* a.type */ + skip(bp,1); /* reg */ + a.sym = Bgetc(bp); /* sym index */ + a.name = Bgetc(bp); /* sym type */ + switch(a.type){ + default: + case D_NONE: + case D_REG: + case D_SP: + case D_FREG: + case D_VREG: + case D_COND: + break; + + case D_OREG: + case D_XPRE: + case D_XPOST: + case D_CONST: + case D_BRANCH: + case D_SHIFT: + case D_EXTREG: + case D_ROFF: + case D_SPR: + off = Bgetc(bp); + off |= Bgetc(bp) << 8; + off |= Bgetc(bp) << 16; + off |= Bgetc(bp) << 24; + if(off < 0) + off = -off; + if(a.sym && (a.name==D_PARAM || a.name==D_AUTO)) + _offset(a.sym, off); + break; + case D_DCONST: + skip(bp, 8); + break; + case D_SCONST: + skip(bp, NSNAME); + break; + case D_FCONST: + skip(bp, 8); + break; + } + return a; +} + +static char +type2char(int t) +{ + switch(t){ + case D_EXTERN: return 'U'; + case D_STATIC: return 'b'; + case D_AUTO: return 'a'; + case D_PARAM: return 'p'; + default: return UNKNOWN; + } +} + +static void +skip(Biobuf *bp, int n) +{ + while (n-- > 0) + Bgetc(bp); +} --- /sys/src/libmach/alphaobj.c Thu Sep 27 18:58:21 2012 +++ /sys/src/libmach/alphaobj.c Thu Mar 5 20:45:13 2026 @@ -20,7 +20,7 @@ static void skip(Biobuf*, int); int -_is7(char *s) +_is7a(char *s) { return s[0] == ANAME /* ANAME */ && s[1] == D_FILE /* type */ @@ -29,7 +29,7 @@ } int -_read7(Biobuf *bp, Prog *p) +_read7a(Biobuf *bp, Prog *p) { int as, n; Addr a; --- /sys/src/libmach/executable.c Fri Jan 30 09:43:35 2026 +++ /sys/src/libmach/executable.c Sun Mar 8 19:48:09 2026 @@ -67,6 +67,7 @@ extern Mach mi386; extern Mach mamd64; extern Mach marm; +extern Mach marm64; extern Mach mpower; extern Mach mpower64; extern Mach malpha; @@ -237,6 +238,15 @@ sizeof(Exec), leswal, armdotout }, + { R_MAGIC, /* Arm64 7.out and boot image */ + "arm64 plan 9 executable", + "arm64 plan 9 dlm", + FARM64, + 1, + &marm64, + sizeof(Exec)+8, + nil, + commonllp64 }, { L_MAGIC, /* alpha 7.out */ "alpha plan 9 executable", "alpha plan 9 dlm", @@ -413,6 +423,12 @@ fp->type = FARMB; fp->txtaddr = (u32int)fp->entry; fp->name = "ARM plan 9 boot image"; + fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize); + return; + case FARM64: + fp->type = FARM64B; + fp->txtaddr = fp->entry; + fp->name = "arm64 plan 9 boot image"; fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize); return; case FALPHA: --- /sys/src/libmach/mkfile Fri Jan 30 09:43:35 2026 +++ /sys/src/libmach/mkfile Sat Mar 7 19:15:47 2026 @@ -19,6 +19,7 @@ 68020\ 5\ 6\ + 7\ alpha\ 8\ 9\ @@ -31,6 +32,7 @@ 68020db\ 5db\ alphadb\ + 7db\ 8db\ idb\ vobj\ @@ -39,6 +41,7 @@ 68020obj\ 5obj\ 6obj\ + 7obj\ alphaobj\ 8obj\ 9obj\ @@ -67,6 +70,7 @@ 5obj.$O: /sys/src/cmd/5c/5.out.h 6obj.$O: /sys/src/cmd/6c/6.out.h alphaobj.$O: alpha/7.out.h +7obj.$O: /sys/src/cmd/7c/7.out.h 8obj.$O: /sys/src/cmd/8c/8.out.h 9obj.$O: 9c/9.out.h kobj.$O: /sys/src/cmd/kc/k.out.h --- /sys/src/libmach/obj.c Fri Jan 30 09:43:35 2026 +++ /sys/src/libmach/obj.c Thu Mar 5 20:49:16 2026 @@ -25,6 +25,7 @@ _is5(char*), _is6(char*), _is7(char*), + _is7a(char*), _is8(char*), _is9(char*), _isk(char*), @@ -37,6 +38,7 @@ _read5(Biobuf*, Prog*), _read6(Biobuf*, Prog*), _read7(Biobuf*, Prog*), + _read7a(Biobuf*, Prog*), _read8(Biobuf*, Prog*), _read9(Biobuf*, Prog*), _readk(Biobuf*, Prog*), @@ -60,7 +62,8 @@ [Obj68020] "68020 .2", _is2, _read2, [ObjAmd64] "amd64 .6", _is6, _read6, [ObjArm] "arm .5", _is5, _read5, - [ObjAlpha] "alpha .7", _is7, _read7, + [ObjArm64] "arm64 .7", _is7, _read7, + [ObjAlpha] "alpha .7", _is7a, _read7a, [Obj386] "386 .8", _is8, _read8, [ObjSparc] "sparc .k", _isk, _readk, [ObjPower] "power .q", _isq, _readq, --- /sys/src/libmach/setmach.c Fri Jan 30 09:43:35 2026 +++ /sys/src/libmach/setmach.c Thu Mar 5 20:18:42 2026 @@ -17,9 +17,9 @@ }; extern Mach mmips, mmips64, msparc, m68020, mi386, mamd64, mriscv, mriscv64, - marm, /* mmips2be, mmips2le, */ mpower, mpower64, malpha, msparc64; + marm, marm64, /* mmips2be, mmips2le, */ mpower, mpower64, malpha, msparc64; extern Machdata mipsmach, mipsmachle, sparcmach, m68020mach, i386mach, riscvmach, riscv64mach, - armmach, mipsmach2le, powermach, alphamach, sparc64mach; + armmach, arm64mach, mipsmach2le, powermach, alphamach, sparc64mach; /* * machine selection table. machines with native disassemblers should @@ -142,6 +142,12 @@ ARISCV64, &mriscv64, &riscv64mach, }, + { "arm64", + FARM64, + FARM64B, + AARM64, + &marm64, + &arm64mach, }, { 0 }, /*the terminator*/ };