Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   package org.jruby.ir.targets;
2
   
3
   import org.jruby.Ruby;
4
   import org.jruby.RubyBoolean;
5
   import org.jruby.RubyClass;
6
   import org.jruby.RubyModule;
7
   import org.jruby.RubyString;
82
  
83
  import java.util.Map;
87
  
88
  import static org.jruby.util.CodegenUtils.ci;
89
  import static org.jruby.util.CodegenUtils.p;
90
  import static org.jruby.util.CodegenUtils.sig;
91
  import  org.objectweb.asm.Type;
92
  import  org.objectweb.asm.commons.Method;

Implementation of IRCompiler for the JVM. 
96
  
97
  public class JVMVisitor extends IRVisitor {
98
  
99
      public static final String DYNAMIC_SCOPE = "$dynamicScope";
100
 
101
     public JVMVisitor() {
102
         this. = new JVM();
103
     }
104
 
105
     public static Class compile(Ruby ruby, IRScope scope, JRubyClassLoader jrubyClassLoader) {
106
         // run compiler
107
         JVMVisitor target = new JVMVisitor();
108
 
109
         target.codegen(scope);
110
 
111
 //        try {
112
 //            FileOutputStream fos = new FileOutputStream("tmp.class");
113
 //            fos.write(target.code());
114
 //            fos.close();
115
 //        } catch (Exception e) {
116
 //            e.printStackTrace();
117
 //        }
118
 
119
         return jrubyClassLoader.defineClass(JVM.scriptToClass(scope.getName()), target.code());
120
     }
121
 
122
     public byte[] code() {
123
         return .code();
124
     }
125
 
126
     public void codegen(IRScope scope) {
127
         if (scope instanceof IRScriptBody) {
128
             codegen((IRScriptBody)scope);
129
         }
130
     }
131
 
132
     public void codegen(IRScriptBody script) {
133
         this. = script;
134
         emit(script);
135
     }
136
 
137
     public String emitScope(IRScope scope, String name, int arity) {
138
         this. = scope;
139
         name = name + scope.getLineNumber();
140
         .pushmethod(name, arity);
141
 
142
         Tuple<Instr[], Map<Integer,Label[]>> t = scope.prepareForCompilation();
143
         Instr[] instrs = t.a;
144
         Map<Integer, Label[]> jumpTable = t.b;
145
 
146
         IRBytecodeAdapter m = .method();
147
         for (int i = 0; i < instrs.length; i++) {
148
             Instr instr = instrs[i];
149
 
150
             if (jumpTable.get(i) != null) {
151
                 for (Label label : jumpTable.get(i)) m.mark(.methodData().getLabel(label));
152
             }
153
             visit(instr);
154
         }
155
 
156
         .popmethod();
157
 
158
         return name;
159
     }
160
 
161
     public void emit(IRScriptBody script) {
162
         String clsName = .scriptToClass(script.getName());
163
         .pushscript(clsName, script.getFileName());
164
 
165
         emitScope(script, "__script__", 0);
166
 
167
         .cls().visitEnd();
168
         .popclass();
169
     }
170
 
171
     public void emit(IRMethod method) {
172
         String name = emitScope(method, method.getName(), method.getCallArgs().length);
173
 
174
         // push a method handle for binding purposes
175
         .method().pushHandle(.clsData()., name, method.getStaticScope().getRequiredArgs());
176
     }
177
 
178
     public void emit(IRModuleBody method) {
179
         String name = method.getName();
180
         if (name.indexOf("DUMMY_MC") != -1) {
181
             name = "METACLASS";
182
         }
183
 
184
         name = emitScope(method, name, 0);
185
 
186
         // push a method handle for binding purposes
187
         .method().pushHandle(.clsData()., name, method.getStaticScope().getRequiredArgs());
188
     }
189
 
190
     public void visit(Instr instr) {
191
         instr.visit(this);
192
     }
193
 
194
     public void visit(Operand operand) {
195
         if (operand.hasKnownValue()) {
196
             operand.visit(this);
197
         } else if (operand instanceof Variable) {
198
             emitVariable((Variable)operand);
199
         } else {
200
             operand.visit(this);
201
         }
202
     }
203
 
204
     private int getJVMLocalVarIndex(Variable variable) {
205
         return .methodData().local(variable);
206
     }
207
 
208
     private int getJVMLocalVarIndex(String specialVar) {
209
         return .methodData().local(specialVar);
210
     }
211
 
212
     private org.objectweb.asm.Label getJVMLabel(Label label) {
213
         return .methodData().getLabel(label);
214
     }
215
 
216
     private void jvmStoreLocal(Variable variable) {
217
         .method().storeLocal(getJVMLocalVarIndex(variable));
218
     }
219
 
220
     private void jvmStoreLocal(String specialVar) {
221
         .method().storeLocal(getJVMLocalVarIndex(specialVar));
222
     }
223
 
224
     private void jvmLoadLocal(Variable variable) {
225
         .method().loadLocal(getJVMLocalVarIndex(variable));
226
     }
227
 
228
     private void jvmLoadLocal(String specialVar) {
229
         .method().loadLocal(getJVMLocalVarIndex(specialVar));
230
     }
231
 
232
     public void emitVariable(Variable variable) {
233
 //        System.out.println("variable: " + variable);
234
         int index = getJVMLocalVarIndex(variable);
235
 //        System.out.println("index: " + index);
236
         .method().loadLocal(index);
237
     }
238
 
239
 
240
     // JVM maintains a stack of ClassData (for nested classes being compiled)
241
     // Each class maintains a stack of MethodData (for methods being compiled in the class)
242
     // MethodData wraps a IRBytecodeAdapter which wraps a SkinnyMethodAdapter which has a ASM MethodVisitor which emits bytecode
243
     // A long chain of indirection: JVM -> MethodData -> IRBytecodeAdapter -> SkinnyMethodAdapter -> ASM.MethodVisitor
244
     // In some places, methods reference JVM -> MethodData -> IRBytecodeAdapter (via jvm.method()) and ask it to walk the last 2 links
245
     // In other places, methods reference JVM -> MethodData -> IRBytecodeAdapter -> SkinnyMethodAdapter (via jvm.method().adapter) and ask it to walk the last link
246
     // Can this be cleaned up to either (a) get rid of IRBytecodeAdapter OR (b) implement passthru' methods for SkinnyMethodAdapter methods (like the others it implements)?
247
 
248
     @Override
249
     public void AliasInstr(AliasInstr aliasInstr) {
250
         IRBytecodeAdapter m = .method();
251
         m.loadLocal(0);
252
         m.loadLocal(getJVMLocalVarIndex(aliasInstr.getReceiver()));
253
         m.adapter.ldc(((StringLiteral) aliasInstr.getNewName()).);
254
         m.adapter.ldc(((StringLiteral) aliasInstr.getOldName()).);
255
         m.invokeHelper("defineAlias", IRubyObject.class, ThreadContext.class, IRubyObject.class, Object.class, Object.class);
256
         m.adapter.pop();
257
     }
258
 
259
     @Override
260
     public void AttrAssignInstr(AttrAssignInstr attrAssignInstr) {
261
         .method().loadLocal(0);
262
         visit(attrAssignInstr.getReceiver());
263
         for (Operand operand : attrAssignInstr.getCallArgs()) {
264
             visit(operand);
265
         }
266
 
267
         .method().invokeOther(attrAssignInstr.getMethodAddr().getName(), attrAssignInstr.getCallArgs().length);
268
         .method()..pop();
269
     }
270
 
271
     @Override
272
     public void BEQInstr(BEQInstr beqInstr) {
273
         Operand[] args = beqInstr.getOperands();
274
         .method().loadLocal(0);
275
         visit(args[0]);
276
         visit(args[1]);
277
         .method().invokeHelper("BEQ", boolean.class, ThreadContext.class, IRubyObject.class, IRubyObject.class);
278
         .method()..iftrue(getJVMLabel(beqInstr.getJumpTarget()));
279
     }
280
 
281
     @Override
282
     public void BFalseInstr(BFalseInstr bFalseInstr) {
283
         visit(bFalseInstr.getArg1());
284
         .method().isTrue();
285
         .method().bfalse(getJVMLabel(bFalseInstr.getJumpTarget()));
286
     }
287
 
288
     @Override
289
     public void BlockGivenInstr(BlockGivenInstr blockGivenInstr) {
290
         .method().loadRuntime();
291
         visit(blockGivenInstr.getBlockArg());
292
         .method().invokeVirtual(Type.getType(Block.class), Method.getMethod("boolean isGiven()"));
293
         .method().invokeVirtual(Type.getType(Ruby.class), Method.getMethod("org.jruby.RubyBoolean newBoolean(boolean)"));
294
         jvmStoreLocal(blockGivenInstr.getResult());
295
     }
296
 
297
     @Override
298
     public void BNEInstr(BNEInstr bneinstr) {
299
         Operand[] args = bneinstr.getOperands();
300
         .method().loadLocal(0);
301
         visit(args[0]);
302
         visit(args[1]);
303
         .method().invokeHelper("BNE", boolean.class, ThreadContext.class, IRubyObject.class, IRubyObject.class);
304
         .method()..iftrue(getJVMLabel(bneinstr.getJumpTarget()));
305
     }
306
 
307
     @Override
308
     public void BNilInstr(BNilInstr bnilinstr) {
309
         visit(bnilinstr.getArg1());
310
         .method().isNil();
311
         .method().btrue(getJVMLabel(bnilinstr.getJumpTarget()));
312
     }
313
 
314
     @Override
315
     public void BreakInstr(BreakInstr breakInstr) {
316
         IRBytecodeAdapter   m = .method();
317
         SkinnyMethodAdapter a = m.adapter;
318
         m.loadLocal(0); // context
319
         a.aload(1); // current scope
320
         // FIXME: This can also be done in the helper itself
321
         m.invokeVirtual(Type.getType(IRScope.class), Method.getMethod("org.jruby.ir.IRScope getIRScope()"));
322
         a.ldc(breakInstr.getScopeToReturnTo().getScopeId());
323
         visit(breakInstr.getReturnValue());
324
         // FIXME: emit block-type for the scope that is currently executing
325
         // For now, it is null
326
         m.pushNil();
327
         a.invokestatic(p(IRubyObject.class), "initiateBreak", sig(ThreadContext.class, IRScope.class, IRScope.class, IRubyObject.class, Block.Type.class));
328
     }
329
 
330
     @Override
331
     public void BTrueInstr(BTrueInstr btrueinstr) {
332
         visit(btrueinstr.getArg1());
333
         .method().isTrue();
334
         .method().btrue(getJVMLabel(btrueinstr.getJumpTarget()));
335
     }
336
 
337
     @Override
338
     public void BUndefInstr(BUndefInstr bundefinstr) {
339
         visit(bundefinstr.getArg1());
340
         .method().pushUndefined();
341
         .method()..if_acmpeq(getJVMLabel(bundefinstr.getJumpTarget()));
342
     }
343
 
344
     @Override
345
     public void CallInstr(CallInstr callInstr) {
346
         IRBytecodeAdapter m = .method();
347
         String name = callInstr.getMethodAddr().getName();
348
         Operand[] args = callInstr.getCallArgs();
349
         int numArgs = args.length;
350
 
351
         if (   (name.equals("+") || name.equals("-") || name.equals("*") || name.equals("/"))
352
             && numArgs == 1
353
             && args[0] instanceof Fixnum
354
             && callInstr.getCallType() == .)
355
         {
356
             m.loadLocal(0);
357
             m.loadLocal(2); // dummy to satisfy signature of existing target linker (MathLinker)
358
             visit(callInstr.getReceiver());
359
             m.invokeFixnumOp(name, ((Fixnum)args[0]).);
360
         } else {
361
             m.loadLocal(0);
362
             visit(callInstr.getReceiver());
363
             for (Operand operand : args) {
364
                 visit(operand);
365
             }
366
             switch (callInstr.getCallType()) {
367
                 case :
368
                 case :
369
                     m.invokeSelf(name, numArgs);
370
                     break;
371
                 case :
372
                     m.invokeOther(name, numArgs);
373
                     break;
374
                 case :
375
                     m.invokeSuper(name, numArgs);
376
                     break;
377
             }
378
         }
379
 
380
         jvmStoreLocal(callInstr.getResult());
381
     }
382
 
383
     @Override
384
     public void CheckArgsArrayArityInstr(CheckArgsArrayArityInstr checkargsarrayarityinstr) {
385
         .method().loadContext();
386
         visit(checkargsarrayarityinstr.getArgsArray());
387
         .method()..pushInt(checkargsarrayarityinstr.required);
388
         .method()..pushInt(checkargsarrayarityinstr.opt);
389
         .method()..pushInt(checkargsarrayarityinstr.rest);
390
         .method().invokeStatic(Type.getType(Helpers.class), Method.getMethod("void irCheckArgsArrayArity(org.jruby.runtime.ThreadContext, org.jruby.RubyArray, int, int, int)"));
391
     }
392
 
393
     @Override
394
     public void CheckArityInstr(CheckArityInstr checkarityinstr) {
395
         // no-op for now
396
     }
397
 
398
     @Override
399
     public void ClassSuperInstr(ClassSuperInstr classsuperinstr) {
400
         super.ClassSuperInstr(classsuperinstr);    //To change body of overridden methods use File | Settings | File Templates.
401
     }
402
 
403
     @Override
404
     public void ConstMissingInstr(ConstMissingInstr constmissinginstr) {
405
         visit(constmissinginstr.getReceiver());
406
         .method()..checkcast("org/jruby/RubyModule");
407
         .method().loadContext();
408
         .method()..ldc("const_missing");
409
         .method().pushSymbol(constmissinginstr.getMissingConst());
410
         .method().invokeVirtual(Type.getType(RubyModule.class), Method.getMethod("org.jruby.runtime.builtin.IRubyObject callMethod(org.jruby.runtime.ThreadContext, java.lang.String, org.jruby.runtime.builtin.IRubyObject)"));
411
     }
412
 
413
     @Override
414
     public void CopyInstr(CopyInstr copyinstr) {
415
         int index = getJVMLocalVarIndex(copyinstr.getResult());
416
         visit(copyinstr.getSource());
417
         .method().storeLocal(index);
418
     }
419
 
420
     @Override
421
     public void DefineClassInstr(DefineClassInstr defineclassinstr) {
422
         IRClassBody newIRClassBody = defineclassinstr.getNewIRClassBody();
423
         StaticScope scope = newIRClassBody.getStaticScope();
424
         if (scope.getRequiredArgs() > 3 || scope.getRestArg() >= 0 || scope.getOptionalArgs() != 0) {
425
             throw new RuntimeException("can't compile variable method: " + this);
426
         }
427
 
428
         String scopeString = Helpers.encodeScope(scope);
429
 
430
         IRBytecodeAdapter   m = .method();
431
         SkinnyMethodAdapter a = m.adapter;
432
 
433
         // new CompiledIRMethod
434
         a.newobj(p(CompiledIRMethod.class));
435
         a.dup();
436
 
437
         // emit method body and get handle
438
         emit(newIRClassBody); // handle
439
 
440
         // add'l args for CompiledIRMethod constructor
441
         a.ldc(newIRClassBody.getName());
442
         a.ldc(newIRClassBody.getFileName());
443
         a.ldc(newIRClassBody.getLineNumber());
444
 
445
         // construct class with Helpers.newClassForIR
446
         a.aload(0); // ThreadContext
447
         a.ldc(newIRClassBody.getName()); // class name
448
         m.loadLocal(2); // self
449
 
450
         // create class
451
         m.loadLocal(0);
452
         visit(defineclassinstr.getContainer());
453
         m.invokeHelper("checkIsRubyModule", RubyModule.class, ThreadContext.class, Object.class);
454
 
455
         // superclass
456
         if (defineclassinstr.getSuperClass() instanceof Nil) {
457
             a.aconst_null();
458
         } else {
459
             visit(defineclassinstr.getSuperClass());
460
         }
461
 
462
         // is meta?
463
         a.ldc(newIRClassBody instanceof IRMetaClassBody);
464
 
465
         m.invokeHelper("newClassForIR", RubyClass.class, ThreadContext.class, String.class, IRubyObject.class, RubyModule.class, Object.class, boolean.class);
466
 
467
         //// static scope
468
         a.aload(0);
469
         a.aload(1);
470
         a.ldc(scopeString);
471
         a.invokestatic(p(Helpers.class), "decodeScope", "(Lorg/jruby/runtime/ThreadContext;Lorg/jruby/parser/StaticScope;Ljava/lang/String;)Lorg/jruby/parser/StaticScope;");
472
         a.swap();
473
 
474
         // set into StaticScope
475
         a.dup2();
476
         a.invokevirtual(p(StaticScope.class), "setModule", sig(void.class, RubyModule.class));
477
 
478
         a.getstatic(p(Visibility.class), "PUBLIC", ci(Visibility.class));
479
         a.swap();
480
 
481
         // invoke constructor
482
         a.invokespecial(p(CompiledIRMethod.class), "<init>", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/String;ILorg/jruby/parser/StaticScope;Lorg/jruby/runtime/Visibility;Lorg/jruby/RubyModule;)V");
483
 
484
         // store
485
         jvmStoreLocal(defineclassinstr.getResult());
486
     }
487
 
488
     @Override
489
     public void DefineClassMethodInstr(DefineClassMethodInstr defineclassmethodinstr) {
490
         super.DefineClassMethodInstr(defineclassmethodinstr);    //To change body of overridden methods use File | Settings | File Templates.
491
     }
492
 
493
     @Override
494
     public void DefineInstanceMethodInstr(DefineInstanceMethodInstr defineinstancemethodinstr) {
495
         IRMethod method = defineinstancemethodinstr.getMethod();
496
         StaticScope scope = method.getStaticScope();
497
         if (scope.getRequiredArgs() > 3 || scope.getRestArg() >= 0 || scope.getOptionalArgs() != 0) {
498
             throw new RuntimeException("can't compile variable method: " + this);
499
         }
500
 
501
         String scopeString = Helpers.encodeScope(scope);
502
 
503
         IRBytecodeAdapter   m = .method();
504
         SkinnyMethodAdapter a = m.adapter;
505
 
506
         // preamble for addMethod below
507
         a.aload(0);
508
         a.invokevirtual(p(ThreadContext.class), "getRubyClass", "()Lorg/jruby/RubyModule;");
509
         a.ldc(method.getName());
510
 
511
         // new CompiledIRMethod
512
         a.newobj(p(CompiledIRMethod.class));
513
         a.dup();
514
 
515
         // emit method body and get handle
516
         emit(method); // handle
517
 
518
         // add'l args for CompiledIRMethod constructor
519
         a.ldc(method.getName());
520
         a.ldc(method.getFileName());
521
         a.ldc(method.getLineNumber());
522
 
523
         a.aload(0);
524
         a.aload(1);
525
         a.ldc(scopeString);
526
         a.invokestatic(p(Helpers.class), "decodeScope", "(Lorg/jruby/runtime/ThreadContext;Lorg/jruby/parser/StaticScope;Ljava/lang/String;)Lorg/jruby/parser/StaticScope;");
527
 
528
         a.aload(0);
529
         a.invokevirtual(p(ThreadContext.class), "getCurrentVisibility", "()Lorg/jruby/runtime/Visibility;");
530
         a.aload(0);
531
         a.invokevirtual(p(ThreadContext.class), "getRubyClass", "()Lorg/jruby/RubyModule;");
532
 
533
         // invoke constructor
534
         a.invokespecial(p(CompiledIRMethod.class), "<init>", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/String;ILorg/jruby/parser/StaticScope;Lorg/jruby/runtime/Visibility;Lorg/jruby/RubyModule;)V");
535
 
536
         // add method
537
         a.invokevirtual(p(RubyModule.class), "addMethod", "(Ljava/lang/String;Lorg/jruby/internal/runtime/methods/DynamicMethod;)V");
538
     }
539
 
540
     @Override
541
     public void DefineMetaClassInstr(DefineMetaClassInstr definemetaclassinstr) {
542
         IRModuleBody metaClassBody = definemetaclassinstr.getMetaClassBody();
543
         StaticScope scope = metaClassBody.getStaticScope();
544
         if (scope.getRequiredArgs() > 3 || scope.getRestArg() >= 0 || scope.getOptionalArgs() != 0) {
545
             throw new RuntimeException("can't compile variable method: " + this);
546
         }
547
 
548
         String scopeString = Helpers.encodeScope(scope);
549
 
550
         IRBytecodeAdapter   m = .method();
551
         SkinnyMethodAdapter a = m.adapter;
552
 
553
         // new CompiledIRMethod
554
         a.newobj(p(CompiledIRMethod.class));
555
         a.dup();
556
 
557
         // emit method body and get handle
558
         emit(metaClassBody); // handle
559
 
560
         // add'l args for CompiledIRMethod constructor
561
         a.ldc(metaClassBody.getName());
562
         a.ldc(metaClassBody.getFileName());
563
         a.ldc(metaClassBody.getLineNumber());
564
 
565
         //// static scope
566
         a.aload(0);
567
         a.aload(1);
568
         a.ldc(scopeString);
569
         a.invokestatic(p(Helpers.class), "decodeScope", "(Lorg/jruby/runtime/ThreadContext;Lorg/jruby/parser/StaticScope;Ljava/lang/String;)Lorg/jruby/parser/StaticScope;");
570
 
571
         // get singleton class
572
         m.loadRuntime();
573
         visit(definemetaclassinstr.getObject());
574
         m.invokeHelper("getSingletonClass", RubyClass.class, Ruby.class, IRubyObject.class);
575
 
576
         // set into StaticScope
577
         a.dup2();
578
         a.invokevirtual(p(StaticScope.class), "setModule", sig(void.class, RubyModule.class));
579
 
580
         a.getstatic(p(Visibility.class), "PUBLIC", ci(Visibility.class));
581
         a.swap();
582
 
583
         // invoke constructor
584
         a.invokespecial(p(CompiledIRMethod.class), "<init>", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/String;ILorg/jruby/parser/StaticScope;Lorg/jruby/runtime/Visibility;Lorg/jruby/RubyModule;)V");
585
 
586
         // store
587
         jvmStoreLocal(definemetaclassinstr.getResult());
588
     }
589
 
590
     @Override
591
     public void DefineModuleInstr(DefineModuleInstr definemoduleinstr) {
592
         IRModuleBody newIRModuleBody = definemoduleinstr.getNewIRModuleBody();
593
         StaticScope scope = newIRModuleBody.getStaticScope();
594
         if (scope.getRequiredArgs() > 3 || scope.getRestArg() >= 0 || scope.getOptionalArgs() != 0) {
595
             throw new RuntimeException("can't compile variable method: " + this);
596
         }
597
 
598
         String scopeString = Helpers.encodeScope(scope);
599
 
600
         IRBytecodeAdapter   m = .method();
601
         SkinnyMethodAdapter a = m.adapter;
602
 
603
         // new CompiledIRMethod
604
         a.newobj(p(CompiledIRMethod.class));
605
         a.dup();
606
 
607
         // emit method body and get handle
608
         emit(newIRModuleBody); // handle
609
 
610
         // add'l args for CompiledIRMethod constructor
611
         a.ldc(newIRModuleBody.getName());
612
         a.ldc(newIRModuleBody.getFileName());
613
         a.ldc(newIRModuleBody.getLineNumber());
614
 
615
         a.aload(0);
616
         a.aload(1);
617
         a.ldc(scopeString);
618
         a.invokestatic(p(Helpers.class), "decodeScope", "(Lorg/jruby/runtime/ThreadContext;Lorg/jruby/parser/StaticScope;Ljava/lang/String;)Lorg/jruby/parser/StaticScope;");
619
 
620
         // create module
621
         m.loadLocal(0);
622
         visit(definemoduleinstr.getContainer());
623
         m.invokeHelper("checkIsRubyModule", RubyModule.class, ThreadContext.class, Object.class);
624
         a.ldc(newIRModuleBody.getName());
625
         a.invokevirtual(p(RubyModule.class), "defineOrGetModuleUnder", sig(RubyModule.class, String.class));
626
 
627
         // set into StaticScope
628
         a.dup2();
629
         a.invokevirtual(p(StaticScope.class), "setModule", sig(void.class, RubyModule.class));
630
 
631
         a.getstatic(p(Visibility.class), "PUBLIC", ci(Visibility.class));
632
         a.swap();
633
 
634
         // invoke constructor
635
         a.invokespecial(p(CompiledIRMethod.class), "<init>", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/String;ILorg/jruby/parser/StaticScope;Lorg/jruby/runtime/Visibility;Lorg/jruby/RubyModule;)V");
636
 
637
         // store
638
         jvmStoreLocal(definemoduleinstr.getResult());
639
     }
640
 
641
     @Override
642
     public void EnsureRubyArrayInstr(EnsureRubyArrayInstr ensurerubyarrayinstr) {
643
         visit(ensurerubyarrayinstr.getObject());
644
         .method()..dup();
645
         org.objectweb.asm.Label after = new org.objectweb.asm.Label();
646
         .method()..instance_of("org/jruby/RubyArray");
647
         .method()..iftrue(after);
648
         .method()..swap();
649
         .method().loadRuntime();
650
         .method()..ldc(false);
651
         .method().invokeStatic(Type.getType(ArgsUtil.class), Method.getMethod("org.jruby.RubyArray convertToRubyArray(org.jruby.Ruby, org.jruby.runtime.builtin.IRubyObject, boolean)"));
652
         .method()..label(after);
653
         jvmStoreLocal(ensurerubyarrayinstr.getResult());
654
     }
655
 
656
     @Override
657
     public void EQQInstr(EQQInstr eqqinstr) {
658
         super.EQQInstr(eqqinstr);    //To change body of overridden methods use File | Settings | File Templates.
659
     }
660
 
661
     @Override
662
     public void ExceptionRegionEndMarkerInstr(ExceptionRegionEndMarkerInstr exceptionregionendmarkerinstr) {
663
         throw new RuntimeException("Marker instructions shouldn't reach compiler: " + exceptionregionendmarkerinstr);
664
     }
665
 
666
     @Override
667
     public void ExceptionRegionStartMarkerInstr(ExceptionRegionStartMarkerInstr exceptionregionstartmarkerinstr) {
668
         throw new RuntimeException("Marker instructions shouldn't reach compiler: " + exceptionregionstartmarkerinstr);
669
     }
670
 
671
     @Override
672
     public void GetClassVarContainerModuleInstr(GetClassVarContainerModuleInstr getclassvarcontainermoduleinstr) {
673
         super.GetClassVarContainerModuleInstr(getclassvarcontainermoduleinstr);    //To change body of overridden methods use File | Settings | File Templates.
674
     }
675
 
676
     @Override
677
     public void GetClassVariableInstr(GetClassVariableInstr getclassvariableinstr) {
678
         super.GetClassVariableInstr(getclassvariableinstr);    //To change body of overridden methods use File | Settings | File Templates.
679
     }
680
 
681
     @Override
682
     public void GetFieldInstr(GetFieldInstr getfieldinstr) {
683
         visit(getfieldinstr.getSource());
684
         .method().getField(getfieldinstr.getRef());
685
         jvmStoreLocal(getfieldinstr.getResult());
686
     }
687
 
688
     @Override
689
     public void GetGlobalVariableInstr(GetGlobalVariableInstr getglobalvariableinstr) {
690
         super.GetGlobalVariableInstr(getglobalvariableinstr);    //To change body of overridden methods use File | Settings | File Templates.
691
     }
692
 
693
     @Override
694
     public void GVarAliasInstr(GVarAliasInstr gvaraliasinstr) {
695
         super.GVarAliasInstr(gvaraliasinstr);    //To change body of overridden methods use File | Settings | File Templates.
696
     }
697
 
698
     @Override
699
     public void InheritanceSearchConstInstr(InheritanceSearchConstInstr inheritancesearchconstinstr) {
700
         .method().loadLocal(0);
701
         visit(inheritancesearchconstinstr.getCurrentModule());
702
 
703
         // TODO: private consts
704
         .method().inheritanceSearchConst(inheritancesearchconstinstr.getConstName());
705
         jvmStoreLocal(inheritancesearchconstinstr.getResult());
706
     }
707
 
708
     @Override
709
     public void InstanceSuperInstr(InstanceSuperInstr instancesuperinstr) {
710
         super.InstanceSuperInstr(instancesuperinstr);    //To change body of overridden methods use File | Settings | File Templates.
711
     }
712
 
713
     @Override
714
     public void JumpIndirectInstr(JumpIndirectInstr jumpindirectinstr) {
715
         super.JumpIndirectInstr(jumpindirectinstr);    //To change body of overridden methods use File | Settings | File Templates.
716
     }
717
 
718
     @Override
719
     public void JumpInstr(JumpInstr jumpinstr) {
720
         .method().goTo(getJVMLabel(jumpinstr.getJumpTarget()));
721
     }
722
 
723
     @Override
724
     public void LabelInstr(LabelInstr labelinstr) {
725
         .method().mark(getJVMLabel(labelinstr.getLabel()));
726
     }
727
 
728
     @Override
729
     public void LexicalSearchConstInstr(LexicalSearchConstInstr lexicalsearchconstinstr) {
730
         super.LexicalSearchConstInstr(lexicalsearchconstinstr);    //To change body of overridden methods use File | Settings | File Templates.
731
     }
732
 
733
     @Override
734
     public void LineNumberInstr(LineNumberInstr linenumberinstr) {
735
         .method()..line(linenumberinstr.getLineNumber());
736
     }
737
 
738
     @Override
739
     public void LoadLocalVarInstr(LoadLocalVarInstr loadlocalvarinstr) {
740
         IRBytecodeAdapter m = .method();
741
         jvmLoadLocal();
742
         int depth = loadlocalvarinstr.getLocalVar().getScopeDepth();
743
         // TODO should not have to subtract 1
744
         int location = loadlocalvarinstr.getLocalVar().getLocation() - 1;
745
         // TODO if we can avoid loading nil unnecessarily, it could be a big win
746
         switch (depth) {
747
             case 0:
748
                 switch (location) {
749
                     case 0:
750
                         m.pushNil();
751
                         m.adapter.invokevirtual(p(DynamicScope.class), "getValueZeroDepthZeroOrNil", sig(IRubyObject.class, IRubyObject.class));
752
                         return;
753
                     case 1:
754
                         m.pushNil();
755
                         m.adapter.invokevirtual(p(DynamicScope.class), "getValueOneDepthZeroOrNil", sig(IRubyObject.class, IRubyObject.class));
756
                         return;
757
                     case 2:
758
                         m.pushNil();
759
                         m.adapter.invokevirtual(p(DynamicScope.class), "getValueTwoDepthZeroOrNil", sig(IRubyObject.class, IRubyObject.class));
760
                         return;
761
                     case 3:
762
                         m.pushNil();
763
                         m.adapter.invokevirtual(p(DynamicScope.class), "getValueThreeDepthZeroOrNil", sig(IRubyObject.class, IRubyObject.class));
764
                         return;
765
                     default:
766
                         m.adapter.pushInt(location);
767
                         m.pushNil();
768
                         m.adapter.invokevirtual(p(DynamicScope.class), "getValueDepthZeroOrNil", sig(IRubyObject.class, int.class, IRubyObject.class));
769
                         return;
770
                 }
771
             default:
772
                 m.adapter.pushInt(location);
773
                 m.adapter.pushInt(depth);
774
                 m.pushNil();
775
                 m.adapter.invokevirtual(p(DynamicScope.class), "getValueOrNil", sig(IRubyObject.class, int.class, int.class, IRubyObject.class));
776
         }
777
     }
778
 
779
     @Override
780
     public void Match2Instr(Match2Instr match2instr) {
781
         super.Match2Instr(match2instr);    //To change body of overridden methods use File | Settings | File Templates.
782
     }
783
 
784
     @Override
785
     public void Match3Instr(Match3Instr match3instr) {
786
         super.Match3Instr(match3instr);    //To change body of overridden methods use File | Settings | File Templates.
787
     }
788
 
789
     @Override
790
     public void MatchInstr(MatchInstr matchinstr) {
791
         super.MatchInstr(matchinstr);    //To change body of overridden methods use File | Settings | File Templates.
792
     }
793
 
794
     @Override
795
     public void MethodLookupInstr(MethodLookupInstr methodlookupinstr) {
796
         // SSS FIXME: Unused at this time
797
         throw new RuntimeException("Unsupported instruction: " + methodlookupinstr);
798
     }
799
 
800
     @Override
801
     public void ModuleVersionGuardInstr(ModuleVersionGuardInstr moduleversionguardinstr) {
802
         // SSS FIXME: Unused at this time
803
         throw new RuntimeException("Unsupported instruction: " + moduleversionguardinstr);
804
     }
805
 
806
     @Override
807
     public void NopInstr(NopInstr nopinstr) {
808
         // do nothing
809
     }
810
 
811
     @Override
812
     public void NoResultCallInstr(NoResultCallInstr noResultCallInstr) {
813
         IRBytecodeAdapter m = .method();
814
         m.loadLocal(0);
815
         visit(noResultCallInstr.getReceiver());
816
         for (Operand operand : noResultCallInstr.getCallArgs()) {
817
             visit(operand);
818
         }
819
 
820
         switch (noResultCallInstr.getCallType()) {
821
             case :
822
             case :
823
                 m.invokeSelf(noResultCallInstr.getMethodAddr().getName(), noResultCallInstr.getCallArgs().length);
824
                 break;
825
             case :
826
                 m.invokeOther(noResultCallInstr.getMethodAddr().getName(), noResultCallInstr.getCallArgs().length);
827
                 break;
828
             case :
829
                 m.invokeSuper(noResultCallInstr.getMethodAddr().getName(), noResultCallInstr.getCallArgs().length);
830
                 break;
831
         }
832
 
833
         m.adapter.pop();
834
     }
835
 
836
     @Override
837
     public void NotInstr(NotInstr instr) {
838
         visit(instr.getOperands()[0]);
839
         // SSS FIXME: Does this really require a helper rather than being inlined?
840
         .method().invokeHelper("irNot", IRubyObject.class, ThreadContext.class, IRubyObject.class);
841
     }
842
 
843
     @Override
844
     public void OptArgMultipleAsgnInstr(OptArgMultipleAsgnInstr optargmultipleasgninstr) {
845
         super.OptArgMultipleAsgnInstr(optargmultipleasgninstr);    //To change body of overridden methods use File | Settings | File Templates.
846
     }
847
 
848
     @Override
849
     public void PopBindingInstr(PopBindingInstr popbindinginstr) {
850
         // TODO pop
851
     }
852
 
853
     @Override
854
     public void ProcessModuleBodyInstr(ProcessModuleBodyInstr processmodulebodyinstr) {
855
         .method().loadLocal(0);
856
         visit(processmodulebodyinstr.getModuleBody());
857
         .method().invokeHelper("invokeModuleBody", IRubyObject.class, ThreadContext.class, CompiledIRMethod.class);
858
         jvmStoreLocal(processmodulebodyinstr.getResult());
859
     }
860
 
861
     @Override
862
     public void PushBindingInstr(PushBindingInstr pushbindinginstr) {
863
         .method().loadStaticScope();
864
         .method()..invokestatic(p(DynamicScope.class), "newDynamicScope", sig(DynamicScope.class, StaticScope.class));
865
         jvmStoreLocal();
866
 
867
         // TODO push
868
     }
869
 
870
     @Override
871
     public void PutClassVariableInstr(PutClassVariableInstr putclassvariableinstr) {
872
         super.PutClassVariableInstr(putclassvariableinstr);    //To change body of overridden methods use File | Settings | File Templates.
873
     }
874
 
875
     @Override
876
     public void PutConstInstr(PutConstInstr putconstinstr) {
877
         IRBytecodeAdapter m = .method();
878
         visit(putconstinstr.getTarget());
879
         m.adapter.checkcast(p(RubyModule.class));
880
         m.adapter.ldc(putconstinstr.getRef());
881
         visit(putconstinstr.getValue());
882
         m.adapter.invokevirtual(p(RubyModule.class), "setConstant", sig(IRubyObject.class, String.class, IRubyObject.class));
883
         m.adapter.pop();
884
     }
885
 
886
     @Override
887
     public void PutFieldInstr(PutFieldInstr putfieldinstr) {
888
         visit(putfieldinstr.getTarget());
889
         visit(putfieldinstr.getValue());
890
         .method().putField(putfieldinstr.getRef());
891
     }
892
 
893
     @Override
894
     public void PutGlobalVarInstr(PutGlobalVarInstr putglobalvarinstr) {
895
         super.PutGlobalVarInstr(putglobalvarinstr);    //To change body of overridden methods use File | Settings | File Templates.
896
     }
897
 
898
     @Override
899
     public void RaiseArgumentErrorInstr(RaiseArgumentErrorInstr raiseargumenterrorinstr) {
900
         super.RaiseArgumentErrorInstr(raiseargumenterrorinstr);    //To change body of overridden methods use File | Settings | File Templates.
901
     }
902
 
903
     @Override
904
     public void ReceiveClosureInstr(ReceiveClosureInstr receiveclosureinstr) {
905
         // -- NOP --
906
         // The JVM always sets up $block to be at the same lvar index where it comes in.
907
         // jvmLoadLocal("$block");
908
         // jvmStoreLocal(receiveclosureinstr.getResult());
909
     }
910
 
911
     @Override
912
     public void ReceiveExceptionInstr(ReceiveExceptionInstr receiveexceptioninstr) {
913
         // TODO implement
914
     }
915
 
916
     @Override
917
     public void ReceivePreReqdArgInstr(ReceivePreReqdArgInstr instr) {
918
         int index = getJVMLocalVarIndex(instr.getResult());
919
         .method().loadLocal(3 + instr.getArgIndex());
920
         .method().storeLocal(index);
921
     }
922
 
923
     @Override
924
     public void ReceiveOptArgInstr(ReceiveOptArgInstr instr) {
925
         // FIXME: Only works when args is in an array rather than being flattened out
926
         // FIXME: Missing kwargs 2.0 support (kwArgHashCount value)
927
         .method()..pushInt(instr.getArgIndex() + instr.numUsedArgs); // MIN reqd args
928
         .method()..pushInt(instr.getArgIndex() + instr.argOffset); // args array offset
929
         .method()..aload(3); // FIXME: what is the correct lvar index for args[]?