_ Git - BearSSL/blob - src/codec/pemdec.c

   1 /* Automatically generated code; do not modify directly. */
   2
   3 #include <stddef.h>
   4 #include <stdint.h>
   5
   6 typedef struct {
   7         uint32_t *dp;
   8         uint32_t *rp;
   9         const unsigned char *ip;
  10 } t0_context;
  11
  12 static uint32_t
  13 t0_parse7E_unsigned(const unsigned char **p)
  14 {
  15         uint32_t x;
  16
  17         x = 0;
  18         for (;;) {
  19                 unsigned y;
  20
  21                 y = *(*p) ++;
  22                 x = (x << 7) | (uint32_t)(y & 0x7F);
  23                 if (y < 0x80) {
  24                         return x;
  25                 }
  26         }
  27 }
  28
  29 static int32_t
  30 t0_parse7E_signed(const unsigned char **p)
  31 {
  32         int neg;
  33         uint32_t x;
  34
  35         neg = ((**p) >> 6) & 1;
  36         x = (uint32_t)-neg;
  37         for (;;) {
  38                 unsigned y;
  39
  40                 y = *(*p) ++;
  41                 x = (x << 7) | (uint32_t)(y & 0x7F);
  42                 if (y < 0x80) {
  43                         if (neg) {
  44                                 return -(int32_t)~x - 1;
  45                         } else {
  46                                 return (int32_t)x;
  47                         }
  48                 }
  49         }
  50 }
  51
  52 #define T0_VBYTE(x, n)   (unsigned char)((((uint32_t)(x) >> (n)) & 0x7F) | 0x80)
  53 #define T0_FBYTE(x, n)   (unsigned char)(((uint32_t)(x) >> (n)) & 0x7F)
  54 #define T0_SBYTE(x)      (unsigned char)((((uint32_t)(x) >> 28) + 0xF8) ^ 0xF8)
  55 #define T0_INT1(x)       T0_FBYTE(x, 0)
  56 #define T0_INT2(x)       T0_VBYTE(x, 7), T0_FBYTE(x, 0)
  57 #define T0_INT3(x)       T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
  58 #define T0_INT4(x)       T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
  59 #define T0_INT5(x)       T0_SBYTE(x), T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
  60
  61 static const uint8_t t0_datablock[];
  62
  63
  64 void br_pem_decoder_init_main(void *t0ctx);
  65
  66 void br_pem_decoder_run(void *t0ctx);
  67
  68
  69
  70 #include "inner.h"
  71
  72 #define CTX   ((br_pem_decoder_context *)((unsigned char *)t0ctx - offsetof(br_pem_decoder_context, cpu)))
  73
  74 /* see bearssl_pem.h */
  75 void
  76 br_pem_decoder_init(br_pem_decoder_context *ctx)
  77 {
  78         memset(ctx, 0, sizeof *ctx);
  79         ctx->cpu.dp = &ctx->dp_stack[0];
  80         ctx->cpu.rp = &ctx->rp_stack[0];
  81         br_pem_decoder_init_main(&ctx->cpu);
  82         br_pem_decoder_run(&ctx->cpu);
  83 }
  84
  85 /* see bearssl_pem.h */
  86 size_t
  87 br_pem_decoder_push(br_pem_decoder_context *ctx,
  88         const void *data, size_t len)
  89 {
  90         if (ctx->event) {
  91                 return 0;
  92         }
  93         ctx->hbuf = data;
  94         ctx->hlen = len;
  95         br_pem_decoder_run(&ctx->cpu);
  96         return len - ctx->hlen;
  97 }
  98
  99 /* see bearssl_pem.h */
 100 int
 101 br_pem_decoder_event(br_pem_decoder_context *ctx)
 102 {
 103         int event;
 104
 105         event = ctx->event;
 106         ctx->event = 0;
 107         return event;
 108 }
 109
 110
 111
 112 static const uint8_t t0_datablock[] = {
 113         0x00, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x42, 0x45, 0x47, 0x49, 0x4E, 0x20,
 114         0x00, 0x2D, 0x2D, 0x2D, 0x2D, 0x45, 0x4E, 0x44, 0x20, 0x00
 115 };
 116
 117 static const uint8_t t0_codeblock[] = {
 118         0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x01, 0x01, 0x07, 0x00, 0x00, 0x01,
 119         0x01, 0x08, 0x00, 0x00, 0x13, 0x13, 0x00, 0x00, 0x01,
 120         T0_INT2(offsetof(br_pem_decoder_context, event)), 0x00, 0x00, 0x01,
 121         T0_INT2(offsetof(br_pem_decoder_context, name)), 0x00, 0x00, 0x05,
 122         0x14, 0x2C, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x03, 0x13, 0x04, 0x76, 0x01,
 123         0x2D, 0x0C, 0x06, 0x05, 0x2E, 0x01, 0x03, 0x2D, 0x00, 0x01, 0x0D, 0x27,
 124         0x05, 0x04, 0x01, 0x03, 0x2D, 0x00, 0x15, 0x2E, 0x01, 0x02, 0x2D, 0x00,
 125         0x01, 0x01, 0x7F, 0x03, 0x00, 0x24, 0x01, 0x00, 0x17, 0x0D, 0x06, 0x03,
 126         0x13, 0x04, 0x3C, 0x01, 0x7F, 0x17, 0x0D, 0x06, 0x13, 0x13, 0x02, 0x00,
 127         0x05, 0x06, 0x2E, 0x01, 0x03, 0x2D, 0x04, 0x03, 0x01, 0x7F, 0x22, 0x01,
 128         0x00, 0x00, 0x04, 0x23, 0x01, 0x01, 0x17, 0x0D, 0x06, 0x09, 0x13, 0x01,
 129         0x00, 0x22, 0x01, 0x00, 0x00, 0x04, 0x14, 0x01, 0x02, 0x17, 0x0D, 0x06,
 130         0x06, 0x13, 0x01, 0x7F, 0x00, 0x04, 0x08, 0x13, 0x01, 0x03, 0x2D, 0x01,
 131         0x00, 0x00, 0x13, 0x01, 0x00, 0x03, 0x00, 0x04, 0xFF, 0x33, 0x01, 0x2C,
 132         0x14, 0x01, 0x2D, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x7F, 0x00, 0x14, 0x31,
 133         0x06, 0x02, 0x13, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01,
 134         0x02, 0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00,
 135         0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x03,
 136         0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00, 0x02,
 137         0x00, 0x01, 0x06, 0x0A, 0x07, 0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D,
 138         0x06, 0x04, 0x13, 0x01, 0x03, 0x00, 0x14, 0x01, 0x3D, 0x0D, 0x06, 0x2E,
 139         0x13, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x03, 0x00,
 140         0x2F, 0x05, 0x04, 0x13, 0x01, 0x03, 0x00, 0x01, 0x3D, 0x0C, 0x06, 0x03,
 141         0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x0F, 0x10, 0x06, 0x03, 0x01, 0x03,
 142         0x00, 0x02, 0x00, 0x01, 0x04, 0x0F, 0x1B, 0x01, 0x01, 0x00, 0x25, 0x14,
 143         0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x06,
 144         0x0A, 0x07, 0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13,
 145         0x01, 0x03, 0x00, 0x14, 0x01, 0x3D, 0x0D, 0x06, 0x20, 0x13, 0x2F, 0x05,
 146         0x03, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x03, 0x10, 0x06, 0x03, 0x01,
 147         0x03, 0x00, 0x02, 0x00, 0x01, 0x0A, 0x0F, 0x1B, 0x02, 0x00, 0x01, 0x02,
 148         0x0F, 0x1B, 0x01, 0x01, 0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E,
 149         0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x06, 0x0A, 0x07, 0x03, 0x00, 0x02,
 150         0x00, 0x01, 0x10, 0x0F, 0x1B, 0x02, 0x00, 0x01, 0x08, 0x0F, 0x1B, 0x02,
 151         0x00, 0x1B, 0x01, 0x00, 0x00, 0x00, 0x14, 0x14, 0x01, 0x80, 0x41, 0x0E,
 152         0x1A, 0x01, 0x80, 0x5A, 0x0B, 0x10, 0x06, 0x05, 0x01, 0x80, 0x41, 0x08,
 153         0x00, 0x14, 0x14, 0x01, 0x80, 0x61, 0x0E, 0x1A, 0x01, 0x80, 0x7A, 0x0B,
 154         0x10, 0x06, 0x05, 0x01, 0x80, 0x47, 0x08, 0x00, 0x14, 0x14, 0x01, 0x30,
 155         0x0E, 0x1A, 0x01, 0x39, 0x0B, 0x10, 0x06, 0x04, 0x01, 0x04, 0x07, 0x00,
 156         0x14, 0x01, 0x2B, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x3E, 0x00, 0x14, 0x01,
 157         0x2F, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x3F, 0x00, 0x01, 0x3D, 0x0C, 0x1E,
 158         0x00, 0x00, 0x28, 0x01, 0x01, 0x2D, 0x23, 0x06, 0x02, 0x04, 0x7B, 0x04,
 159         0x75, 0x00, 0x14, 0x12, 0x2A, 0x14, 0x05, 0x04, 0x1F, 0x01, 0x7F, 0x00,
 160         0x2C, 0x2A, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x05, 0x13, 0x1F, 0x01, 0x00,
 161         0x00, 0x0D, 0x05, 0x05, 0x13, 0x2E, 0x01, 0x00, 0x00, 0x1D, 0x04, 0x5E,
 162         0x00, 0x01, 0x01, 0x27, 0x06, 0x0B, 0x21, 0x01, 0x80, 0x7F, 0x2B, 0x14,
 163         0x06, 0x02, 0x30, 0x00, 0x13, 0x04, 0x6E, 0x00, 0x2C, 0x14, 0x31, 0x05,
 164         0x01, 0x00, 0x13, 0x04, 0x77, 0x00, 0x14, 0x14, 0x01, 0x80, 0x61, 0x0E,
 165         0x1A, 0x01, 0x80, 0x7A, 0x0B, 0x10, 0x06, 0x03, 0x01, 0x20, 0x08, 0x00,
 166         0x01, 0x14, 0x03, 0x00, 0x1A, 0x17, 0x05, 0x05, 0x1F, 0x2E, 0x01, 0x00,
 167         0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x06, 0x1F, 0x02, 0x00, 0x1A,
 168         0x08, 0x00, 0x2A, 0x17, 0x19, 0x1D, 0x1A, 0x1E, 0x1A, 0x04, 0x62, 0x00,
 169         0x18, 0x14, 0x1C, 0x05, 0x01, 0x00, 0x13, 0x11, 0x04, 0x76, 0x00, 0x20,
 170         0x19, 0x11, 0x00, 0x00, 0x2C, 0x01, 0x0A, 0x0C, 0x06, 0x02, 0x04, 0x78,
 171         0x00, 0x01, 0x01, 0x7F, 0x03, 0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0C, 0x06,
 172         0x09, 0x31, 0x05, 0x04, 0x01, 0x00, 0x03, 0x00, 0x04, 0x70, 0x13, 0x02,
 173         0x00, 0x00, 0x00, 0x14, 0x06, 0x14, 0x1E, 0x14, 0x21, 0x07, 0x16, 0x01,
 174         0x2D, 0x0C, 0x06, 0x08, 0x21, 0x07, 0x1D, 0x01, 0x00, 0x1A, 0x19, 0x00,
 175         0x04, 0x69, 0x21, 0x19, 0x00, 0x00, 0x14, 0x01, 0x0A, 0x0C, 0x1A, 0x01,
 176         0x20, 0x0B, 0x10, 0x00
 177 };
 178
 179 static const uint16_t t0_caddr[] = {
 180         0,
 181         5,
 182         10,
 183         15,
 184         19,
 185         24,
 186         29,
 187         67,
 188         149,
 189         384,
 190         464,
 191         476,
 192         511,
 193         530,
 194         540,
 195         559,
 196         594,
 197         605,
 198         610,
 199         620,
 200         645,
 201         672
 202 };
 203
 204 #define T0_INTERPRETED   28
 205
 206 #define T0_ENTER(ip, rp, slot)   do { \
 207                 const unsigned char *t0_newip; \
 208                 uint32_t t0_lnum; \
 209                 t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
 210                 t0_lnum = t0_parse7E_unsigned(&t0_newip); \
 211                 (rp) += t0_lnum; \
 212                 *((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
 213                 (ip) = t0_newip; \
 214         } while (0)
 215
 216 #define T0_DEFENTRY(name, slot) \
 217 void \
 218 name(void *ctx) \
 219 { \
 220         t0_context *t0ctx = ctx; \
 221         t0ctx->ip = &t0_codeblock[0]; \
 222         T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
 223 }
 224
 225 T0_DEFENTRY(br_pem_decoder_init_main, 38)
 226
 227 void
 228 br_pem_decoder_run(void *t0ctx)
 229 {
 230         uint32_t *dp, *rp;
 231         const unsigned char *ip;
 232
 233 #define T0_LOCAL(x)    (*(rp - 2 - (x)))
 234 #define T0_POP()       (*-- dp)
 235 #define T0_POPi()      (*(int32_t *)(-- dp))
 236 #define T0_PEEK(x)     (*(dp - 1 - (x)))
 237 #define T0_PEEKi(x)    (*(int32_t *)(dp - 1 - (x)))
 238 #define T0_PUSH(v)     do { *dp = (v); dp ++; } while (0)
 239 #define T0_PUSHi(v)    do { *(int32_t *)dp = (v); dp ++; } while (0)
 240 #define T0_RPOP()      (*-- rp)
 241 #define T0_RPOPi()     (*(int32_t *)(-- rp))
 242 #define T0_RPUSH(v)    do { *rp = (v); rp ++; } while (0)
 243 #define T0_RPUSHi(v)   do { *(int32_t *)rp = (v); rp ++; } while (0)
 244 #define T0_ROLL(x)     do { \
 245         size_t t0len = (size_t)(x); \
 246         uint32_t t0tmp = *(dp - 1 - t0len); \
 247         memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
 248         *(dp - 1) = t0tmp; \
 249 } while (0)
 250 #define T0_SWAP()      do { \
 251         uint32_t t0tmp = *(dp - 2); \
 252         *(dp - 2) = *(dp - 1); \
 253         *(dp - 1) = t0tmp; \
 254 } while (0)
 255 #define T0_ROT()       do { \
 256         uint32_t t0tmp = *(dp - 3); \
 257         *(dp - 3) = *(dp - 2); \
 258         *(dp - 2) = *(dp - 1); \
 259         *(dp - 1) = t0tmp; \
 260 } while (0)
 261 #define T0_NROT()       do { \
 262         uint32_t t0tmp = *(dp - 1); \
 263         *(dp - 1) = *(dp - 2); \
 264         *(dp - 2) = *(dp - 3); \
 265         *(dp - 3) = t0tmp; \
 266 } while (0)
 267 #define T0_PICK(x)      do { \
 268         uint32_t t0depth = (x); \
 269         T0_PUSH(T0_PEEK(t0depth)); \
 270 } while (0)
 271 #define T0_CO()         do { \
 272         goto t0_exit; \
 273 } while (0)
 274 #define T0_RET()        break
 275
 276         dp = ((t0_context *)t0ctx)->dp;
 277         rp = ((t0_context *)t0ctx)->rp;
 278         ip = ((t0_context *)t0ctx)->ip;
 279         for (;;) {
 280                 uint32_t t0x;
 281
 282                 t0x = t0_parse7E_unsigned(&ip);
 283                 if (t0x < T0_INTERPRETED) {
 284                         switch (t0x) {
 285                                 int32_t t0off;
 286
 287                         case 0: /* ret */
 288                                 t0x = T0_RPOP();
 289                                 rp -= (t0x >> 16);
 290                                 t0x &= 0xFFFF;
 291                                 if (t0x == 0) {
 292                                         ip = NULL;
 293                                         goto t0_exit;
 294                                 }
 295                                 ip = &t0_codeblock[t0x];
 296                                 break;
 297                         case 1: /* literal constant */
 298                                 T0_PUSHi(t0_parse7E_signed(&ip));
 299                                 break;
 300                         case 2: /* read local */
 301                                 T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
 302                                 break;
 303                         case 3: /* write local */
 304                                 T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
 305                                 break;
 306                         case 4: /* jump */
 307                                 t0off = t0_parse7E_signed(&ip);
 308                                 ip += t0off;
 309                                 break;
 310                         case 5: /* jump if */
 311                                 t0off = t0_parse7E_signed(&ip);
 312                                 if (T0_POP()) {
 313                                         ip += t0off;
 314                                 }
 315                                 break;
 316                         case 6: /* jump if not */
 317                                 t0off = t0_parse7E_signed(&ip);
 318                                 if (!T0_POP()) {
 319                                         ip += t0off;
 320                                 }
 321                                 break;
 322                         case 7: {
 323                                 /* + */
 324
 325         uint32_t b = T0_POP();
 326         uint32_t a = T0_POP();
 327         T0_PUSH(a + b);
 328
 329                                 }
 330                                 break;
 331                         case 8: {
 332                                 /* - */
 333
 334         uint32_t b = T0_POP();
 335         uint32_t a = T0_POP();
 336         T0_PUSH(a - b);
 337
 338                                 }
 339                                 break;
 340                         case 9: {
 341                                 /* < */
 342
 343         int32_t b = T0_POPi();
 344         int32_t a = T0_POPi();
 345         T0_PUSH(-(uint32_t)(a < b));
 346
 347                                 }
 348                                 break;
 349                         case 10: {
 350                                 /* << */
 351
 352         int c = (int)T0_POPi();
 353         uint32_t x = T0_POP();
 354         T0_PUSH(x << c);
 355
 356                                 }
 357                                 break;
 358                         case 11: {
 359                                 /* <= */
 360
 361         int32_t b = T0_POPi();
 362         int32_t a = T0_POPi();
 363         T0_PUSH(-(uint32_t)(a <= b));
 364
 365                                 }
 366                                 break;
 367                         case 12: {
 368                                 /* <> */
 369
 370         uint32_t b = T0_POP();
 371         uint32_t a = T0_POP();
 372         T0_PUSH(-(uint32_t)(a != b));
 373
 374                                 }
 375                                 break;
 376                         case 13: {
 377                                 /* = */
 378
 379         uint32_t b = T0_POP();
 380         uint32_t a = T0_POP();
 381         T0_PUSH(-(uint32_t)(a == b));
 382
 383                                 }
 384                                 break;
 385                         case 14: {
 386                                 /* >= */
 387
 388         int32_t b = T0_POPi();
 389         int32_t a = T0_POPi();
 390         T0_PUSH(-(uint32_t)(a >= b));
 391
 392                                 }
 393                                 break;
 394                         case 15: {
 395                                 /* >> */
 396
 397         int c = (int)T0_POPi();
 398         int32_t x = T0_POPi();
 399         T0_PUSHi(x >> c);
 400
 401                                 }
 402                                 break;
 403                         case 16: {
 404                                 /* and */
 405
 406         uint32_t b = T0_POP();
 407         uint32_t a = T0_POP();
 408         T0_PUSH(a & b);
 409
 410                                 }
 411                                 break;
 412                         case 17: {
 413                                 /* co */
 414  T0_CO();
 415                                 }
 416                                 break;
 417                         case 18: {
 418                                 /* data-get8 */
 419
 420         size_t addr = T0_POP();
 421         T0_PUSH(t0_datablock[addr]);
 422
 423                                 }
 424                                 break;
 425                         case 19: {
 426                                 /* drop */
 427  (void)T0_POP();
 428                                 }
 429                                 break;
 430                         case 20: {
 431                                 /* dup */
 432  T0_PUSH(T0_PEEK(0));
 433                                 }
 434                                 break;
 435                         case 21: {
 436                                 /* flush-buf */
 437
 438         if (CTX->ptr > 0) {
 439                 CTX->dest(CTX->dest_ctx, CTX->buf, CTX->ptr);
 440                 CTX->ptr = 0;
 441         }
 442
 443                                 }
 444                                 break;
 445                         case 22: {
 446                                 /* get8 */
 447
 448         size_t addr = T0_POP();
 449         T0_PUSH(*((unsigned char *)CTX + addr));
 450
 451                                 }
 452                                 break;
 453                         case 23: {
 454                                 /* over */
 455  T0_PUSH(T0_PEEK(1));
 456                                 }
 457                                 break;
 458                         case 24: {
 459                                 /* read8-native */
 460
 461         if (CTX->hlen > 0) {
 462                 T0_PUSH(*CTX->hbuf ++);
 463                 CTX->hlen --;
 464         } else {
 465                 T0_PUSHi(-1);
 466         }
 467
 468                                 }
 469                                 break;
 470                         case 25: {
 471                                 /* set8 */
 472
 473         size_t addr = T0_POP();
 474         unsigned x = T0_POP();
 475         *((unsigned char *)CTX + addr) = x;
 476
 477                                 }
 478                                 break;
 479                         case 26: {
 480                                 /* swap */
 481  T0_SWAP();
 482                                 }
 483                                 break;
 484                         case 27: {
 485                                 /* write8 */
 486
 487         unsigned char x = (unsigned char)T0_POP();
 488         CTX->buf[CTX->ptr ++] = x;
 489         if (CTX->ptr == sizeof CTX->buf) {
 490                 if (CTX->dest) {
 491                         CTX->dest(CTX->dest_ctx, CTX->buf, sizeof CTX->buf);
 492                 }
 493                 CTX->ptr = 0;
 494         }
 495
 496                                 }
 497                                 break;
 498                         }
 499
 500                 } else {
 501                         T0_ENTER(ip, rp, t0x);
 502                 }
 503         }
 504 t0_exit:
 505         ((t0_context *)t0ctx)->dp = dp;
 506         ((t0_context *)t0ctx)->rp = rp;
 507         ((t0_context *)t0ctx)->ip = ip;
 508 }