Merge pull request #803 from magarciaEPFL/offload-classfile-writing-B

performance improvements (10% to 20% depending on HDD vs SSD) in GenASM

4 files changed, 444 insertions, 280 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
index 5f495c8456..13457bfe58 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
@@ -15,37 +15,48 @@ import scala.reflect.internal.util.{Position,NoPosition}
 /*
   A pattern match
 
-  case THIS(clasz) =>
-  case STORE_THIS(kind) =>
-  case CONSTANT(const) =>
-  case LOAD_ARRAY_ITEM(kind) =>
-  case LOAD_LOCAL(local) =>
-  case LOAD_FIELD(field, isStatic) =>
-  case LOAD_MODULE(module) =>
-  case STORE_ARRAY_ITEM(kind) =>
-  case STORE_LOCAL(local) =>
-  case STORE_FIELD(field, isStatic) =>
-  case CALL_PRIMITIVE(primitive) =>
-  case CALL_METHOD(method, style) =>
-  case NEW(kind) =>
-  case CREATE_ARRAY(elem, dims) =>
-  case IS_INSTANCE(tpe) =>
-  case CHECK_CAST(tpe) =>
-  case SWITCH(tags, labels) =>
-  case JUMP(whereto) =>
-  case CJUMP(success, failure, cond, kind) =>
-  case CZJUMP(success, failure, cond, kind) =>
-  case RETURN(kind) =>
-  case THROW(clasz) =>
-  case DROP(kind) =>
-  case DUP(kind) =>
-  case MONITOR_ENTER() =>
-  case MONITOR_EXIT() =>
-  case BOX(boxType) =>
-  case UNBOX(tpe) =>
-  case SCOPE_ENTER(lv) =>
-  case SCOPE_EXIT(lv) =>
-  case LOAD_EXCEPTION(clasz) =>
+  // locals
+    case THIS(clasz) =>
+    case STORE_THIS(kind) =>
+    case LOAD_LOCAL(local) =>
+    case STORE_LOCAL(local) =>
+    case SCOPE_ENTER(lv) =>
+    case SCOPE_EXIT(lv) =>
+  // stack
+    case LOAD_MODULE(module) =>
+    case LOAD_EXCEPTION(clasz) =>
+    case DROP(kind) =>
+    case DUP(kind) =>
+  // constants
+    case CONSTANT(const) =>
+  // arithlogic
+    case CALL_PRIMITIVE(primitive) =>
+  // casts
+    case IS_INSTANCE(tpe) =>
+    case CHECK_CAST(tpe) =>
+  // objs
+    case NEW(kind) =>
+    case MONITOR_ENTER() =>
+    case MONITOR_EXIT() =>
+    case BOX(boxType) =>
+    case UNBOX(tpe) =>
+  // flds
+    case LOAD_FIELD(field, isStatic) =>
+    case STORE_FIELD(field, isStatic) =>
+  // mthds
+    case CALL_METHOD(method, style) =>
+  // arrays
+    case LOAD_ARRAY_ITEM(kind) =>
+    case STORE_ARRAY_ITEM(kind) =>
+    case CREATE_ARRAY(elem, dims) =>
+  // jumps
+    case SWITCH(tags, labels) =>
+    case JUMP(whereto) =>
+    case CJUMP(success, failure, cond, kind) =>
+    case CZJUMP(success, failure, cond, kind) =>
+  // ret
+    case RETURN(kind) =>
+    case THROW(clasz) =>
 */
 
 
@@ -58,11 +69,26 @@ import scala.reflect.internal.util.{Position,NoPosition}
 trait Opcodes { self: ICodes =>
   import global.{Symbol, NoSymbol, Type, Name, Constant};
 
+  // categories of ICode instructions
+  final val localsCat =  1
+  final val stackCat  =  2
+  final val constCat  =  3
+  final val arilogCat =  4
+  final val castsCat  =  5
+  final val objsCat   =  6
+  final val fldsCat   =  7
+  final val mthdsCat  =  8
+  final val arraysCat =  9
+  final val jumpsCat  = 10
+  final val retCat    = 11
+
   /** This class represents an instruction of the intermediate code.
    *  Each case subclass will represent a specific operation.
    */
   abstract class Instruction extends Cloneable {
 
+    def category: Int = 0 // undefined
+
     /** This abstract method returns the number of used elements on the stack */
     def consumed : Int = 0
 
@@ -118,6 +144,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def producedTypes = List(REFERENCE(clasz))
+
+      override def category = localsCat
     }
 
     /** Loads a constant on the stack.
@@ -130,6 +158,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def producedTypes = List(toTypeKind(constant.tpe))
+
+      override def category = constCat
     }
 
     /** Loads an element of an array. The array and the index should
@@ -143,6 +173,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumedTypes = List(ARRAY(kind), INT)
       override def producedTypes = List(kind)
+
+      override def category = arraysCat
     }
 
     /** Load a local variable on the stack. It can be a method argument.
@@ -154,6 +186,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def producedTypes = List(local.kind)
+
+      override def category = localsCat
     }
 
     /** Load a field on the stack. The object to which it refers should be
@@ -176,6 +210,8 @@ trait Opcodes { self: ICodes =>
       // see #4283
       var hostClass: Symbol = field.owner
       def setHostClass(cls: Symbol): this.type = { hostClass = cls; this }
+
+      override def category = fldsCat
     }
 
     case class LOAD_MODULE(module: Symbol) extends Instruction {
@@ -187,6 +223,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def producedTypes = List(REFERENCE(module))
+
+      override def category = stackCat
     }
 
     /** Store a value into an array at a specified index.
@@ -198,6 +236,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 0
 
       override def consumedTypes = List(ARRAY(kind), INT, kind)
+
+      override def category = arraysCat
     }
 
     /** Store a value into a local variable. It can be an argument.
@@ -209,6 +249,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 0
 
       override def consumedTypes = List(local.kind)
+
+      override def category = localsCat
     }
 
     /** Store a value into a field.
@@ -228,6 +270,8 @@ trait Opcodes { self: ICodes =>
           List(toTypeKind(field.tpe))
         else
           List(REFERENCE(field.owner), toTypeKind(field.tpe));
+
+      override def category = fldsCat
     }
 
     /** Store a value into the 'this' pointer.
@@ -238,6 +282,7 @@ trait Opcodes { self: ICodes =>
       override def consumed = 1
       override def produced = 0
       override def consumedTypes = List(kind)
+      override def category = localsCat
     }
 
     /** Call a primitive function.
@@ -292,6 +337,8 @@ trait Opcodes { self: ICodes =>
         case StartConcat         => List(ConcatClass)
         case EndConcat           => List(REFERENCE(global.definitions.StringClass))
       }
+
+      override def category = arilogCat
    }
 
     /** This class represents a CALL_METHOD instruction
@@ -347,6 +394,8 @@ trait Opcodes { self: ICodes =>
        *  being able to store such instructions into maps, when more
        *  than one CALL_METHOD to the same method might exist.
        */
+
+      override def category = mthdsCat
     }
 
     case class BOX(boxType: TypeKind) extends Instruction {
@@ -355,6 +404,7 @@ trait Opcodes { self: ICodes =>
       override def consumed = 1
       override def consumedTypes = boxType :: Nil
       override def produced = 1
+      override def category = objsCat
     }
 
     case class UNBOX(boxType: TypeKind) extends Instruction {
@@ -363,6 +413,7 @@ trait Opcodes { self: ICodes =>
       override def consumed = 1
       override def consumedTypes = ObjectReference :: Nil
       override def produced = 1
+      override def category = objsCat
     }
 
     /** Create a new instance of a class through the specified constructor
@@ -378,6 +429,8 @@ trait Opcodes { self: ICodes =>
 
       /** The corresponding constructor call. */
       var init: CALL_METHOD = _
+
+      override def category = objsCat
     }
 
 
@@ -392,6 +445,8 @@ trait Opcodes { self: ICodes =>
       override def consumed = dims;
       override def consumedTypes = List.fill(dims)(INT)
       override def produced = 1;
+
+      override def category = arraysCat
     }
 
     /** This class represents a IS_INSTANCE instruction
@@ -405,6 +460,8 @@ trait Opcodes { self: ICodes =>
       override def consumed = 1
       override def consumedTypes = ObjectReference :: Nil
       override def produced = 1
+
+      override def category = castsCat
     }
 
     /** This class represents a CHECK_CAST instruction
@@ -419,6 +476,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
       override val consumedTypes = List(ObjectReference)
       override def producedTypes = List(typ)
+
+      override def category = castsCat
     }
 
     /** This class represents a SWITCH instruction
@@ -439,6 +498,8 @@ trait Opcodes { self: ICodes =>
       override val consumedTypes = List(INT)
 
       def flatTagsCount: Int = { var acc = 0; var rest = tags; while(rest.nonEmpty) { acc += rest.head.length; rest = rest.tail }; acc } // a one-liner
+
+      override def category = jumpsCat
     }
 
     /** This class represents a JUMP instruction
@@ -451,6 +512,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumed = 0
       override def produced = 0
+
+      override def category = jumpsCat
     }
 
     /** This class represents a CJUMP instruction
@@ -474,6 +537,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 0
 
       override val consumedTypes = List(kind, kind)
+
+      override def category = jumpsCat
     }
 
     /** This class represents a CZJUMP instruction
@@ -495,6 +560,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 0
 
       override val consumedTypes = List(kind)
+
+      override def category = jumpsCat
     }
 
 
@@ -507,6 +574,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 0
 
       // TODO override val consumedTypes = List(kind)
+
+      override def category = retCat
     }
 
     /** This class represents a THROW instruction
@@ -522,6 +591,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumed = 1
       override def produced = 0
+
+      override def category = retCat
     }
 
     /** This class represents a DROP instruction
@@ -534,6 +605,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumed = 1
       override def produced = 0
+
+      override def category = stackCat
     }
 
     /** This class represents a DUP instruction
@@ -543,6 +616,7 @@ trait Opcodes { self: ICodes =>
     case class DUP (typ: TypeKind) extends Instruction {
       override def consumed = 1
       override def produced = 2
+      override def category = stackCat
     }
 
     /** This class represents a MONITOR_ENTER instruction
@@ -555,6 +629,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumed = 1
       override def produced = 0
+
+      override def category = objsCat
     }
 
     /** This class represents a MONITOR_EXIT instruction
@@ -567,6 +643,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumed = 1;
       override def produced = 0;
+
+      override def category = objsCat
     }
 
     /** A local variable becomes visible at this point in code.
@@ -577,6 +655,7 @@ trait Opcodes { self: ICodes =>
       override def toString(): String = "SCOPE_ENTER " + lv
       override def consumed = 0
       override def produced = 0
+      override def category = localsCat
     }
 
     /** A local variable leaves its scope at this point in code.
@@ -587,6 +666,7 @@ trait Opcodes { self: ICodes =>
       override def toString(): String = "SCOPE_EXIT " + lv
       override def consumed = 0
       override def produced = 0
+      override def category = localsCat
     }
 
     /** Fake instruction. It designates the VM who pushes an exception
@@ -598,6 +678,7 @@ trait Opcodes { self: ICodes =>
       override def consumed = sys.error("LOAD_EXCEPTION does clean the whole stack, no idea how many things it consumes!")
       override def produced = 1
       override def producedTypes = REFERENCE(clasz) :: Nil
+      override def category = stackCat
     }
 
     /** This class represents a method invocation style. */
@@ -658,6 +739,8 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def producedTypes = List(msil_mgdptr(local.kind))
+
+      override def category = localsCat
   }
 
     case class CIL_LOAD_FIELD_ADDRESS(field: Symbol, isStatic: Boolean) extends Instruction {
@@ -670,6 +753,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumedTypes = if (isStatic) Nil else List(REFERENCE(field.owner));
       override def producedTypes = List(msil_mgdptr(REFERENCE(field.owner)));
+
+      override def category = fldsCat
 }
 
     case class CIL_LOAD_ARRAY_ITEM_ADDRESS(kind: TypeKind) extends Instruction {
@@ -681,6 +766,8 @@ trait Opcodes { self: ICodes =>
 
       override def consumedTypes = List(ARRAY(kind), INT)
       override def producedTypes = List(msil_mgdptr(kind))
+
+      override def category = arraysCat
     }
 
     case class CIL_UNBOX(valueType: TypeKind) extends Instruction {
@@ -689,6 +776,7 @@ trait Opcodes { self: ICodes =>
       override def consumedTypes = ObjectReference :: Nil // actually consumes a 'boxed valueType'
       override def produced = 1
       override def producedTypes = List(msil_mgdptr(valueType))
+      override def category = objsCat
     }
 
     case class CIL_INITOBJ(valueType: TypeKind) extends Instruction {
@@ -696,6 +784,7 @@ trait Opcodes { self: ICodes =>
       override def consumed = 1
       override def consumedTypes = ObjectReference :: Nil // actually consumes a managed pointer
       override def produced = 0
+      override def category = objsCat
     }
 
     case class CIL_NEWOBJ(method: Symbol) extends Instruction {
@@ -705,6 +794,7 @@ trait Opcodes { self: ICodes =>
       override def consumedTypes = method.tpe.paramTypes map toTypeKind
       override def produced = 1
       override def producedTypes = List(toTypeKind(method.tpe.resultType))
+      override def category = objsCat
     }
 
   }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
index ff68aba845..42921e733d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
@@ -37,7 +37,7 @@ trait BytecodeWriters {
     getFile(outputDirectory(sym), clsName, suffix)
 
   trait BytecodeWriter {
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol): Unit
+    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit
     def close(): Unit = ()
   }
 
@@ -48,7 +48,9 @@ trait BytecodeWriters {
     )
     val writer = new Jar(jfile).jarWriter(jarMainAttrs: _*)
 
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) {
+    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) {
+      assert(outfile == null,
+             "The outfile formal param is there just because ClassBytecodeWriter overrides this method and uses it.")
       val path = jclassName + ".class"
       val out  = writer.newOutputStream(path)
 
@@ -72,21 +74,21 @@ trait BytecodeWriters {
       try javap(Seq("-verbose", "dummy")) foreach (_.show())
       finally pw.close()
     }
-    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) {
-      super.writeClass(label, jclassName, jclassBytes, sym)
+    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) {
+      super.writeClass(label, jclassName, jclassBytes, outfile)
 
-      val bytes     = getFile(sym, jclassName, ".class").toByteArray
       val segments  = jclassName.split("[./]")
       val javapFile = segments.foldLeft(baseDir: Path)(_ / _) changeExtension "javap" toFile;
 
       javapFile.parent.createDirectory()
-      emitJavap(bytes, javapFile)
+      emitJavap(jclassBytes, javapFile)
     }
   }
 
   trait ClassBytecodeWriter extends BytecodeWriter {
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) {
-      val outfile   = getFile(sym, jclassName, ".class")
+    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) {
+      assert(outfile != null,
+             "Precisely this override requires its invoker to hand out a non-null AbstractFile.")
       val outstream = new DataOutputStream(outfile.bufferedOutput)
 
       try outstream.write(jclassBytes, 0, jclassBytes.length)
@@ -98,8 +100,8 @@ trait BytecodeWriters {
   trait DumpBytecodeWriter extends BytecodeWriter {
     val baseDir = Directory(settings.Ydumpclasses.value).createDirectory()
 
-    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) {
-      super.writeClass(label, jclassName, jclassBytes, sym)
+    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) {
+      super.writeClass(label, jclassName, jclassBytes, outfile)
 
       val pathName = jclassName
       var dumpFile = pathName.split("[./]").foldLeft(baseDir: Path) (_ / _) changeExtension "class" toFile;
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 59adcc637a..5ab8a3d751 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -29,6 +29,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 

   val phaseName = "jvm"

 

+  case class WorkUnit(label: String, jclassName: String, jclass: asm.ClassWriter, outF: AbstractFile)

+

+  type WorkUnitQueue = _root_.java.util.concurrent.LinkedBlockingQueue[WorkUnit]

+

   /** Create a new phase */

   override def newPhase(p: Phase): Phase = new AsmPhase(p)

 

@@ -148,6 +152,44 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
       }

     }

 

+    // -----------------------------------------------------------------------------------------

+    // Allow overlapping disk write of classfiles with building of the next classfiles.

+    // -----------------------------------------------------------------------------------------

+

+    val q = new WorkUnitQueue(500)

+

+    class WriteTask(bytecodeWriter: BytecodeWriter) extends _root_.java.lang.Runnable {

+

+      def run() {

+        var stop = false

+        try {

+          while (!stop) {

+            val WorkUnit(label, jclassName, jclass, outF) = q.take

+            if(jclass eq null) { stop = true }

+            else { writeIfNotTooBig(label, jclassName, jclass, outF) }

+          }

+        } catch {

+          case ex: InterruptedException => throw ex

+        }

+      }

+

+      private def writeIfNotTooBig(label: String, jclassName: String, jclass: asm.ClassWriter, outF: AbstractFile) {

+        try {

+          val arr = jclass.toByteArray()

+          bytecodeWriter.writeClass(label, jclassName, arr, outF)

+        } catch {

+          case e: java.lang.RuntimeException if(e.getMessage() == "Class file too large!") =>

+            // TODO check where ASM throws the equivalent of CodeSizeTooBigException

+            log("Skipped class "+jclassName+" because it exceeds JVM limits (it's too big or has methods that are too long).")

+        }

+      }

+

+    }

+

+    // -----------------------------------------------------------------------------------------

+    // what AsmPhase does.

+    // -----------------------------------------------------------------------------------------

+

     override def run() {

 

       if (settings.debug.value)

@@ -161,10 +203,14 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
       var sortedClasses = classes.values.toList sortBy ("" + _.symbol.fullName)

 

       debuglog("Created new bytecode generator for " + classes.size + " classes.")

-      val bytecodeWriter  = initBytecodeWriter(sortedClasses filter isJavaEntryPoint)

-      val plainCodeGen    = new JPlainBuilder(bytecodeWriter)

-      val mirrorCodeGen   = new JMirrorBuilder(bytecodeWriter)

-      val beanInfoCodeGen = new JBeanInfoBuilder(bytecodeWriter)

+      val bytecodeWriter        = initBytecodeWriter(sortedClasses filter isJavaEntryPoint)

+      val needsOutfileForSymbol = bytecodeWriter.isInstanceOf[ClassBytecodeWriter]

+

+      val plainCodeGen    = new JPlainBuilder(q, needsOutfileForSymbol)

+      val mirrorCodeGen   = new JMirrorBuilder(q, needsOutfileForSymbol)

+      val beanInfoCodeGen = new JBeanInfoBuilder(q, needsOutfileForSymbol)

+

+      new _root_.java.lang.Thread(new WriteTask(bytecodeWriter)).start()

 

       while(!sortedClasses.isEmpty) {

         val c = sortedClasses.head

@@ -187,6 +233,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
         classes -= c.symbol // GC opportunity

       }

 

+      q put WorkUnit(null, null, null, null)

+

+      while(!q.isEmpty) { _root_.java.lang.Thread.sleep(10) }

+

       bytecodeWriter.close()

       classes.clear()

       reverseJavaName.clear()

@@ -448,7 +498,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
   val JAVA_LANG_STRING = asm.Type.getObjectType("java/lang/String")

 

   /** basic functionality for class file building */

-  abstract class JBuilder(bytecodeWriter: BytecodeWriter) {

+  abstract class JBuilder(wuQ: WorkUnitQueue, needsOutfileForSymbol: Boolean) {

 

     val EMPTY_JTYPE_ARRAY  = Array.empty[asm.Type]

     val EMPTY_STRING_ARRAY = Array.empty[String]

@@ -504,17 +554,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
     // utitilies useful when emitting plain, mirror, and beaninfo classes.

     // -----------------------------------------------------------------------------------------

 

-    def writeIfNotTooBig(label: String, jclassName: String, jclass: asm.ClassWriter, sym: Symbol) {

-      try {

-        val arr = jclass.toByteArray()

-        bytecodeWriter.writeClass(label, jclassName, arr, sym)

-      } catch {

-        case e: java.lang.RuntimeException if(e.getMessage() == "Class file too large!") =>

-          // TODO check where ASM throws the equivalent of CodeSizeTooBigException

-          log("Skipped class "+jclassName+" because it exceeds JVM limits (it's too big or has methods that are too long).")

-      }

-    }

-

     /** Specialized array conversion to prevent calling

      *  java.lang.reflect.Array.newInstance via TraversableOnce.toArray

      */

@@ -728,11 +767,18 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
       }

     }

 

+    def enqueue(label: String, jclassName: String, jclass: asm.ClassWriter, sym: Symbol) {

+      val outF: scala.tools.nsc.io.AbstractFile = {

+        if(needsOutfileForSymbol) getFile(sym, jclassName, ".class") else null

+      }

+      wuQ put WorkUnit(label, jclassName, jclass, outF)

+    }

+

   } // end of class JBuilder

 

 

   /** functionality for building plain and mirror classes */

-  abstract class JCommonBuilder(bytecodeWriter: BytecodeWriter) extends JBuilder(bytecodeWriter) {

+  abstract class JCommonBuilder(wuQ: WorkUnitQueue, needsOutfileForSymbol: Boolean) extends JBuilder(wuQ, needsOutfileForSymbol) {

 

     // -----------------------------------------------------------------------------------------

     // more constants

@@ -1290,8 +1336,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
   case class BlockInteval(start: BasicBlock, end: BasicBlock)

 

   /** builder of plain classes */

-  class JPlainBuilder(bytecodeWriter: BytecodeWriter)

-    extends JCommonBuilder(bytecodeWriter)

+  class JPlainBuilder(wuQ: WorkUnitQueue, needsOutfileForSymbol: Boolean)

+    extends JCommonBuilder(wuQ, needsOutfileForSymbol)

     with    JAndroidBuilder {

 

     val MIN_SWITCH_DENSITY = 0.7

@@ -1445,7 +1491,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 

       addInnerClasses(clasz.symbol, jclass)

       jclass.visitEnd()

-      writeIfNotTooBig("" + c.symbol.name, thisName, jclass, c.symbol)

+      enqueue("" + c.symbol.name, thisName, jclass, c.symbol)

 

     }

 

@@ -2366,251 +2412,269 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
             }

           }

 

-          instr match {

-            case THIS(_)               => jmethod.visitVarInsn(Opcodes.ALOAD, 0)

-

-            case CONSTANT(const)       => genConstant(jmethod, const)

-

-            case LOAD_ARRAY_ITEM(kind) => jcode.aload(kind)

-

-            case LOAD_LOCAL(local)     => jcode.load(indexOf(local), local.kind)

-

-            case lf @ LOAD_FIELD(field, isStatic) =>

-              var owner = javaName(lf.hostClass)

-              debuglog("LOAD_FIELD with owner: " + owner + " flags: " + Flags.flagsToString(field.owner.flags))

-              val fieldJName = javaName(field)

-              val fieldDescr = descriptor(field)

-              val opc = if (isStatic) Opcodes.GETSTATIC else Opcodes.GETFIELD

-              jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)

-

-            case LOAD_MODULE(module) =>

-              // assert(module.isModule, "Expected module: " + module)

-              debuglog("generating LOAD_MODULE for: " + module + " flags: " + Flags.flagsToString(module.flags));

-              if (clasz.symbol == module.moduleClass && jMethodName != nme.readResolve.toString) {

-                jmethod.visitVarInsn(Opcodes.ALOAD, 0)

-              } else {

-                jmethod.visitFieldInsn(

-                  Opcodes.GETSTATIC,

-                  javaName(module) /* + "$" */ ,

-                  strMODULE_INSTANCE_FIELD,

-                  descriptor(module)

-                )

-              }

+          (instr.category: @scala.annotation.switch) match {

+

+            case icodes.localsCat => (instr: @unchecked) match {

+                case THIS(_)            => jmethod.visitVarInsn(Opcodes.ALOAD, 0)

+                case LOAD_LOCAL(local)  => jcode.load(indexOf(local), local.kind)

+                case STORE_LOCAL(local) => jcode.store(indexOf(local), local.kind)

+                case STORE_THIS(_)      =>

+                  // this only works for impl classes because the self parameter comes first

+                  // in the method signature. If that changes, this code has to be revisited.

+                  jmethod.visitVarInsn(Opcodes.ASTORE, 0)

+

+                case SCOPE_ENTER(lv) =>

+                  // locals removed by closelim (via CopyPropagation) may have left behind SCOPE_ENTER, SCOPE_EXIT that are to be ignored

+                  val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))

+                  if(relevant) { // TODO check: does GenICode emit SCOPE_ENTER, SCOPE_EXIT for synthetic vars?

+                    // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)

+                    // similarly, these labels aren't tracked in the `labels` map.

+                    val start = new asm.Label

+                    jmethod.visitLabel(start)

+                    scoping.pushScope(lv, start)

+                  }

+

+                case SCOPE_EXIT(lv) =>

+                  val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))

+                  if(relevant) {

+                    // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)

+                    // similarly, these labels aren't tracked in the `labels` map.

+                    val end = new asm.Label

+                    jmethod.visitLabel(end)

+                    scoping.popScope(lv, end)

+                  }

+            }

 

-            case STORE_ARRAY_ITEM(kind) => jcode.astore(kind)

+            case icodes.stackCat => (instr: @unchecked) match {

 

-            case STORE_LOCAL(local) => jcode.store(indexOf(local), local.kind)

+              case LOAD_MODULE(module) =>

+                // assert(module.isModule, "Expected module: " + module)

+                debuglog("generating LOAD_MODULE for: " + module + " flags: " + Flags.flagsToString(module.flags));

+                if (clasz.symbol == module.moduleClass && jMethodName != nme.readResolve.toString) {

+                  jmethod.visitVarInsn(Opcodes.ALOAD, 0)

+                } else {

+                  jmethod.visitFieldInsn(

+                    Opcodes.GETSTATIC,

+                    javaName(module) /* + "$" */ ,

+                    strMODULE_INSTANCE_FIELD,

+                    descriptor(module)

+                  )

+                }

 

-            case STORE_THIS(_) =>

-              // this only works for impl classes because the self parameter comes first

-              // in the method signature. If that changes, this code has to be revisited.

-              jmethod.visitVarInsn(Opcodes.ASTORE, 0)

+              case DROP(kind)   => emit(if(kind.isWideType) Opcodes.POP2 else Opcodes.POP)

 

-            case STORE_FIELD(field, isStatic) =>

-              val owner = javaName(field.owner)

-              val fieldJName = javaName(field)

-              val fieldDescr = descriptor(field)

-              val opc = if (isStatic) Opcodes.PUTSTATIC else Opcodes.PUTFIELD

-              jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)

+              case DUP(kind)    => emit(if(kind.isWideType) Opcodes.DUP2 else Opcodes.DUP)

 

-            case CALL_PRIMITIVE(primitive) => genPrimitive(primitive, instr.pos)

+              case LOAD_EXCEPTION(_) => ()

+            }

 

-            /** Special handling to access native Array.clone() */

-            case call @ CALL_METHOD(definitions.Array_clone, Dynamic) =>

-              val target: String = javaType(call.targetTypeKind).getInternalName

-              jcode.invokevirtual(target, "clone", mdesc_arrayClone)

+            case icodes.constCat => genConstant(jmethod, instr.asInstanceOf[CONSTANT].constant)

 

-            case call @ CALL_METHOD(method, style) => genCallMethod(call)

+            case icodes.arilogCat => genPrimitive(instr.asInstanceOf[CALL_PRIMITIVE].primitive, instr.pos)

 

-            case BOX(kind) =>

-              val MethodNameAndType(mname, mdesc) = jBoxTo(kind)

-              jcode.invokestatic(BoxesRunTime, mname, mdesc)

+            case icodes.castsCat => (instr: @unchecked) match {

 

-            case UNBOX(kind) =>

-              val MethodNameAndType(mname, mdesc) = jUnboxTo(kind)

-              jcode.invokestatic(BoxesRunTime, mname, mdesc)

+              case IS_INSTANCE(tpe) =>

+                val jtyp: asm.Type =

+                  tpe match {

+                    case REFERENCE(cls) => asm.Type.getObjectType(javaName(cls))

+                    case ARRAY(elem)    => javaArrayType(javaType(elem))

+                    case _              => abort("Unknown reference type in IS_INSTANCE: " + tpe)

+                  }

+                jmethod.visitTypeInsn(Opcodes.INSTANCEOF, jtyp.getInternalName)

 

-            case NEW(REFERENCE(cls)) =>

-              val className = javaName(cls)

-              jmethod.visitTypeInsn(Opcodes.NEW, className)

+              case CHECK_CAST(tpe) =>

+                tpe match {

 

-            case CREATE_ARRAY(elem, 1) => jcode newarray elem

+                  case REFERENCE(cls) =>

+                    if (cls != ObjectClass) { // No need to checkcast for Objects

+                      jmethod.visitTypeInsn(Opcodes.CHECKCAST, javaName(cls))

+                    }

 

-            case CREATE_ARRAY(elem, dims) =>

-              jmethod.visitMultiANewArrayInsn(descriptor(ArrayN(elem, dims)), dims)

+                  case ARRAY(elem)    =>

+                    val iname = javaArrayType(javaType(elem)).getInternalName

+                    jmethod.visitTypeInsn(Opcodes.CHECKCAST, iname)

 

-            case IS_INSTANCE(tpe) =>

-              val jtyp: asm.Type =

-                tpe match {

-                  case REFERENCE(cls) => asm.Type.getObjectType(javaName(cls))

-                  case ARRAY(elem)    => javaArrayType(javaType(elem))

                   case _              => abort("Unknown reference type in IS_INSTANCE: " + tpe)

                 }

-              jmethod.visitTypeInsn(Opcodes.INSTANCEOF, jtyp.getInternalName)

 

-            case CHECK_CAST(tpe) =>

-              tpe match {

+            }

 

-                case REFERENCE(cls) =>

-                  if (cls != ObjectClass) { // No need to checkcast for Objects

-                    jmethod.visitTypeInsn(Opcodes.CHECKCAST, javaName(cls))

-                  }

+            case icodes.objsCat  => (instr: @unchecked) match {

 

-                case ARRAY(elem)    =>

-                  val iname = javaArrayType(javaType(elem)).getInternalName

-                  jmethod.visitTypeInsn(Opcodes.CHECKCAST, iname)

+              case BOX(kind) =>

+                val MethodNameAndType(mname, mdesc) = jBoxTo(kind)

+                jcode.invokestatic(BoxesRunTime, mname, mdesc)

 

-                case _              => abort("Unknown reference type in IS_INSTANCE: " + tpe)

-              }

+              case UNBOX(kind) =>

+                val MethodNameAndType(mname, mdesc) = jUnboxTo(kind)

+                jcode.invokestatic(BoxesRunTime, mname, mdesc)

 

-            case sw @ SWITCH(tagss, branches) =>

-              assert(branches.length == tagss.length + 1, sw)

-              val flatSize     = sw.flatTagsCount

-              val flatKeys     = new Array[Int](flatSize)

-              val flatBranches = new Array[asm.Label](flatSize)

-

-              var restTagss    = tagss

-              var restBranches = branches

-              var k = 0 // ranges over flatKeys and flatBranches

-              while(restTagss.nonEmpty) {

-                val currLabel = labels(restBranches.head)

-                for(cTag <- restTagss.head) {

-                  flatKeys(k)     = cTag;

-                  flatBranches(k) = currLabel

-                  k += 1

-                }

-                restTagss    = restTagss.tail

-                restBranches = restBranches.tail

-              }

-              val defaultLabel = labels(restBranches.head)

-              assert(restBranches.tail.isEmpty)

-              debuglog("Emitting SWITCH:\ntags: " + tagss + "\nbranches: " + branches)

-              jcode.emitSWITCH(flatKeys, flatBranches, defaultLabel, MIN_SWITCH_DENSITY)

-

-            case JUMP(whereto) =>

-              if (nextBlock != whereto) {

-                jcode goTo labels(whereto)

-              }

+              case NEW(REFERENCE(cls)) =>

+                val className = javaName(cls)

+                jmethod.visitTypeInsn(Opcodes.NEW, className)

 

-            case CJUMP(success, failure, cond, kind) =>

-              if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT

-                if (nextBlock == success) {

-                  jcode.emitIF_ICMP(cond.negate, labels(failure))

-                  // .. and fall through to success label

-                } else {

-                  jcode.emitIF_ICMP(cond, labels(success))

-                  if (nextBlock != failure) { jcode goTo labels(failure) }

-                }

-              } else if(kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)

-                if (nextBlock == success) {

-                  jcode.emitIF_ACMP(cond.negate, labels(failure))

-                  // .. and fall through to success label

-                } else {

-                  jcode.emitIF_ACMP(cond, labels(success))

-                  if (nextBlock != failure) { jcode goTo labels(failure) }

-                }

-              } else {

-                (kind: @unchecked) match {

-                  case LONG   => emit(Opcodes.LCMP)

-                  case FLOAT  =>

-                    if (cond == LT || cond == LE) emit(Opcodes.FCMPG)

-                    else emit(Opcodes.FCMPL)

-                  case DOUBLE =>

-                    if (cond == LT || cond == LE) emit(Opcodes.DCMPG)

-                    else emit(Opcodes.DCMPL)

-                }

-                if (nextBlock == success) {

-                  jcode.emitIF(cond.negate, labels(failure))

-                  // .. and fall through to success label

-                } else {

-                  jcode.emitIF(cond, labels(success))

-                  if (nextBlock != failure) { jcode goTo labels(failure) }

-                }

-              }

+              case MONITOR_ENTER() => emit(Opcodes.MONITORENTER)

+              case MONITOR_EXIT()  => emit(Opcodes.MONITOREXIT)

+            }

 

-            case CZJUMP(success, failure, cond, kind) =>

-              if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT

-                if (nextBlock == success) {

-                  jcode.emitIF(cond.negate, labels(failure))

-                } else {

-                  jcode.emitIF(cond, labels(success))

-                  if (nextBlock != failure) { jcode goTo labels(failure) }

-                }

-              } else if(kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)

-                val Success = success

-                val Failure = failure

-                // @unchecked because references aren't compared with GT, GE, LT, LE.

-                ((cond, nextBlock) : @unchecked) match {

-                  case (EQ, Success) => jcode emitIFNONNULL labels(failure)

-                  case (NE, Failure) => jcode emitIFNONNULL labels(success)

-                  case (EQ, Failure) => jcode emitIFNULL    labels(success)

-                  case (NE, Success) => jcode emitIFNULL    labels(failure)

-                  case (EQ, _) =>

-                    jcode emitIFNULL labels(success)

-                    jcode goTo labels(failure)

-                  case (NE, _) =>

-                    jcode emitIFNONNULL labels(success)

-                    jcode goTo labels(failure)

-                }

-              } else {

-                (kind: @unchecked) match {

-                  case LONG   =>

-                    emit(Opcodes.LCONST_0)

-                    emit(Opcodes.LCMP)

-                  case FLOAT  =>

-                    emit(Opcodes.FCONST_0)

-                    if (cond == LT || cond == LE) emit(Opcodes.FCMPG)

-                    else emit(Opcodes.FCMPL)

-                  case DOUBLE =>

-                    emit(Opcodes.DCONST_0)

-                    if (cond == LT || cond == LE) emit(Opcodes.DCMPG)

-                    else emit(Opcodes.DCMPL)

-                }

-                if (nextBlock == success) {

-                  jcode.emitIF(cond.negate, labels(failure))

-                } else {

-                  jcode.emitIF(cond, labels(success))

-                  if (nextBlock != failure) { jcode goTo labels(failure) }

-                }

-              }

+            case icodes.fldsCat  => (instr: @unchecked) match {

 

-            case RETURN(kind) => jcode emitRETURN kind

+              case lf @ LOAD_FIELD(field, isStatic) =>

+                var owner = javaName(lf.hostClass)

+                debuglog("LOAD_FIELD with owner: " + owner + " flags: " + Flags.flagsToString(field.owner.flags))

+                val fieldJName = javaName(field)

+                val fieldDescr = descriptor(field)

+                val opc = if (isStatic) Opcodes.GETSTATIC else Opcodes.GETFIELD

+                jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)

 

-            case THROW(_)     => emit(Opcodes.ATHROW)

+              case STORE_FIELD(field, isStatic) =>

+                val owner = javaName(field.owner)

+                val fieldJName = javaName(field)

+                val fieldDescr = descriptor(field)

+                val opc = if (isStatic) Opcodes.PUTSTATIC else Opcodes.PUTFIELD

+                jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)

 

-            case DROP(kind)   =>

-              emit(if(kind.isWideType) Opcodes.POP2 else Opcodes.POP)

+            }

 

-            case DUP(kind)    =>

-              emit(if(kind.isWideType) Opcodes.DUP2 else Opcodes.DUP)

+            case icodes.mthdsCat => (instr: @unchecked) match {

 

-            case MONITOR_ENTER() => emit(Opcodes.MONITORENTER)

+              /** Special handling to access native Array.clone() */

+              case call @ CALL_METHOD(definitions.Array_clone, Dynamic) =>

+                val target: String = javaType(call.targetTypeKind).getInternalName

+                jcode.invokevirtual(target, "clone", mdesc_arrayClone)

 

-            case MONITOR_EXIT()  => emit(Opcodes.MONITOREXIT)

+              case call @ CALL_METHOD(method, style) => genCallMethod(call)

 

-            case SCOPE_ENTER(lv) =>

-              // locals removed by closelim (via CopyPropagation) may have left behind SCOPE_ENTER, SCOPE_EXIT that are to be ignored

-              val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))

-              if(relevant) { // TODO check: does GenICode emit SCOPE_ENTER, SCOPE_EXIT for synthetic vars?

-                // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)

-                // similarly, these labels aren't tracked in the `labels` map.

-                val start = new asm.Label

-                jmethod.visitLabel(start)

-                scoping.pushScope(lv, start)

-              }

+            }

 

-            case SCOPE_EXIT(lv) =>

-              val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))

-              if(relevant) {

-                // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)

-                // similarly, these labels aren't tracked in the `labels` map.

-                val end = new asm.Label

-                jmethod.visitLabel(end)

-                scoping.popScope(lv, end)

-              }

+            case icodes.arraysCat => (instr: @unchecked) match {

+              case LOAD_ARRAY_ITEM(kind)    => jcode.aload(kind)

+              case STORE_ARRAY_ITEM(kind)   => jcode.astore(kind)

+              case CREATE_ARRAY(elem, 1)    => jcode newarray elem

+              case CREATE_ARRAY(elem, dims) => jmethod.visitMultiANewArrayInsn(descriptor(ArrayN(elem, dims)), dims)

+            }

+

+            case icodes.jumpsCat => (instr: @unchecked) match {

+

+              case sw @ SWITCH(tagss, branches) =>

+                assert(branches.length == tagss.length + 1, sw)

+                val flatSize     = sw.flatTagsCount

+                val flatKeys     = new Array[Int](flatSize)

+                val flatBranches = new Array[asm.Label](flatSize)

+

+                var restTagss    = tagss

+                var restBranches = branches

+                var k = 0 // ranges over flatKeys and flatBranches

+                while(restTagss.nonEmpty) {

+                  val currLabel = labels(restBranches.head)

+                  for(cTag <- restTagss.head) {

+                    flatKeys(k)     = cTag;

+                    flatBranches(k) = currLabel

+                    k += 1

+                  }

+                  restTagss    = restTagss.tail

+                  restBranches = restBranches.tail

+                }

+                val defaultLabel = labels(restBranches.head)

+                assert(restBranches.tail.isEmpty)

+                debuglog("Emitting SWITCH:\ntags: " + tagss + "\nbranches: " + branches)

+                jcode.emitSWITCH(flatKeys, flatBranches, defaultLabel, MIN_SWITCH_DENSITY)

+

+              case JUMP(whereto) =>

+                if (nextBlock != whereto) {

+                  jcode goTo labels(whereto)

+                }

+

+              case CJUMP(success, failure, cond, kind) =>

+                if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT

+                  if (nextBlock == success) {

+                    jcode.emitIF_ICMP(cond.negate, labels(failure))

+                    // .. and fall through to success label

+                  } else {

+                    jcode.emitIF_ICMP(cond, labels(success))

+                    if (nextBlock != failure) { jcode goTo labels(failure) }

+                  }

+                } else if(kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)

+                  if (nextBlock == success) {

+                    jcode.emitIF_ACMP(cond.negate, labels(failure))

+                    // .. and fall through to success label

+                  } else {

+                    jcode.emitIF_ACMP(cond, labels(success))

+                    if (nextBlock != failure) { jcode goTo labels(failure) }

+                  }

+                } else {

+                  (kind: @unchecked) match {

+                    case LONG   => emit(Opcodes.LCMP)

+                    case FLOAT  =>

+                      if (cond == LT || cond == LE) emit(Opcodes.FCMPG)

+                      else emit(Opcodes.FCMPL)

+                    case DOUBLE =>

+                      if (cond == LT || cond == LE) emit(Opcodes.DCMPG)

+                      else emit(Opcodes.DCMPL)

+                  }

+                  if (nextBlock == success) {

+                    jcode.emitIF(cond.negate, labels(failure))

+                    // .. and fall through to success label

+                  } else {

+                    jcode.emitIF(cond, labels(success))

+                    if (nextBlock != failure) { jcode goTo labels(failure) }

+                  }

+                }

+

+              case CZJUMP(success, failure, cond, kind) =>

+                if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT

+                  if (nextBlock == success) {

+                    jcode.emitIF(cond.negate, labels(failure))

+                  } else {

+                    jcode.emitIF(cond, labels(success))

+                    if (nextBlock != failure) { jcode goTo labels(failure) }

+                  }

+                } else if(kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)

+                  val Success = success

+                  val Failure = failure

+                  // @unchecked because references aren't compared with GT, GE, LT, LE.

+                  ((cond, nextBlock) : @unchecked) match {

+                    case (EQ, Success) => jcode emitIFNONNULL labels(failure)

+                    case (NE, Failure) => jcode emitIFNONNULL labels(success)

+                    case (EQ, Failure) => jcode emitIFNULL    labels(success)

+                    case (NE, Success) => jcode emitIFNULL    labels(failure)

+                    case (EQ, _) =>

+                      jcode emitIFNULL labels(success)

+                      jcode goTo labels(failure)

+                    case (NE, _) =>

+                      jcode emitIFNONNULL labels(success)

+                      jcode goTo labels(failure)

+                  }

+                } else {

+                  (kind: @unchecked) match {

+                    case LONG   =>

+                      emit(Opcodes.LCONST_0)

+                      emit(Opcodes.LCMP)

+                    case FLOAT  =>

+                      emit(Opcodes.FCONST_0)

+                      if (cond == LT || cond == LE) emit(Opcodes.FCMPG)

+                      else emit(Opcodes.FCMPL)

+                    case DOUBLE =>

+                      emit(Opcodes.DCONST_0)

+                      if (cond == LT || cond == LE) emit(Opcodes.DCMPG)

+                      else emit(Opcodes.DCMPL)

+                  }

+                  if (nextBlock == success) {

+                    jcode.emitIF(cond.negate, labels(failure))

+                  } else {

+                    jcode.emitIF(cond, labels(success))

+                    if (nextBlock != failure) { jcode goTo labels(failure) }

+                  }

+                }

+

+            }

+

+            case icodes.retCat   => (instr: @unchecked) match {

+              case RETURN(kind) => jcode emitRETURN kind

+              case THROW(_)     => emit(Opcodes.ATHROW)

+            }

 

-            case LOAD_EXCEPTION(_) =>

-              ()

           }

 

         }

@@ -2863,7 +2927,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 

 

   /** builder of mirror classes */

-  class JMirrorBuilder(bytecodeWriter: BytecodeWriter) extends JCommonBuilder(bytecodeWriter) {

+  class JMirrorBuilder(wuQ: WorkUnitQueue, needsOutfileForSymbol: Boolean) extends JCommonBuilder(wuQ, needsOutfileForSymbol) {

 

     private var cunit: CompilationUnit = _

     def getCurrentCUnit(): CompilationUnit = cunit;

@@ -2907,7 +2971,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 

       addInnerClasses(modsym, mirrorClass)

       mirrorClass.visitEnd()

-      writeIfNotTooBig("" + modsym.name, mirrorName, mirrorClass, modsym)

+      enqueue("" + modsym.name, mirrorName, mirrorClass, modsym)

     }

 

 

@@ -2915,7 +2979,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 

 

   /** builder of bean info classes */

-  class JBeanInfoBuilder(bytecodeWriter: BytecodeWriter) extends JBuilder(bytecodeWriter) {

+  class JBeanInfoBuilder(wuQ: WorkUnitQueue, needsOutfileForSymbol: Boolean) extends JBuilder(wuQ, needsOutfileForSymbol) {

 

     /**

      * Generate a bean info class that describes the given class.

@@ -3036,7 +3100,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
       addInnerClasses(clasz.symbol, beanInfoClass)

       beanInfoClass.visitEnd()

 

-      writeIfNotTooBig("BeanInfo ", beanInfoName, beanInfoClass, clasz.symbol)

+      enqueue("BeanInfo ", beanInfoName, beanInfoClass, clasz.symbol)

     }

 

   } // end of class JBeanInfoBuilder

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 21260d399c..ad054015ef 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -183,7 +183,6 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
   class BytecodeGenerator(bytecodeWriter: BytecodeWriter) extends BytecodeUtil {
     def this() = this(new ClassBytecodeWriter { })
     def debugLevel = settings.debuginfo.indexOfChoice
-    import bytecodeWriter.writeClass
 
     val MIN_SWITCH_DENSITY = 0.7
     val INNER_CLASSES_FLAGS =
@@ -344,6 +343,15 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
       writeClass("" + sym.name, jclass.getName(), toByteArray(jclass), sym)
     }
 
+    val needsOutfileForSymbol = bytecodeWriter.isInstanceOf[ClassBytecodeWriter]
+
+    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) {
+      val outF: scala.tools.nsc.io.AbstractFile = {
+        if(needsOutfileForSymbol) getFile(sym, jclassName, ".class") else null
+      }
+      bytecodeWriter.writeClass(label, jclassName, jclassBytes, outF)
+    }
+
     /** Returns the ScalaSignature annotation if it must be added to this class,
      *  none otherwise; furthermore, it adds to `jclass` the ScalaSig marker
      *  attribute (marking that a scala signature annotation is present) or the