← Back to branch summary

~ubuntu-branches/ubuntu/trusty/luajit/trusty

« back to all changes in this revision

Viewing changes to src/lj_parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Enrico Tassi
  • Date: 2011-05-09 23:14:21 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20110509231421-zdcnqbqk5h6iryxr
Tags: 2.0.0~beta7+dfsg-1
New upstream release with arm support

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lj_parse.c
73
73
#define expr_isnumk_nojump(e)   (expr_isnumk(e) && !expr_hasjump(e))
74
74
#define expr_isstrk(e)          ((e)->k == VKSTR)
75
75
 
76
 
#define expr_numV(e)            check_exp(expr_isnumk((e)), numV(&(e)->u.nval))
 
76
#define expr_numtv(e)           check_exp(expr_isnumk((e)), &(e)->u.nval)
 
77
#define expr_numberV(e)         numberVnum(expr_numtv((e)))
77
78
 
78
79
/* Initialize expression. */
79
80
static LJ_AINLINE void expr_init(ExpDesc *e, ExpKind k, uint32_t info)
83
84
  e->f = e->t = NO_JMP;
84
85
}
85
86
 
 
87
/* Check number constant for +-0. */
 
88
static int expr_numiszero(ExpDesc *e)
 
89
{
 
90
  TValue *o = expr_numtv(e);
 
91
  return tvisint(o) ? (intV(o) == 0) : tviszero(o);
 
92
}
 
93
 
86
94
/* Per-function linked list of scope blocks. */
87
95
typedef struct FuncScope {
88
96
  struct FuncScope *prev;       /* Link to outer scope. */
174
182
/* Return bytecode encoding for primitive constant. */
175
183
#define const_pri(e)            check_exp((e)->k <= VKTRUE, (e)->k)
176
184
 
 
185
#define tvhaskslot(o)   ((o)->u32.hi == 0)
 
186
#define tvkslot(o)      ((o)->u32.lo)
 
187
 
177
188
/* Add a number constant. */
178
189
static BCReg const_num(FuncState *fs, ExpDesc *e)
179
190
{
180
191
  lua_State *L = fs->L;
181
 
  TValue *val;
 
192
  TValue *o;
182
193
  lua_assert(expr_isnumk(e));
183
 
  val = lj_tab_set(L, fs->kt, &e->u.nval);
184
 
  if (tvisnum(val))
185
 
    return val->u32.lo;
186
 
  val->u64 = fs->nkn;
 
194
  o = lj_tab_set(L, fs->kt, &e->u.nval);
 
195
  if (tvhaskslot(o))
 
196
    return tvkslot(o);
 
197
  o->u64 = fs->nkn;
187
198
  return fs->nkn++;
188
199
}
189
200
 
191
202
static BCReg const_gc(FuncState *fs, GCobj *gc, uint32_t itype)
192
203
{
193
204
  lua_State *L = fs->L;
194
 
  TValue o, *val;
195
 
  setgcV(L, &o, gc, itype);
 
205
  TValue key, *o;
 
206
  setgcV(L, &key, gc, itype);
196
207
  /* NOBARRIER: the key is new or kept alive. */
197
 
  val = lj_tab_set(L, fs->kt, &o);
198
 
  if (tvisnum(val))
199
 
    return val->u32.lo;
200
 
  val->u64 = fs->nkgc;
 
208
  o = lj_tab_set(L, fs->kt, &key);
 
209
  if (tvhaskslot(o))
 
210
    return tvkslot(o);
 
211
  o->u64 = fs->nkgc;
201
212
  return fs->nkgc++;
202
213
}
203
214
 
247
258
static int jmp_novalue(FuncState *fs, BCPos list)
248
259
{
249
260
  for (; list != NO_JMP; list = jmp_next(fs, list)) {
250
 
    BCOp op = bc_op(fs->bcbase[list >= 1 ? list-1 : list].ins);
251
 
    if (!(op == BC_ISTC || op == BC_ISFC)) return 1;
 
261
    BCIns p = fs->bcbase[list >= 1 ? list-1 : list].ins;
 
262
    if (!(bc_op(p) == BC_ISTC || bc_op(p) == BC_ISFC || bc_a(p) == NO_REG))
 
263
      return 1;
252
264
  }
253
265
  return 0;
254
266
}
258
270
{
259
271
  BCIns *ip = &fs->bcbase[pc >= 1 ? pc-1 : pc].ins;
260
272
  BCOp op = bc_op(*ip);
261
 
  if (!(op == BC_ISTC || op == BC_ISFC))
 
273
  if (op == BC_ISTC || op == BC_ISFC) {
 
274
    if (reg != NO_REG && reg != bc_d(*ip)) {
 
275
      setbc_a(ip, reg);
 
276
    } else {  /* Nothing to store or already in the right register. */
 
277
      setbc_op(ip, op+(BC_IST-BC_ISTC));
 
278
      setbc_a(ip, 0);
 
279
    }
 
280
  } else if (bc_a(*ip) == NO_REG) {
 
281
    if (reg == NO_REG)
 
282
      *ip = BCINS_AJ(BC_JMP, bc_a(fs->bcbase[pc].ins), 0);
 
283
    else
 
284
      setbc_a(ip, reg);
 
285
  } else {
262
286
    return 0;  /* Cannot patch other instructions. */
263
 
  if (reg != NO_REG && reg != bc_d(*ip)) {
264
 
    setbc_a(ip, reg);
265
 
  } else {  /* Nothing to store or already in the right register. */
266
 
    setbc_op(ip, op+(BC_IST-BC_ISTC));
267
 
    setbc_a(ip, 0);
268
287
  }
269
288
  return 1;
270
289
}
344
363
  if (sz > fs->framesize) {
345
364
    if (sz >= LJ_MAX_SLOTS)
346
365
      err_syntax(fs->ls, LJ_ERR_XSLOTS);
347
 
    fs->framesize = cast_byte(sz);
 
366
    fs->framesize = (uint8_t)sz;
348
367
  }
349
368
}
350
369
 
478
497
  if (e->k == VKSTR) {
479
498
    ins = BCINS_AD(BC_KSTR, reg, const_str(fs, e));
480
499
  } else if (e->k == VKNUM) {
481
 
    lua_Number n = expr_numV(e);
 
500
#if LJ_DUALNUM
 
501
    cTValue *tv = expr_numtv(e);
 
502
    if (tvisint(tv) && checki16(intV(tv)))
 
503
      ins = BCINS_AD(BC_KSHORT, reg, (BCReg)(uint16_t)intV(tv));
 
504
    else
 
505
#else
 
506
    lua_Number n = expr_numberV(e);
482
507
    int32_t k = lj_num2int(n);
483
 
    if (checki16(k) && n == cast_num(k))
 
508
    if (checki16(k) && n == (lua_Number)k)
484
509
      ins = BCINS_AD(BC_KSHORT, reg, (BCReg)(uint16_t)k);
485
510
    else
 
511
#endif
486
512
      ins = BCINS_AD(BC_KNUM, reg, const_num(fs, e));
487
513
#if LJ_HASFFI
488
514
  } else if (e->k == VKCDATA) {
691
717
    pc = NO_JMP;  /* Never jump. */
692
718
  else if (e->k == VJMP)
693
719
    invertcond(fs, e), pc = e->u.s.info;
 
720
  else if (e->k == VKFALSE || e->k == VKNIL)
 
721
    expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
694
722
  else
695
723
    pc = bcemit_branch(fs, e, 0);
696
724
  jmp_append(fs, &e->f, pc);
707
735
    pc = NO_JMP;  /* Never jump. */
708
736
  else if (e->k == VJMP)
709
737
    pc = e->u.s.info;
 
738
  else if (e->k == VKSTR || e->k == VKNUM || e->k == VKTRUE)
 
739
    expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
710
740
  else
711
741
    pc = bcemit_branch(fs, e, 1);
712
742
  jmp_append(fs, &e->t, pc);
720
750
static int foldarith(BinOpr opr, ExpDesc *e1, ExpDesc *e2)
721
751
{
722
752
  TValue o;
 
753
  lua_Number n;
723
754
  if (!expr_isnumk_nojump(e1) || !expr_isnumk_nojump(e2)) return 0;
724
 
  setnumV(&o, lj_vm_foldarith(expr_numV(e1), expr_numV(e2), (int)opr-OPR_ADD));
 
755
  n = lj_vm_foldarith(expr_numberV(e1), expr_numberV(e2), (int)opr-OPR_ADD);
 
756
  setnumV(&o, n);
725
757
  if (tvisnan(&o) || tvismzero(&o)) return 0;  /* Avoid NaN and -0 as consts. */
726
 
  setnumV(&e1->u.nval, numV(&o));
 
758
  if (LJ_DUALNUM) {
 
759
    int32_t k = lj_num2int(n);
 
760
    if ((lua_Number)k == n) {
 
761
      setintV(&e1->u.nval, k);
 
762
      return 1;
 
763
    }
 
764
  }
 
765
  setnumV(&e1->u.nval, n);
727
766
  return 1;
728
767
}
729
768
 
900
939
        return;
901
940
      } else
902
941
#endif
903
 
      if (expr_isnumk(e) && expr_numV(e) != 0) {  /* Avoid folding to -0. */
904
 
        e->u.nval.u64 ^= U64x(80000000,00000000);
905
 
        return;
 
942
      if (expr_isnumk(e) && !expr_numiszero(e)) {  /* Avoid folding to -0. */
 
943
        TValue *o = expr_numtv(e);
 
944
        if (tvisint(o)) {
 
945
          int32_t k = intV(o);
 
946
          if (k == -k)
 
947
            setnumV(o, -(lua_Number)k);
 
948
          else
 
949
            setintV(o, -k);
 
950
          return;
 
951
        } else {
 
952
          o->u64 ^= U64x(80000000,00000000);
 
953
          return;
 
954
        }
906
955
      }
907
956
    }
908
957
    expr_toanyreg(fs, e);
986
1035
static void var_add(LexState *ls, BCReg nvars)
987
1036
{
988
1037
  FuncState *fs = ls->fs;
989
 
  fs->nactvar = cast_byte(fs->nactvar + nvars);
 
1038
  fs->nactvar = (uint8_t)(fs->nactvar + nvars);
990
1039
  for (; nvars; nvars--)
991
1040
    var_get(ls, fs, fs->nactvar - nvars).startpc = fs->pc;
992
1041
}
1094
1143
  kt = fs->kt;
1095
1144
  array = tvref(kt->array);
1096
1145
  for (i = 0; i < kt->asize; i++)
1097
 
    if (tvisnum(&array[i]))
1098
 
      ((lua_Number *)kptr)[array[i].u32.lo] = cast_num(i);
 
1146
    if (tvhaskslot(&array[i])) {
 
1147
      TValue *tv = &((TValue *)kptr)[tvkslot(&array[i])];
 
1148
      if (LJ_DUALNUM)
 
1149
        setintV(tv, (int32_t)i);
 
1150
      else
 
1151
        setnumV(tv, (lua_Number)i);
 
1152
    }
1099
1153
  node = noderef(kt->node);
1100
1154
  hmask = kt->hmask;
1101
1155
  for (i = 0; i <= hmask; i++) {
1102
1156
    Node *n = &node[i];
1103
 
    if (tvisnum(&n->val)) {
1104
 
      ptrdiff_t kidx = (ptrdiff_t)n->val.u32.lo;
 
1157
    if (tvhaskslot(&n->val)) {
 
1158
      ptrdiff_t kidx = (ptrdiff_t)tvkslot(&n->val);
 
1159
      lua_assert(!tvisint(&n->key));
1105
1160
      if (tvisnum(&n->key)) {
1106
 
        ((lua_Number *)kptr)[kidx] = numV(&n->key);
 
1161
        TValue *tv = &((TValue *)kptr)[kidx];
 
1162
        if (LJ_DUALNUM) {
 
1163
          lua_Number nn = numV(&n->key);
 
1164
          int32_t k = lj_num2int(nn);
 
1165
          lua_assert(!tvismzero(&n->key));
 
1166
          if ((lua_Number)k == nn)
 
1167
            setintV(tv, k);
 
1168
          else
 
1169
            *tv = n->key;
 
1170
        } else {
 
1171
          *tv = n->key;
 
1172
        }
1107
1173
      } else {
1108
1174
        GCobj *o = gcV(&n->key);
1109
1175
        setgcref(((GCRef *)kptr)[~kidx], o);
1286
1352
  /* Already called: expr_toval(fs, e). */
1287
1353
  t->k = VINDEXED;
1288
1354
  if (expr_isnumk(e)) {
1289
 
    lua_Number n = expr_numV(e);
 
1355
#if LJ_DUALNUM
 
1356
    if (tvisint(expr_numtv(e))) {
 
1357
      int32_t k = intV(expr_numtv(e));
 
1358
      if (checku8(k)) {
 
1359
        t->u.s.aux = BCMAX_C+1+(uint32_t)k;  /* 256..511: const byte key */
 
1360
        return;
 
1361
      }
 
1362
    }
 
1363
#else
 
1364
    lua_Number n = expr_numberV(e);
1290
1365
    int32_t k = lj_num2int(n);
1291
 
    if (checku8(k) && n == cast_num(k)) {
 
1366
    if (checku8(k) && n == (lua_Number)k) {
1292
1367
      t->u.s.aux = BCMAX_C+1+(uint32_t)k;  /* 256..511: const byte key */
1293
1368
      return;
1294
1369
    }
 
1370
#endif
1295
1371
  } else if (expr_isstrk(e)) {
1296
1372
    BCReg idx = const_str(fs, e);
1297
1373
    if (idx <= BCMAX_C) {
1331
1407
    setgcref(v->gcr, obj2gco(e->u.sval));
1332
1408
    setitype(v, LJ_TSTR);
1333
1409
  } else {
1334
 
    lua_assert(e->k == VKNUM);
1335
 
    setnumV(v, expr_numV(e));
 
1410
    lua_assert(tvisnumber(expr_numtv(e)));
 
1411
    *v = *expr_numtv(e);
1336
1412
  }
1337
1413
}
1338
1414
 
1357
1433
    if (ls->token == '[') {
1358
1434
      expr_bracket(ls, &key);  /* Already calls expr_toval. */
1359
1435
      if (!expr_isk(&key)) expr_index(fs, e, &key);
1360
 
      if (expr_isnumk(&key) && expr_numV(&key) == 0) needarr = 1; else nhash++;
 
1436
      if (expr_isnumk(&key) && expr_numiszero(&key)) needarr = 1; else nhash++;
1361
1437
      lex_check(ls, '=');
1362
1438
    } else if (ls->token == TK_name && lj_lex_lookahead(ls) == '=') {
1363
1439
      expr_str(ls, &key);
2119
2195
  case BC_GGET:
2120
2196
    /* There's no inverse index (yet), so lookup the strings. */
2121
2197
    o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "pairs"));
2122
 
    if (o && tvisnum(o) && o->u32.lo == bc_d(ins))
 
2198
    if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2123
2199
      return 1;
2124
2200
    o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "next"));
2125
 
    if (o && tvisnum(o) && o->u32.lo == bc_d(ins))
 
2201
    if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2126
2202
      return 1;
2127
2203
    return 0;
2128
2204
  default:
2265
2341
    lj_lex_next(ls);
2266
2342
    parse_break(ls);
2267
2343
    return 1;  /* Must be last. */
 
2344
#ifdef LUAJIT_ENABLE_LUA52COMPAT
 
2345
  case ';':
 
2346
    lj_lex_next(ls);
 
2347
    break;
 
2348
#endif
2268
2349
  default:
2269
2350
    parse_call_assign(ls);
2270
2351
    break;