root/src/dps8/dps8_utils.h

/* */

INCLUDED FROM

DEFINITIONS

1. getbits36
2. getbits36_1
3. getbits36_2
4. getbits36_3
5. getbits36_4
6. getbits36_5
7. getbits36_6
8. getbits36_7
9. getbits36_8
10. getbits36_9
11. getbits36_10
12. getbits36_12
13. getbits36_14
14. getbits36_15
15. getbits36_16
16. getbits36_18
17. getbits36_24
18. getbits36_28
19. setbits36
20. setbits36_1
21. setbits36_4
22. setbits36_5
23. setbits36_6
24. setbits36_8
25. setbits36_9
26. setbits36_16
27. setbits36_24
28. putbits36
29. putbits36_1
30. putbits36_2
31. putbits36_3
32. putbits36_4
33. putbits36_5
34. putbits36_6
35. putbits36_7
36. putbits36_8
37. putbits36_9
38. putbits36_10
39. putbits36_12
40. putbits36_13
41. putbits36_14
42. putbits36_15
43. putbits36_16
44. putbits36_17
45. putbits36_18
46. putbits36_23
47. putbits36_24
48. putbits36_28
49. putbits72
50. getbits18
51. putbits18
52. setmask
53. clrmask

   1 /*
   2  * vim: filetype=c:tabstop=4:ai:expandtab
   3  * SPDX-License-Identifier: ICU
   4  * scspell-id: 1881c7a6-f62f-11ec-b538-80ee73e9b8e7
   5  *
   6  * ---------------------------------------------------------------------------
   7  *
   8  * Copyright (c) 2007-2013 Michael Mondy
   9  * Copyright (c) 2012-2016 Harry Reed
  10  * Copyright (c) 2013-2018 Charles Anthony
  11  * Copyright (c) 2021-2025 The DPS8M Development Team
  12  *
  13  * This software is made available under the terms of the ICU License.
  14  * See the LICENSE.md file at the top-level directory of this distribution.
  15  *
  16  * ---------------------------------------------------------------------------
  17  */
  18 
  19 // Interface for cfg_parse
  20 
  21 typedef struct config_value_list_s
  22   {
  23     const char * value_name;
  24     int64_t value;
  25   } config_value_list_t;
  26 
  27 typedef struct config_list_s
  28   {
  29     const char * name;  // opt name
  30     int64_t min, max;   // value limits
  31     config_value_list_t * value_list;
  32   } config_list_t;
  33 
  34 typedef struct config_state_s
  35   {
  36     char * copy;
  37     char * statement_save;
  38   } config_state_t;
  39 
  40 int cfg_parse (const char * tag, const char * cptr, config_list_t * clist, config_state_t * state, int64_t * result);
  41 void cfg_parse_done (config_state_t * state);
  42 
  43 struct opcode_s * get_iwb_info (DCDstruct *i);
  44 char * dump_flags(char * buffer, word18 flags);
  45 char *disassemble(char * result, word36 instruction);
  46 char *get_mod_string(char * msg, word6 tag);
  47 word72 convert_to_word72 (word36 even, word36 odd);
  48 void convert_to_word36 (word72 src, word36 *even, word36 *odd);
  49 
  50 word36 compl36(cpu_state_t * cpup, word36 op1, word18 *flags, bool * ovf);
  51 word18 compl18(cpu_state_t * cpup, word18 op1, word18 *flags, bool * ovf);
  52 
  53 void copyBytes(int posn, word36 src, word36 *dst);
  54 void copyChars(int posn, word36 src, word36 *dst);
  55 
  56 void putByte(word36 *dst, word9 data, int posn);
  57 void putChar(word36 *dst, word6 data, int posn);
  58 
  59 void cmp36(cpu_state_t * cpup, word36 op1, word36 op2, word18 *flags);
  60 void cmp36wl(cpu_state_t * cpup, word36 A, word36 Y, word36 Q, word18 *flags);
  61 void cmp18(cpu_state_t * cpup, word18 op1, word18 op2, word18 *flags);
  62 void cmp72(cpu_state_t * cpup, word72 op1, word72 op2, word18 *flags);
  63 
  64 char *strlower(char *q);
  65 int strmask(char *str, char *mask);
  66 char *Strtok(char *, char *);
  67 char *stripquotes(char *s);
  68 char *trim(char *s);
  69 char *ltrim(char *s);
  70 char *rtrim(char *s);
  71 
  72 //
  73 // getbitsNN/setbitsNN/putbitsNN
  74 //
  75 //   Manipulate bitfields.
  76 //     NN      the word size (18, 36, 72).
  77 //     data    the incoming word
  78 //     i       the starting bit number (DPS8 notation, 0 is the MSB)
  79 //     n       the number of bits, starting at i
  80 //     val     the bits
  81 //
  82 //   val = getbitsNN (data, i, n)
  83 //
  84 //       extract n bits from data, starting at i.
  85 //
  86 //           val = getbits36 (data, 0, 1) --> the sign bit
  87 //           val = getbits36 (data, 18, 18) --> the low eighteen bits
  88 //
  89 //   newdata = setbitsNN (data, i, n, val)
  90 //
  91 //       return 'data' with n bits of val inserted.
  92 //
  93 //           newdata = setbits36 (data, 0, 18, 1) --> move '1' into the high
  94 //                                                    18 bits.
  95 //
  96 //   putbitsNN (& data, i, n, val)
  97 //
  98 //        put val into data (equivalent to 'data = setbitsNN (data, ....)'
  99 //
 100 //           putbits (& data, 0, 18, 1) --> set the high 18 bits to '1'.
 101 //
 102 
 103 
 104 
 105 
 106 
 107 
 108 
 109 
 110 
 111 
 112 
 113 
 114 
 115 
 116 
 117 
 118 static inline word36 getbits36(word36 x, uint i, uint n) {
     /*  */
 119     // bit 35 is right end, bit zero is 36th from the right
 120     int shift = 35-(int)i-(int)n+1;
 121     if (shift < 0 || shift > 35) {
 122         sim_printf ("getbits36: bad args (%012llu,i=%d,n=%d)\r\n", (unsigned long long)x, i, n);
 123         return 0;
 124     } else
 125         return (x >> (unsigned) shift) & ~ (~0U << n);
 126 }
 127 
 128 static inline word1 getbits36_1 (word36 x, uint i)
     /*  */
 129   {
 130     // bit 35 is right end, bit zero is 36th from the right
 131     int shift = 35-(int)i;
 132     if (shift < 0 || shift > 35) {
 133         sim_printf ("getbits36_1: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 134         return 0;
 135     } else
 136         return (x >> (unsigned) shift) & 01;
 137   }
 138 
 139 static inline word2 getbits36_2 (word36 x, uint i)
     /*  */
 140   {
 141     // bit 35 is right end, bit zero is 36th from the right
 142     int shift = 35-(int)i-(int)2+1;
 143     if (shift < 0 || shift > 35) {
 144         sim_printf ("getbits36_2: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 145         return 0;
 146     } else
 147         return (x >> (unsigned) shift) & 03;
 148   }
 149 
 150 static inline word3 getbits36_3 (word36 x, uint i)
     /*  */
 151   {
 152     // bit 35 is right end, bit zero is 36th from the right
 153     int shift = 35-(int)i-(int)3+1;
 154     if (shift < 0 || shift > 35) {
 155         sim_printf ("getbits36_3: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 156         return 0;
 157     } else
 158         return (x >> (unsigned) shift) & 07;
 159   }
 160 
 161 static inline word4 getbits36_4 (word36 x, uint i)
     /*  */
 162   {
 163     // bit 35 is right end, bit zero is 36th from the right
 164     int shift = 35-(int)i-(int)4+1;
 165     if (shift < 0 || shift > 35) {
 166         sim_printf ("getbits36_4: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 167         return 0;
 168     } else
 169         return (x >> (unsigned) shift) & 017;
 170   }
 171 
 172 static inline word5 getbits36_5 (word36 x, uint i)
     /*  */
 173   {
 174     // bit 35 is right end, bit zero is 36th from the right
 175     int shift = 35-(int)i-(int)5+1;
 176     if (shift < 0 || shift > 35) {
 177         sim_printf ("getbits36_5: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 178         return 0;
 179     } else
 180         return (x >> (unsigned) shift) & 037;
 181   }
 182 
 183 static inline word6 getbits36_6 (word36 x, uint i)
     /*  */
 184   {
 185     // bit 35 is right end, bit zero is 36th from the right
 186     int shift = 35-(int)i-(int)6+1;
 187     if (shift < 0 || shift > 35) {
 188         sim_printf ("getbits36_6: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 189         return 0;
 190     } else
 191         return (x >> (unsigned) shift) & 077;
 192   }
 193 
 194 static inline word7 getbits36_7 (word36 x, uint i)
     /*  */
 195   {
 196     // bit 35 is right end, bit zero is 36th from the right
 197     int shift = 35-(int)i-(int)7+1;
 198     if (shift < 0 || shift > 35) {
 199         sim_printf ("getbits36_7: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 200         return 0;
 201     } else
 202         return (x >> (unsigned) shift) & 0177;
 203   }
 204 
 205 static inline word8 getbits36_8 (word36 x, uint i)
     /*  */
 206   {
 207     // bit 35 is right end, bit zero is 36th from the right
 208     int shift = 35-(int)i-(int)8+1;
 209     if (shift < 0 || shift > 35) {
 210         sim_printf ("getbits36_8: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 211         return 0;
 212     } else
 213         return (x >> (unsigned) shift) & 0377;
 214   }
 215 
 216 static inline word9 getbits36_9 (word36 x, uint i)
     /*  */
 217   {
 218     // bit 35 is right end, bit zero is 36th from the right
 219     int shift = 35-(int)i-(int)9+1;
 220     if (shift < 0 || shift > 35) {
 221         sim_printf ("getbits36_9: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 222         return 0;
 223     } else
 224         return (x >> (unsigned) shift) & 0777;
 225   }
 226 
 227 static inline word10 getbits36_10 (word36 x, uint i)
     /*  */
 228   {
 229     // bit 35 is right end, bit zero is 36th from the right
 230     int shift = 35-(int)i-(int)10+1;
 231     if (shift < 0 || shift > 35) {
 232         sim_printf ("getbits36_10: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 233         return 0;
 234     } else
 235         return (x >> (unsigned) shift) & 01777;
 236   }
 237 
 238 static inline word12 getbits36_12 (word36 x, uint i)
     /*  */
 239   {
 240     // bit 35 is right end, bit zero is 36th from the right
 241     int shift = 35-(int)i-(int)12+1;
 242     if (shift < 0 || shift > 35) {
 243         sim_printf ("getbits36_12: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 244         return 0;
 245     } else
 246         return (x >> (unsigned) shift) & 07777;
 247   }
 248 
 249 static inline word14 getbits36_14 (word36 x, uint i)
     /*  */
 250   {
 251     // bit 35 is right end, bit zero is 36th from the right
 252     int shift = 35-(int)i-(int)14+1;
 253     if (shift < 0 || shift > 35) {
 254         sim_printf ("getbits36_14: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 255         return 0;
 256     } else
 257         return (x >> (unsigned) shift) & 037777;
 258   }
 259 
 260 static inline word15 getbits36_15 (word36 x, uint i)
     /*  */
 261   {
 262     // bit 35 is right end, bit zero is 36th from the right
 263     int shift = 35-(int)i-(int)15+1;
 264     if (shift < 0 || shift > 35) {
 265         sim_printf ("getbits36_15: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 266         return 0;
 267     } else
 268         return (x >> (unsigned) shift) & 077777;
 269   }
 270 
 271 static inline word16 getbits36_16 (word36 x, uint i)
     /*  */
 272   {
 273     // bit 35 is right end, bit zero is 36th from the right
 274     int shift = 35-(int)i-(int)16+1;
 275     if (shift < 0 || shift > 35) {
 276         sim_printf ("getbits36_16: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 277         return 0;
 278     } else
 279         return (x >> (unsigned) shift) & 0177777;
 280   }
 281 
 282 static inline word18 getbits36_18 (word36 x, uint i)
     /*  */
 283   {
 284     // bit 35 is right end, bit zero is 36th from the right
 285     int shift = 35-(int)i-(int)18+1;
 286     if (shift < 0 || shift > 35) {
 287         sim_printf ("getbits36_18: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 288         return 0;
 289     } else
 290         return (x >> (unsigned) shift) & 0777777;
 291   }
 292 
 293 static inline word24 getbits36_24 (word36 x, uint i)
     /*  */
 294   {
 295     // bit 35 is right end, bit zero is 36th from the right
 296     int shift = 35-(int)i-(int)24+1;
 297     if (shift < 0 || shift > 35) {
 298         sim_printf ("getbits36_24: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 299         return 0;
 300     } else
 301         return (x >> (unsigned) shift) & MASK24;
 302   }
 303 
 304 static inline word28 getbits36_28 (word36 x, uint i)
     /*  */
 305   {
 306     // bit 35 is right end, bit zero is 36th from the right
 307     int shift = 35-(int)i-(int)28+1;
 308     if (shift < 0 || shift > 35) {
 309         sim_printf ("getbits36_28: bad args (%012llu,i=%d)\r\n", (unsigned long long)x, i);
 310         return 0;
 311     } else
 312         return (x >> (unsigned) shift) & 01777777777;
 313   }
 314 
 315 static inline word36 setbits36(word36 x, uint p, uint n, word36 val)
     /*  */
 316 {
 317     int shift = 36 - (int) p - (int) n;
 318     if (shift < 0 || shift > 35) {
 319         sim_printf ("setbits36: bad args (%012llu,pos=%d,n=%d)\r\n", (unsigned long long)x, p, n);
 320         return 0;
 321     }
 322     word36 mask = ~ (~0U<<n);  // n low bits on
 323     mask <<= (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 324     // caller may provide val that is too big, e.g., a word with all bits
 325     // set to one, so we mask val
 326     word36 result = (x & ~ mask) | ((val&MASKBITS(n)) << (36 - p - n));
 327     return result;
 328 }
 329 
 330 static inline word36 setbits36_1 (word36 x, uint p, word1 val)
     /*  */
 331 {
 332     const int n = 1;
 333     int shift = 36 - (int) p - (int) n;
 334     if (shift < 0 || shift > 35) {
 335         sim_printf ("setbits36_1: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 336         return 0;
 337     }
 338     word36 mask = ~ (~0U<<n);  // n low bits on
 339     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 340     // caller may provide val that is too big, e.g., a word with all bits
 341     // set to one, so we mask val
 342     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 343     return result;
 344 }
 345 
 346 static inline word36 setbits36_4 (word36 x, uint p, word4 val)
     /*  */
 347 {
 348     const int n = 4;
 349     int shift = 36 - (int) p - (int) n;
 350     if (shift < 0 || shift > 35) {
 351         sim_printf ("setbits36_4: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 352         return 0;
 353     }
 354     word36 mask = ~ (~0U<<n);  // n low bits on
 355     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 356     // caller may provide val that is too big, e.g., a word with all bits
 357     // set to one, so we mask val
 358     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 359     return result;
 360 }
 361 
 362 static inline word36 setbits36_5 (word36 x, uint p, word5 val)
     /*  */
 363 {
 364     const int n = 5;
 365     int shift = 36 - (int) p - (int) n;
 366     if (shift < 0 || shift > 35) {
 367         sim_printf ("setbits36_5: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 368         return 0;
 369     }
 370     word36 mask = ~ (~0U<<n);  // n low bits on
 371     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 372     // caller may provide val that is too big, e.g., a word with all bits
 373     // set to one, so we mask val
 374     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 375     return result;
 376 }
 377 
 378 static inline word36 setbits36_6 (word36 x, uint p, word6 val)
     /*  */
 379 {
 380     const int n = 6;
 381     int shift = 36 - (int) p - (int) n;
 382     if (shift < 0 || shift > 35) {
 383         sim_printf ("setbits36_6: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 384         return 0;
 385     }
 386     word36 mask = ~ (~0U<<n);  // n low bits on
 387     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 388     // caller may provide val that is too big, e.g., a word with all bits
 389     // set to one, so we mask val
 390     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 391     return result;
 392 }
 393 
 394 static inline word36 setbits36_8 (word36 x, uint p, word8 val)
     /*  */
 395 {
 396     const int n = 8;
 397     int shift = 36 - (int) p - (int) n;
 398     if (shift < 0 || shift > 35) {
 399         sim_printf ("setbits36_8: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 400         return 0;
 401     }
 402     word36 mask = ~ (~0U<<n);  // n low bits on
 403     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 404     // caller may provide val that is too big, e.g., a word with all bits
 405     // set to one, so we mask val
 406     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 407     return result;
 408 }
 409 
 410 static inline word36 setbits36_9 (word36 x, uint p, word9 val)
     /*  */
 411 {
 412     const int n = 9;
 413     int shift = 36 - (int) p - (int) n;
 414     if (shift < 0 || shift > 35) {
 415         sim_printf ("setbits36_9: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 416         return 0;
 417     }
 418     word36 mask = ~ (~0U<<n);  // n low bits on
 419     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 420     // caller may provide val that is too big, e.g., a word with all bits
 421     // set to one, so we mask val
 422     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 423     return result;
 424 }
 425 
 426 static inline word36 setbits36_16 (word36 x, uint p, word16 val)
     /*  */
 427 {
 428     const int n = 16;
 429     int shift = 36 - (int) p - (int) n;
 430     if (shift < 0 || shift > 35) {
 431         sim_printf ("setbits36_16: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 432         return 0;
 433     }
 434     word36 mask = ~ (~0U<<n);  // n low bits on
 435     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 436     // caller may provide val that is too big, e.g., a word with all bits
 437     // set to one, so we mask val
 438     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 439     return result;
 440 }
 441 
 442 static inline word36 setbits36_24 (word36 x, uint p, word24 val)
     /*  */
 443 {
 444     const int n = 24;
 445     int shift = 36 - (int) p - (int) n;
 446     if (shift < 0 || shift > 35) {
 447         sim_printf ("setbits36_24: bad args (%012llu,pos=%d)\r\n", (unsigned long long)x, p);
 448         return 0;
 449     }
 450     word36 mask = ~ (~0U<<n);  // n low bits on
 451     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 452     // caller may provide val that is too big, e.g., a word with all bits
 453     // set to one, so we mask val
 454     word36 result = (x & ~ smask) | (((word36) val & mask) << shift);
 455     return result;
 456 }
 457 
 458 static inline void putbits36 (word36 * x, uint p, uint n, word36 val)
     /*  */
 459   {
 460     int shift = 36 - (int) p - (int) n;
 461     if (shift < 0 || shift > 35)
 462       {
 463         sim_printf ("putbits36: bad args (%012llu,pos=%d,n=%d)\r\n", (unsigned long long)*x, p, n);
 464         return;
 465       }
 466     // ~0U is 32 bits: (word36)~0U << n left ones in bits 32-63, which the
 467     // shift below moved onto bits 0-2 of the word when p + n > 32 (e.g.
 468     // putbits36 (rega, 32, 1, ...) cleared bit 0; SM781 04B).
 469     word36 mask = ~ ((~ (word36) 0) << n);  // n low bits on
 470     mask <<= (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 471     // caller may provide val that is too big, e.g., a word with all bits
 472     // set to one, so we mask val
 473     * x = (* x & ~mask) | ((val & MASKBITS (n)) << (36 - p - n));
 474     return;
 475   }
 476 
 477 static inline void putbits36_1 (word36 * x, uint p, word1 val)
     /*  */
 478 {
 479     const int n = 1;
 480     int shift = 36 - (int) p - (int) n;
 481     if (shift < 0 || shift > 35) {
 482         sim_printf ("putbits36_1: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 483         return;
 484     }
 485     word36 mask = ~ (~0U<<n);  // n low bits on
 486     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 487     // caller may provide val that is too big, e.g., a word with all bits
 488     // set to one, so we mask val
 489     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 490 }
 491 
 492 static inline void putbits36_2 (word36 * x, uint p, word2 val)
     /*  */
 493 {
 494     const int n = 2;
 495     int shift = 36 - (int) p - (int) n;
 496     if (shift < 0 || shift > 35) {
 497         sim_printf ("putbits36_2: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 498         return;
 499     }
 500     word36 mask = ~ (~0U<<n);  // n low bits on
 501     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 502     // caller may provide val that is too big, e.g., a word with all bits
 503     // set to one, so we mask val
 504     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 505 }
 506 
 507 static inline void putbits36_3 (word36 * x, uint p, word3 val)
     /*  */
 508 {
 509     const int n = 3;
 510     int shift = 36 - (int) p - (int) n;
 511     if (shift < 0 || shift > 35) {
 512         sim_printf ("putbits36_3: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 513         return;
 514     }
 515     word36 mask = ~ (~0U<<n);  // n low bits on
 516     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 517     // caller may provide val that is too big, e.g., a word with all bits
 518     // set to one, so we mask val
 519     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 520 }
 521 
 522 static inline void putbits36_4 (word36 * x, uint p, word4 val)
     /*  */
 523 {
 524     const int n = 4;
 525     int shift = 36 - (int) p - (int) n;
 526     if (shift < 0 || shift > 35) {
 527         sim_printf ("putbits36_4: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 528         return;
 529     }
 530     word36 mask = ~ (~0U<<n);  // n low bits on
 531     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 532     // caller may provide val that is too big, e.g., a word with all bits
 533     // set to one, so we mask val
 534     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 535 }
 536 
 537 static inline void putbits36_5 (word36 * x, uint p, word5 val)
     /*  */
 538 {
 539     const int n = 5;
 540     int shift = 36 - (int) p - (int) n;
 541     if (shift < 0 || shift > 35) {
 542         sim_printf ("putbits36_5: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 543         return;
 544     }
 545     word36 mask = ~ (~0U<<n);  // n low bits on
 546     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 547     // caller may provide val that is too big, e.g., a word with all bits
 548     // set to one, so we mask val
 549     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 550 }
 551 
 552 static inline void putbits36_6 (word36 * x, uint p, word6 val)
     /*  */
 553 {
 554     const int n = 6;
 555     int shift = 36 - (int) p - (int) n;
 556     if (shift < 0 || shift > 35) {
 557         sim_printf ("putbits36_6: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 558         return;
 559     }
 560     word36 mask = ~ (~0U<<n);  // n low bits on
 561     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 562     // caller may provide val that is too big, e.g., a word with all bits
 563     // set to one, so we mask val
 564     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 565 }
 566 
 567 static inline void putbits36_7 (word36 * x, uint p, word7 val)
     /*  */
 568 {
 569     const int n = 7;
 570     int shift = 36 - (int) p - (int) n;
 571     if (shift < 0 || shift > 35) {
 572         sim_printf ("putbits36_7: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 573         return;
 574     }
 575     word36 mask = ~ (~0U<<n);  // n low bits on
 576     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 577     // caller may provide val that is too big, e.g., a word with all bits
 578     // set to one, so we mask val
 579     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 580 }
 581 
 582 static inline void putbits36_8 (word36 * x, uint p, word8 val)
     /*  */
 583 {
 584     const int n = 8;
 585     int shift = 36 - (int) p - (int) n;
 586     if (shift < 0 || shift > 35) {
 587         sim_printf ("putbits36_8: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 588         return;
 589     }
 590     word36 mask = ~ (~0U<<n);  // n low bits on
 591     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 592     // caller may provide val that is too big, e.g., a word with all bits
 593     // set to one, so we mask val
 594     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 595 }
 596 
 597 static inline void putbits36_9 (word36 * x, uint p, word9 val)
     /*  */
 598 {
 599     const int n = 9;
 600     int shift = 36 - (int) p - (int) n;
 601     if (shift < 0 || shift > 35) {
 602         sim_printf ("putbits36_9: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 603         return;
 604     }
 605     word36 mask = ~ (~0U<<n);  // n low bits on
 606     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 607     // caller may provide val that is too big, e.g., a word with all bits
 608     // set to one, so we mask val
 609 #if !defined(__OPEN64__)
 610 # if defined(__GNUC__) && !defined(__PCC__)
 611 #  if !defined(__clang_version__)
 612 #   if __GNUC__ > 3
 613 #    pragma GCC diagnostic push
 614 #    pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 615 #   endif /* if __GNUC__ > 3 */
 616 #  endif /* if !defined(__clang_version__) */
 617 # endif /* if defined(__GNUC__) && !defined(__PCC__) */
 618 #endif /* if !defined(__OPEN64__) */
 619     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 620 #if !defined(__OPEN64__)
 621 # if defined(__GNUC__)
 622 #  if !defined(__clang_version__)
 623 #   if __GNUC__ > 3
 624 #    pragma GCC diagnostic pop
 625 #   endif /* if __GNUC__ > 3 */
 626 #  endif /* if !defined(__clang_version__) */
 627 # endif /* if defined(__GNUC__) */
 628 #endif /* if !defined(__OPEN64__) */
 629 }
 630 
 631 static inline void putbits36_10 (word36 * x, uint p, word10 val)
     /*  */
 632 {
 633     const int n = 10;
 634     int shift = 36 - (int) p - (int) n;
 635     if (shift < 0 || shift > 35) {
 636         sim_printf ("putbits36_10: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 637         return;
 638     }
 639     word36 mask = ~ (~0U<<n);  // n low bits on
 640     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 641     // caller may provide val that is too big, e.g., a word with all bits
 642     // set to one, so we mask val
 643     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 644 }
 645 
 646 static inline void putbits36_12 (word36 * x, uint p, word12 val)
     /*  */
 647 {
 648     const int n = 12;
 649     int shift = 36 - (int) p - (int) n;
 650     if (shift < 0 || shift > 35) {
 651         sim_printf ("putbits36_12: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 652         return;
 653     }
 654     word36 mask = ~ (~0U<<n);  // n low bits on
 655     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 656     // caller may provide val that is too big, e.g., a word with all bits
 657     // set to one, so we mask val
 658     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 659 }
 660 
 661 static inline void putbits36_13 (word36 * x, uint p, word13 val)
     /*  */
 662 {
 663     const int n = 13;
 664     int shift = 36 - (int) p - (int) n;
 665     if (shift < 0 || shift > 35) {
 666         sim_printf ("putbits36_13: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 667         return;
 668     }
 669     word36 mask = ~ (~0U<<n);  // n low bits on
 670     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 671     // caller may provide val that is too big, e.g., a word with all bits
 672     // set to one, so we mask val
 673     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 674 }
 675 
 676 static inline void putbits36_14 (word36 * x, uint p, word14 val)
     /*  */
 677 {
 678     const int n = 14;
 679     int shift = 36 - (int) p - (int) n;
 680     if (shift < 0 || shift > 35) {
 681         sim_printf ("putbits36_14: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 682         return;
 683     }
 684     word36 mask = ~ (~0U<<n);  // n low bits on
 685     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 686     // caller may provide val that is too big, e.g., a word with all bits
 687     // set to one, so we mask val
 688     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 689 }
 690 
 691 static inline void putbits36_15 (word36 * x, uint p, word15 val)
     /*  */
 692 {
 693     const int n = 15;
 694     int shift = 36 - (int) p - (int) n;
 695     if (shift < 0 || shift > 35) {
 696         sim_printf ("putbits36_15: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 697         return;
 698     }
 699     word36 mask = ~ (~0U<<n);  // n low bits on
 700     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 701     // caller may provide val that is too big, e.g., a word with all bits
 702     // set to one, so we mask val
 703     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 704 }
 705 
 706 static inline void putbits36_16 (word36 * x, uint p, word16 val)
     /*  */
 707 {
 708     const int n = 16;
 709     int shift = 36 - (int) p - (int) n;
 710     if (shift < 0 || shift > 35) {
 711         sim_printf ("putbits36_16: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 712         return;
 713     }
 714     word36 mask = ~ (~0U<<n);  // n low bits on
 715     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 716     // caller may provide val that is too big, e.g., a word with all bits
 717     // set to one, so we mask val
 718     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 719 }
 720 
 721 static inline void putbits36_17 (word36 * x, uint p, word17 val)
     /*  */
 722 {
 723     const int n = 17;
 724     int shift = 36 - (int) p - (int) n;
 725     if (shift < 0 || shift > 35) {
 726         sim_printf ("putbits36_17: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 727         return;
 728     }
 729     word36 mask = ~ (~0U<<n);  // n low bits on
 730     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 731     // caller may provide val that is too big, e.g., a word with all bits
 732     // set to one, so we mask val
 733     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 734 }
 735 
 736 static inline void putbits36_18 (word36 * x, uint p, word18 val)
     /*  */
 737 {
 738     const int n = 18;
 739     int shift = 36 - (int) p - (int) n;
 740     if (shift < 0 || shift > 35) {
 741         sim_printf ("putbits36_18: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 742         return;
 743     }
 744     word36 mask = ~ (~0U<<n);  // n low bits on
 745     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 746     // caller may provide val that is too big, e.g., a word with all bits
 747     // set to one, so we mask val
 748     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 749 }
 750 
 751 static inline void putbits36_23 (word36 * x, uint p, word23 val)
     /*  */
 752 {
 753     const int n = 23;
 754     int shift = 36 - (int) p - (int) n;
 755     if (shift < 0 || shift > 35) {
 756         sim_printf ("putbits36_23: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 757         return;
 758     }
 759     word36 mask = ~ (~0U<<n);  // n low bits on
 760     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 761     // caller may provide val that is too big, e.g., a word with all bits
 762     // set to one, so we mask val
 763     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 764 }
 765 
 766 static inline void putbits36_24 (word36 * x, uint p, word24 val)
     /*  */
 767 {
 768     const int n = 24;
 769     int shift = 36 - (int) p - (int) n;
 770     if (shift < 0 || shift > 35) {
 771         sim_printf ("putbits36_24: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 772         return;
 773     }
 774     word36 mask = ~ (~0U<<n);  // n low bits on
 775     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 776     // caller may provide val that is too big, e.g., a word with all bits
 777     // set to one, so we mask val
 778     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 779 }
 780 
 781 static inline void putbits36_28 (word36 * x, uint p, word28 val)
     /*  */
 782 {
 783     const int n = 28;
 784     int shift = 36 - (int) p - (int) n;
 785     if (shift < 0 || shift > 35) {
 786         sim_printf ("putbits36_28: bad args (%012llu,pos=%d)\r\n", (unsigned long long)*x, p);
 787         return;
 788     }
 789     word36 mask = ~ (~0U<<n);  // n low bits on
 790     word36 smask = mask << (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 791     // caller may provide val that is too big, e.g., a word with all bits
 792     // set to one, so we mask val
 793     * x = (* x & ~ smask) | (((word36) val & mask) << shift);
 794 }
 795 
 796 static inline void putbits72 (word72 * x, uint p, uint n, word72 val)
     /*  */
 797   {
 798     int shift = 72 - (int) p - (int) n;
 799     if (shift < 0 || shift > 71)
 800       {
 801         sim_printf ("putbits72: bad args (pos=%d,n=%d)\r\n", p, n);
 802         return;
 803       }
 804 #if defined(NEED_128)
 805 // n low bits on
 806     uint64_t lowmask = 0;
 807     uint64_t highmask = 0;
 808     if (n >= 64)
 809       {
 810         lowmask = MASK64;
 811         highmask = ~ ((~(uint64_t)0) << n);
 812         highmask &= 0377U;
 813       }
 814     else
 815       {
 816         lowmask = ~ ((~(uint64_t)0) << n);
 817       }
 818     word72 mask = construct_128 (highmask, lowmask);
 819     mask = lshift_128 (mask, (uint) shift);
 820     word72 notmask = complement_128 (mask);
 821     * x = or_128 (and_128 (* x, notmask), and_128 (lshift_128 (val, 72 - p - n), mask));
 822 #else
 823     word72 mask = ~ ((~(word72)0) << n);  // n low bits on
 824     mask <<= (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 825     // caller may provide val that is too big, e.g., a word with all bits
 826     // set to one, so we mask val
 827     * x = (* x & ~mask) | ((val & MASKBITS72 (n)) << (72 - p - n));
 828 #endif
 829     return;
 830   }
 831 
 832 //  getbits18 (data, starting bit, number of bits)
 833 
 834 static inline word18 getbits18 (word18 x, uint i, uint n)
     /*  */
 835   {
 836     // bit 17 is right end, bit zero is 18th from the right
 837     int shift = 17 - (int) i - (int) n + 1;
 838     if (shift < 0 || shift > 17)
 839       {
 840         sim_printf ("getbits18: bad args (%06o,i=%d,n=%d)\r\n", x, i, n);
 841         return 0;
 842       }
 843     else
 844       return (x >> (unsigned) shift) & ~ (~0U << n);
 845   }
 846 
 847 //  putbits18 (data, starting bit, number of bits, bits)
 848 
 849 static inline void putbits18 (word18 * x, uint p, uint n, word18 val)
     /*  */
 850   {
 851     int shift = 18 - (int) p - (int) n;
 852     if (shift < 0 || shift > 17)
 853       {
 854         sim_printf ("putbits18: bad args (%06o,pos=%d,n=%d)\r\n", * x, p, n);
 855         return;
 856       }
 857     word18 mask = ~ (~0U << n);  // n low bits on
 858     mask <<= (unsigned) shift;  // shift 1s to proper position; result 0*1{n}0*
 859     // caller may provide val that is too big, e.g., a word with all bits
 860     // set to one, so we mask val
 861     * x = (* x & ~mask) | ((val & MASKBITS18 (n)) << (18 - p - n));
 862     return;
 863   }
 864 
 865 //
 866 // setmask -- set bits from mask
 867 //
 868 
 869 static inline void setmask (word36 * v, word36 mask)
     /*  */
 870   {
 871     * v |= mask;
 872   }
 873 
 874 //
 875 // clrmask -- clear bits from mask
 876 //
 877 
 878 static inline void clrmask (word36 * v, word36 mask)
     /*  */
 879   {
 880     * v &= ~mask;
 881   }
 882 
 883 int x_mkdir_p (const char * path);
 884 char * strdupesc (const char * str);
 885 word36 extr36 (uint8 * bits, uint woffset);
 886 void put36 (word36 val, uint8 * bits, uint woffset);
 887 int extractASCII36FromBuffer (uint8 * bufp, t_mtrlnt tbc, uint * words_processed, word36 *wordp);
 888 int extractWord36FromBuffer (uint8 * bufp, t_mtrlnt tbc, uint * words_processed, word36 *wordp);
 889 int insertASCII36toBuffer (uint8 * bufp, t_mtrlnt tbc, uint * words_processed, word36 word);
 890 int insertWord36toBuffer (uint8 * bufp, t_mtrlnt tbc, uint * words_processed, word36 word);
 891 void print_int128 (int128 n, char * p);
 892 char * print_int128o (int128 n, char * p);
 893 word36 Add36b (cpu_state_t * cpup, word36 op1, word36 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 894 word36 Sub36b (cpu_state_t * cpup, word36 op1, word36 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 895 word18 Add18b (cpu_state_t * cpup, word18 op1, word18 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 896 word18 Sub18b (cpu_state_t * cpup, word18 op1, word18 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 897 word72 Add72b (cpu_state_t * cpup, word72 op1, word72 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 898 word72 Sub72b (cpu_state_t * cpup, word72 op1, word72 op2, word1 carryin, word18 flagsToSet, word18 * flags, bool * ovf);
 899 
 900 void timespec_diff(struct timespec *start, struct timespec *stop,
 901                    struct timespec *result);
 902 
 903 #if defined(THREADZ) || defined(LOCKLESS)
 904 void currentTR (word27 * trunits, bool * ovf);
 905 #endif

/* */