Class: MrbParser::CodeDump

Inherits:
Object
  • Object
show all
Defined in:
lib/mrb_parser/code_dump.rb

Constant Summary collapse

MAXARG_Bx = 
0xffff
MAXARG_sBx =

‘sBx’ is signed

(MAXARG_Bx>>1)
OP_NOP =

/* */

0
OP_MOVE =

/* A B R(A) := R(B) */

1
OP_LOADL =

/* A Bx R(A) := Lit(Bx) */

2
OP_LOADI =

/* A sBx R(A) := sBx */

3
OP_LOADSYM =

/* A Bx R(A) := Sym(Bx) */

4
OP_LOADNIL =

/* A R(A) := nil */

5
OP_LOADSELF =

/* A R(A) := self */

6
OP_LOADT =

/* A R(A) := true */

7
OP_LOADF =

/* A R(A) := false */

8
OP_GETGLOBAL =

/* A Bx R(A) := getglobal(Sym(Bx)) */

9
OP_SETGLOBAL =

/* A Bx setglobal(Sym(Bx), R(A)) */

10
OP_GETSPECIAL =

/* A Bx R(A) := Special */

11
OP_SETSPECIAL =

/* A Bx Special := R(A) */

12
OP_GETIV =

/* A Bx R(A) := ivget(Sym(Bx)) */

13
OP_SETIV =

/* A Bx ivset(Sym(Bx),R(A)) */

14
OP_GETCV =

/* A Bx R(A) := cvget(Sym(Bx)) */

15
OP_SETCV =

/* A Bx cvset(Sym(Bx),R(A)) */

16
OP_GETCONST =

/* A Bx R(A) := constget(Sym(Bx)) */

17
OP_SETCONST =

/* A Bx constset(Sym(Bx),R(A)) */

18
OP_GETMCNST =

/* A Bx R(A) := R(A)::Sym(B) */

19
OP_SETMCNST =

/* A Bx R(A+1)::Sym(B) := R(A) */

20
OP_GETUPVAR =

/* A B C R(A) := uvget(B,C) */

21
OP_SETUPVAR =

/* A B C uvset(B,C,R(A)) */

22
OP_JMP =

/* sBx pc+=sBx */

23
OP_JMPIF =

/* A sBx if R(A) pc+=sBx */

24
OP_JMPNOT =

/* A sBx if !R(A) pc+=sBx */

25
OP_ONERR =

/* sBx rescue_push(pc+sBx) */

26
OP_RESCUE =

/* A clear(exc); R(A) := exception (ignore when A=0) */

27
OP_POPERR =

/* A A.timesrescue_pop() */

28
OP_RAISE =

/* A raise(R(A)) */

29
OP_EPUSH =

/* Bx ensure_push(SEQ) */

30
OP_EPOP =

/* A A.timesMrbParser::CodeDump.ensure_pop()ensure_pop().call */

31
OP_SEND =

/* A B C R(A) := call(R(A),mSym(B),R(A+1),…,R(A+C)) */

32
OP_SENDB =

/* A B C R(A) := call(R(A),mSym(B),R(A+1),…,R(A+C),&R(A+C+1))*/

33
OP_FSEND =

/* A B C R(A) := fcall(R(A),mSym(B),R(A+1),…,R(A+C-1)) */

34
OP_CALL =

/* A B C R(A) := self.call(R(A),.., R(A+C)) */

35
OP_SUPER =

/* A B C R(A) := super(R(A+1),… ,R(A+C-1)) */

36
OP_ARGARY =

/* A Bx R(A) := argument array (16=6:1:5:4) */

37
OP_ENTER =

/* Ax arg setup according to flags (24=5:5:1:5:5:1:1) */

38
OP_KARG =

/* A B C R(A) := kdict; if C kdict.rm(mSym(B)) */

39
OP_KDICT =

/* A C R(A) := kdict */

40
OP_RETURN =

/* A B return R(A) (B=normal,in-block return/break) */

41
OP_TAILCALL =

/* A B C return call(R(A),mSym(B),*R©) */

42
OP_BLKPUSH =

/* A Bx R(A) := block (16=6:1:5:4) */

43
OP_ADD =

/* A B C R(A) := R(A)+R(A+1) (mSyms=:+,C=1) */

44
OP_ADDI =

/* A B C R(A) := R(A)+C (mSyms=:+) */

45
OP_SUB =

/* A B C R(A) := R(A)-R(A+1) (mSyms=:-,C=1) */

46
OP_SUBI =

/* A B C R(A) := R(A)-C (mSyms=:-) */

47
OP_MUL =

/* A B C R(A) := R(A)*R(A+1) (mSyms=:*,C=1) */

48
OP_DIV =

/* A B C R(A) := R(A)/R(A+1) (mSyms=:/,C=1) */

49
OP_EQ =

/* A B C R(A) := R(A)==R(A+1) (mSyms=:==,C=1) */

50
OP_LT =

/* A B C R(A) := R(A)<R(A+1) (mSyms=:<,C=1) */

51
OP_LE =

/* A B C R(A) := R(A)<=R(A+1) (mSyms=:<=,C=1) */

52
OP_GT =

/* A B C R(A) := R(A)>R(A+1) (mSyms=:>,C=1) */

53
OP_GE =

/* A B C R(A) := R(A)>=R(A+1) (mSyms=:>=,C=1) */

54
OP_ARRAY =

/* A B C R(A) := ary_new(R(B),R(B+1)..R(B+C)) */

55
OP_ARYCAT =

/* A B ary_cat(R(A),R(B)) */

56
OP_ARYPUSH =

/* A B ary_push(R(A),R(B)) */

57
OP_AREF =

/* A B C R(A) := R(B) */

58
OP_ASET =

/* A B C R(B) := R(A) */

59
OP_APOST =

/* A B C *R(A),R(A+1)..R(A+C) := R(A) */

60
OP_STRING =

/* A Bx R(A) := str_dup(Lit(Bx)) */

61
OP_STRCAT =

/* A B str_cat(R(A),R(B)) */

62
OP_HASH =

/* A B C R(A) := hash_new(R(B),R(B+1)..R(B+C)) */

63
OP_LAMBDA =

/* A Bz Cz R(A) := lambda(SEQ,Cm) */

64
OP_RANGE =

/* A B C R(A) := range_new(R(B),R(B+1),C) */

65
OP_OCLASS =

/* A R(A) := ::Object */

66
OP_CLASS =

/* A B R(A) := newclass(R(A),mSym(B),R(A+1)) */

67
OP_MODULE =

/* A B R(A) := newmodule(R(A),mSym(B)) */

68
OP_EXEC =

/* A Bx R(A) := blockexec(R(A),SEQ) */

69
OP_METHOD =

/* A B R(A).newmethod(mSym(B),R(A+1)) */

70
OP_SCLASS =

/* A B R(A) := R(B).singleton_class */

71
OP_TCLASS =

/* A R(A) := target_class */

72
OP_DEBUG =

/* A print R(A) */

73
OP_STOP =

/* stop VM */

74
OP_ERR =

/* Bx raise RuntimeError with message Lit(Bx) */

75
OP_RSVD1 =

/* reserved instruction #1 */

76
OP_RSVD2 =

/* reserved instruction #2 */

77
OP_RSVD3 =

/* reserved instruction #3 */

78
OP_RSVD4 =

/* reserved instruction #4 */

79
OP_RSVD5 =

/* reserved instruction #5 */

80
OP_R_NORMAL = 
0
OP_R_BREAK = 
1
OP_R_RETURN = 
2

Instance Method Summary collapse

Constructor Details

#initialize(irep) ⇒ CodeDump

instructions: packed 32 bit

A:B:C:OP = 9: 9: 7: 7
 A:Bx:OP =    9:16: 7
   Ax:OP =      25: 7

A:Bz:Cz:OP = 9:14: 2: 7



112
113
114
 
# File 'lib/mrb_parser/code_dump.rb', line 112

def initialize(irep)
  @irep = irep
end

Instance Method Details

#dump(c, i) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/mrb_parser/code_dump.rb', line 161

def dump(c, i)
  printf("%03d ", i)
  op = opcode(c)
  case op
  when OP_NOP
    printf("OP_NOP\n")
  when OP_MOVE
    printf("OP_MOVE\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
  when OP_LOADL
    printf("OP_LOADL\tR%d\tL(%d)\n", getarg_a(c), getarg_bx(c))
  when OP_LOADI
    printf("OP_LOADI\tR%d\t%d\n", getarg_a(c), getarg_sbx(c))
  when OP_LOADSYM
    printf("OP_LOADSYM\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_LOADNIL
    printf("OP_LOADNIL\tR%d\n", getarg_a(c))
  when OP_LOADSELF
    printf("OP_LOADSELF\tR%d\n", getarg_a(c))
  when OP_LOADT
    printf("OP_LOADT\tR%d\n", getarg_a(c))
  when OP_LOADF
    printf("OP_LOADF\tR%d\n", getarg_a(c))
  when OP_GETGLOBAL
    printf("OP_GETGLOBAL\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_SETGLOBAL
    printf("OP_SETGLOBAL\t:%s\tR%d\n",
           @irep.syms[getarg_bx(c)],
           getarg_a(c))
  when OP_GETCONST
    printf("OP_GETCONST\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_SETCONST
    printf("OP_SETCONST\t:%s\tR%d\n",
           @irep.syms[getarg_bx(c)],
           getarg_a(c))
  when OP_GETMCNST
    printf("OP_GETMCNST\tR%d\tR%d::%s\n", getarg_a(c), getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_SETMCNST
    printf("OP_SETMCNST\tR%d::%s\tR%d\n", getarg_a(c)+1,
           @irep.syms[getarg_bx(c)],
           getarg_a(c))
  when OP_GETIV
    printf("OP_GETIV\tR%d\t%s\n", getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_SETIV
    printf("OP_SETIV\t%s\tR%d\n",
           @irep.syms[getarg_bx(c)],
           getarg_a(c))
  when OP_GETUPVAR
    printf("OP_GETUPVAR\tR%d\t%d\t%d\n",
           getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_SETUPVAR
    printf("OP_SETUPVAR\tR%d\t%d\t%d\n",
           getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_GETCV
    printf("OP_GETCV\tR%d\t%s\n", getarg_a(c),
           @irep.syms[getarg_bx(c)])
  when OP_SETCV
    printf("OP_SETCV\t%s\tR%d\n",
           @irep.syms[getarg_bx(c)],
           getarg_a(c))
  when OP_JMP
    printf("OP_JMP\t\t%03d\n", i+getarg_sbx(c))
  when OP_JMPIF
    printf("OP_JMPIF\tR%d\t%03d\n", getarg_a(c), i+getarg_sbx(c))
  when OP_JMPNOT
    printf("OP_JMPNOT\tR%d\t%03d\n", getarg_a(c), i+getarg_sbx(c));
  when OP_SEND
    printf("OP_SEND\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_SENDB
    printf("OP_SENDB\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_TAILCALL
    printf("OP_TAILCALL\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_SUPER
    printf("OP_SUPER\tR%d\t%d\n", getarg_a(c),
           getarg_c(c))
  when OP_ARGARY
    printf("OP_ARGARY\tR%d\t%d:%d:%d:%d\n", getarg_a(c),
           (getarg_bx(c)>>10)&0x3f,
           (getarg_bx(c)>>9)&0x1,
           (getarg_bx(c)>>4)&0x1f,
           (getarg_bx(c)>>0)&0xf)

  when OP_ENTER
    printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
           (getarg_ax(c)>>18)&0x1f,
           (getarg_ax(c)>>13)&0x1f,
           (getarg_ax(c)>>12)&0x1,
           (getarg_ax(c)>>7)&0x1f,
           (getarg_ax(c)>>2)&0x1f,
           (getarg_ax(c)>>1)&0x1,
           getarg_ax(c) & 0x1)
  when OP_RETURN
    printf("OP_RETURN\tR%d", getarg_a(c))
    case getarg_b(c)
    when OP_R_NORMAL
      printf("\n")
    when OP_R_RETURN
      printf("\treturn\n")
    when OP_R_BREAK
      printf("\tbreak\n")
    else
      printf("\tbroken\n")
    end
  when OP_BLKPUSH
    printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d\n", getarg_a(c),
           (getarg_bx(c)>>10)&0x3f,
           (getarg_bx(c)>>9)&0x1,
           (getarg_bx(c)>>4)&0x1f,
           (getarg_bx(c)>>0)&0xf)

  when OP_LAMBDA
    printf("OP_LAMBDA\tR%d\tI(%+d)\t%d\n", getarg_a(c), getarg_b2(c), getarg_c2(c))
  when OP_RANGE
    printf("OP_RANGE\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_METHOD
    printf("OP_METHOD\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_b(c)])

  when OP_ADD
    printf("OP_ADD\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_ADDI
    printf("OP_ADDI\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_SUB
    printf("OP_SUB\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_SUBI
    printf("OP_SUBI\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_MUL
    printf("OP_MUL\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_DIV
    printf("OP_DIV\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_LT
    printf("OP_LT\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_LE
    printf("OP_LE\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_GT
    printf("OP_GT\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_GE
    printf("OP_GE\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))
  when OP_EQ
    printf("OP_EQ\tR%d\t:%s\t%d\n", getarg_a(c),
           @irep.syms[getarg_b(c)],
           getarg_c(c))

  when OP_STOP
    printf("OP_STOP\n")

  when OP_ARRAY
    printf("OP_ARRAY\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_ARYCAT
    printf("OP_ARYCAT\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
  when OP_ARYPUSH
    printf("OP_ARYPUSH\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
  when OP_AREF
    printf("OP_AREF\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_APOST
    printf("OP_APOST\tR%d\t%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
  when OP_STRING
    s = @irep.pool[getarg_bx(c)]
    printf("OP_STRING\tR%d\t%s\n", getarg_a(c), s)
  when OP_STRCAT
    printf("OP_STRCAT\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
  when OP_HASH
    printf("OP_HASH\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))

  when OP_OCLASS
    printf("OP_OCLASS\tR%d\n", getarg_a(c))
  when OP_CLASS
    printf("OP_cLASS\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_b(c)])
  when OP_MODULE
    printf("OP_MODULE\tR%d\t:%s\n", getarg_a(c),
           @irep.syms[getarg_b(c)])
  when OP_EXEC
    printf("OP_EXEC\tR%d\tI(%+d)\n", getarg_a(c), getarg_bx(c))
  when OP_SCLASS
    printf("OP_SCLASS\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
  when OP_TCLASS
    printf("OP_TCLASS\tR%d\n", getarg_a(c))
  when OP_ERR
    printf("OP_ERR\tL(%d)\n", getarg_bx(c))
  when OP_EPUSH
    printf("OP_EPUSH\t:I(%+d)\n", getarg_bx(c))
  when OP_ONERR
    printf("OP_ONERR\t%03d\n", i+getarg_sbx(c))
  when OP_RESCUE
    printf("OP_RESCUE\tR%d\n", getarg_a(c))
  when OP_RAISE
    printf("OP_RAISE\tR%d\n", getarg_a(c))
  when OP_POPERR
    printf("OP_POPERR\t%d\n", getarg_a(c))
  when OP_EPOP
    printf("OP_EPOP\t%d\n", getarg_a(c))
  else
    printf("OP_unknown %d\t%d\t%d\t%d\n", opcode(c),
           getarg_a(c), getarg_b(c), getarg_c(c))
  end
end

#getarg_a(code) ⇒ Object 



120
121
122
 
# File 'lib/mrb_parser/code_dump.rb', line 120

def getarg_a(code)
  (code >> 23) & 0x1ff
end

#getarg_ax(code) ⇒ Object 



140
141
142
 
# File 'lib/mrb_parser/code_dump.rb', line 140

def getarg_ax(code)
  (code >> 7) & 0x1ffffff
end

#getarg_b(code) ⇒ Object 



124
125
126
 
# File 'lib/mrb_parser/code_dump.rb', line 124

def getarg_b(code)
  (code >> 14) & 0x1ff
end

#getarg_b2(code) ⇒ Object 



152
153
154
 
# File 'lib/mrb_parser/code_dump.rb', line 152

def getarg_b2(code)
  getarg_unpack_b(code, 14, 2)
end

#getarg_bx(code) ⇒ Object 



132
133
134
 
# File 'lib/mrb_parser/code_dump.rb', line 132

def getarg_bx(code)
  (code >> 7) & 0xffff
end

#getarg_c(code) ⇒ Object 



128
129
130
 
# File 'lib/mrb_parser/code_dump.rb', line 128

def getarg_c(code)
  (code >> 7) & 0x7f
end

#getarg_c2(code) ⇒ Object 



156
157
158
 
# File 'lib/mrb_parser/code_dump.rb', line 156

def getarg_c2(code)
  getarg_unpack_c(code, 14, 2)
end

#getarg_sbx(code) ⇒ Object 



136
137
138
 
# File 'lib/mrb_parser/code_dump.rb', line 136

def getarg_sbx(code)
  getarg_bx(code) - MAXARG_sBx
end

#getarg_unpack_b(code, n1, n2) ⇒ Object 



144
145
146
 
# File 'lib/mrb_parser/code_dump.rb', line 144

def getarg_unpack_b(code, n1, n2)
  (code >> (7 + n2)) & ((1 << n1)-1)
end

#getarg_unpack_c(code, n1, n2) ⇒ Object 



148
149
150
 
# File 'lib/mrb_parser/code_dump.rb', line 148

def getarg_unpack_c(code, n1, n2)
  (code >> 7) & ((1 << n2)-1)
end

#opcode(code) ⇒ Object 



116
117
118
 
# File 'lib/mrb_parser/code_dump.rb', line 116

def opcode(code)
  code & 0x7F
end