BasicBlock

Instance Constructors

new BasicBlock(label: Int, method: ICodes.IMethod)

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to StringAdd performed by method any2stringadd in scala.Predef.
Definition Classes
StringAdd
def ->[B](y: B): (ICodes.BasicBlock, B)

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to ArrowAssoc[ICodes.BasicBlock] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def apply(n: Int): ICodes.Instruction

Return the n-th instruction.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def blockContents: String
def clear(): Unit
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def close(): Unit

Close the block
def closeWith(instr: ICodes.Instruction, pos: Position): Unit
def closeWith(instr: ICodes.Instruction): Unit

do nothing if block is already closed
def closed: Boolean

Is this block closed?
def closed_=(b: Boolean): Unit
def code: ICodes.Code
def directSuccessors: List[ICodes.BasicBlock]
def emit(is: Seq[ICodes.Instruction]): Unit
def emit(instr: ICodes.Instruction, pos: Position): Unit

Emitting does not set touched to true.
Emitting does not set touched to true. During code generation this is a hotspot and setting the flag for each emit is a waste. Caching should happen only after a block is closed, which sets the DIRTYSUCCS flag.
def emit(instr: ICodes.Instruction): Unit

Add a new instruction at the end of the block, using the same source position as the last emitted instruction
def emitOnly(is: ICodes.Instruction*): Unit

The semantics of this are a little odd but it's designed to work seamlessly with the existing code.
The semantics of this are a little odd but it's designed to work seamlessly with the existing code. It emits each supplied instruction, then closes the block. The odd part is that if the instruction has pos == NoPosition, it calls the 1-arg emit, but otherwise it calls the 2-arg emit. This way I could retain existing behavior exactly by calling setPos on any instruction using the two arg version which I wanted to include in a call to emitOnly.
def ensuring(cond: (ICodes.BasicBlock) ⇒ Boolean, msg: ⇒ Any): ICodes.BasicBlock

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to Ensuring[ICodes.BasicBlock] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (ICodes.BasicBlock) ⇒ Boolean): ICodes.BasicBlock

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to Ensuring[ICodes.BasicBlock] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): ICodes.BasicBlock

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to Ensuring[ICodes.BasicBlock] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): ICodes.BasicBlock

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to Ensuring[ICodes.BasicBlock] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def enterIgnoreMode(): Unit

Enter ignore mode: new 'emit'ted instructions will not be added to this basic block.
Enter ignore mode: new 'emit'ted instructions will not be added to this basic block. It makes the generation of THROW and RETURNs easier.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(other: Any): Boolean

Definition Classes
BasicBlock → AnyRef → Any
def exceptionHandlerStart: Boolean

Is this block the start block of an exception handler?
Is this block the start block of an exception handler?

Definition Classes
BasicBlock → ProgramPoint
def exceptionHandlerStart_=(b: Boolean): Unit
def exceptionSuccessors: List[ICodes.BasicBlock]
def exceptionSuccessorsForBlock(block: ICodes.BasicBlock): List[ICodes.BasicBlock]
def exitIgnoreMode(): Unit
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def firstInstruction: ICodes.Instruction
def flagsString: String
final def foreach[U](f: (ICodes.Instruction) ⇒ U): Unit

Apply a function to all the instructions of the block.
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to StringFormat performed by method any2stringfmt in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def fromList(is: List[ICodes.Instruction]): Unit
def fullString: String
def getArray: Array[ICodes.Instruction]

return the underlying array of instructions
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hasFlag(flag: Int): Boolean

Does this block have the given flag?
def hashCode(): Int

Definition Classes
BasicBlock → AnyRef → Any
def ignore: Boolean

When set, the emit methods will be ignored.
def ignore_=(b: Boolean): Unit
def indexOf(inst: ICodes.Instruction): Int

Return the index of inst.
Return the index of inst. Uses reference equality. Returns -1 if not found.
def insertAfter(idx: Int, is: List[ICodes.Instruction]): Unit

Insert instructions in 'is' immediately after index 'idx'.
final def isEmpty: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: Iterator[ICodes.Instruction]

Return an iterator over the instructions in this basic block.
val label: Int
def lastInstruction: ICodes.Instruction

Return the last instruction of this basic block.
def length: Int

The number of instructions in this basic block so far.
def loopHeader: Boolean

Is this block the head of a while?
def loopHeader_=(b: Boolean): Unit
val method: ICodes.IMethod
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def nonEmpty: Boolean
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def open(): Unit
def predContents: String
def predecessors: List[ICodes.BasicBlock]

Returns the predecessors of this block.
Returns the predecessors of this block.

Definition Classes
BasicBlock → ProgramPoint
var preds: List[ICodes.BasicBlock]

Cached predecessors.
def print(out: PrintStream): Unit
def print(): Unit
def removeInstructionsAt(positions: Int*): Unit

Removes instructions found at the given positions.
Removes instructions found at the given positions.
positions
...
def removeLastInstruction(): Unit

Remove the last instruction of this basic block.
Remove the last instruction of this basic block. It is fast for an open block, but slower when the block is closed.
def replaceInstruction(oldInstr: ICodes.Instruction, is: List[ICodes.Instruction]): Boolean

Replaces oldInstr with is.
Replaces oldInstr with is. It does not update the position field in the newly inserted instructions, so it behaves differently than the one-instruction versions of this function.
is
..
returns
..
def replaceInstruction(oldInstr: ICodes.Instruction, newInstr: ICodes.Instruction): Boolean

Replace the given instruction with the new one.
Replace the given instruction with the new one. Returns true if it actually changed something. The replacing instruction is given the nsc.util.Position of the instruction it replaces.
def replaceInstruction(pos: Int, instr: ICodes.Instruction): Boolean

Replace the instruction at the given position.
Replace the instruction at the given position. Used by labels when they are anchored. The replacing instruction is given the nsc.util.Position of the instruction it replaces.
def size: Int
def subst(map: Map[ICodes.Instruction, ICodes.Instruction]): Unit

Replaces all instructions found in the map.
Replaces all instructions found in the map.
map
...
def succContents: String
def successors: List[ICodes.BasicBlock]

Definition Classes
BasicBlock → ProgramPoint
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Seq[ICodes.Instruction]
def toList: List[ICodes.Instruction]
def toString(): String

Definition Classes
BasicBlock → AnyRef → Any
def touched: Boolean

Has this basic block been modified since the last call to 'successors'?
def touched_=(b: Boolean): Unit
val varsInScope: Set[ICodes.Local]

Local variables that are in scope at entry of this basic block.
Local variables that are in scope at entry of this basic block. Used for debugging information.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
def →[B](y: B): (ICodes.BasicBlock, B)

Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to ArrowAssoc[ICodes.BasicBlock] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implict Value Members

val self: Any
Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to StringAdd performed by method any2stringadd in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(basicBlock: StringAdd).self
Definition Classes
StringAdd
val self: Any
Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to StringFormat performed by method any2stringfmt in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(basicBlock: StringFormat).self
Definition Classes
StringFormat

Deprecated Value Members

def x: ICodes.BasicBlock
Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to ArrowAssoc[ICodes.BasicBlock] performed by method any2ArrowAssoc in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(basicBlock: ArrowAssoc[ICodes.BasicBlock]).x
Definition Classes
ArrowAssoc
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use leftOfArrow instead
def x: ICodes.BasicBlock
Implicit information
This member is added by an implicit conversion from ICodes.BasicBlock to Ensuring[ICodes.BasicBlock] performed by method any2Ensuring in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(basicBlock: Ensuring[ICodes.BasicBlock]).x
Definition Classes
Ensuring
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use resultOfEnsuring instead

class BasicBlock extends ProgramPoint[ICodes.BasicBlock]

Instance Constructors

new BasicBlock(label: Int, method: ICodes.IMethod)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (ICodes.BasicBlock, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(n: Int): ICodes.Instruction

final def asInstanceOf[T0]: T0

def blockContents: String

def clear(): Unit

def clone(): AnyRef

def close(): Unit

def closeWith(instr: ICodes.Instruction, pos: Position): Unit

def closeWith(instr: ICodes.Instruction): Unit

def closed: Boolean

def closed_=(b: Boolean): Unit

def code: ICodes.Code

def directSuccessors: List[ICodes.BasicBlock]

def emit(is: Seq[ICodes.Instruction]): Unit

def emit(instr: ICodes.Instruction, pos: Position): Unit

def emit(instr: ICodes.Instruction): Unit

def emitOnly(is: ICodes.Instruction*): Unit

def ensuring(cond: (ICodes.BasicBlock) ⇒ Boolean, msg: ⇒ Any): ICodes.BasicBlock

def ensuring(cond: (ICodes.BasicBlock) ⇒ Boolean): ICodes.BasicBlock

def ensuring(cond: Boolean, msg: ⇒ Any): ICodes.BasicBlock

def ensuring(cond: Boolean): ICodes.BasicBlock

def enterIgnoreMode(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def exceptionHandlerStart: Boolean

def exceptionHandlerStart_=(b: Boolean): Unit

def exceptionSuccessors: List[ICodes.BasicBlock]

def exceptionSuccessorsForBlock(block: ICodes.BasicBlock): List[ICodes.BasicBlock]

def exitIgnoreMode(): Unit

def finalize(): Unit

def firstInstruction: ICodes.Instruction

def flagsString: String

final def foreach[U](f: (ICodes.Instruction) ⇒ U): Unit

def formatted(fmtstr: String): String

def fromList(is: List[ICodes.Instruction]): Unit

def fullString: String

def getArray: Array[ICodes.Instruction]

final def getClass(): Class[_]

def hasFlag(flag: Int): Boolean

def hashCode(): Int

def ignore: Boolean

def ignore_=(b: Boolean): Unit

def indexOf(inst: ICodes.Instruction): Int

def insertAfter(idx: Int, is: List[ICodes.Instruction]): Unit

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[ICodes.Instruction]

val label: Int

def lastInstruction: ICodes.Instruction

def length: Int

def loopHeader: Boolean

def loopHeader_=(b: Boolean): Unit

val method: ICodes.IMethod

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def open(): Unit

def predContents: String

def predecessors: List[ICodes.BasicBlock]

var preds: List[ICodes.BasicBlock]

def print(out: PrintStream): Unit

def print(): Unit

def removeInstructionsAt(positions: Int*): Unit

def removeLastInstruction(): Unit

def replaceInstruction(oldInstr: ICodes.Instruction, is: List[ICodes.Instruction]): Boolean

def replaceInstruction(oldInstr: ICodes.Instruction, newInstr: ICodes.Instruction): Boolean

def replaceInstruction(pos: Int, instr: ICodes.Instruction): Boolean

def size: Int