scala.tools.nsc.backend.icode.BasicBlocks

BasicBlock

class BasicBlock extends ProgramPoint[BasicBlock] with Seq[Instruction]

This class represents a basic block. Each basic block contains a list of instructions that are either executed all, or none. No jumps to/from the "middle" of the basic block are allowed (modulo exceptions).

Source
BasicBlocks.scala
Linear Supertypes
Seq[Instruction], SeqLike[Instruction, Seq[Instruction]], GenSeq[Instruction], GenSeqLike[Instruction, Seq[Instruction]], Iterable[Instruction], IterableLike[Instruction, Seq[Instruction]], Equals, GenIterable[Instruction], GenIterableLike[Instruction, Seq[Instruction]], Traversable[Instruction], GenTraversable[Instruction], GenericTraversableTemplate[Instruction, Seq], TraversableLike[Instruction, Seq[Instruction]], GenTraversableLike[Instruction, Seq[Instruction]], Parallelizable[Instruction, ParSeq[Instruction]], TraversableOnce[Instruction], GenTraversableOnce[Instruction], FilterMonadic[Instruction, Seq[Instruction]], HasNewBuilder[Instruction, Seq[Instruction]], PartialFunction[Int, Instruction], (Int) ⇒ Instruction, ProgramPoint[BasicBlock], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. BasicBlock
  2. Seq
  3. SeqLike
  4. GenSeq
  5. GenSeqLike
  6. Iterable
  7. IterableLike
  8. Equals
  9. GenIterable
  10. GenIterableLike
  11. Traversable
  12. GenTraversable
  13. GenericTraversableTemplate
  14. TraversableLike
  15. GenTraversableLike
  16. Parallelizable
  17. TraversableOnce
  18. GenTraversableOnce
  19. FilterMonadic
  20. HasNewBuilder
  21. PartialFunction
  22. Function1
  23. ProgramPoint
  24. AnyRef
  25. Any
Visibility
  1. Public
  2. All

Instance Constructors

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

Type Members

  1. type Self = Seq[Instruction]

    Attributes
    protected
    Definition Classes
    TraversableLike

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. def ++[B >: Instruction, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike
  5. def ++:[B >: Instruction, That](that: Traversable[B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike
  6. def ++:[B >: Instruction, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike
  7. def +:[B >: Instruction, That](elem: B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  8. def /:[B](z: B)(op: (B, Instruction) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  9. def /:\[A1 >: Instruction](z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
    GenTraversableOnce
  10. def :+[B >: Instruction, That](elem: B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  11. def :\[B](z: B)(op: (Instruction, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  12. final def ==(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  14. def addString(b: StringBuilder): StringBuilder

    Definition Classes
    TraversableOnce
  15. def addString(b: StringBuilder, sep: String): StringBuilder

    Definition Classes
    TraversableOnce
  16. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Definition Classes
    TraversableOnce
  17. def aggregate[B](z: B)(seqop: (B, Instruction) ⇒ B, combop: (B, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  18. def andThen[C](k: (Instruction) ⇒ C): PartialFunction[Int, C]

    Definition Classes
    PartialFunction → Function1
  19. def apply(n: Int): Instruction

    Return the n-th instruction.

    Return the n-th instruction.

    Definition Classes
    BasicBlock → SeqLike → GenSeqLike → Function1
  20. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  21. def blockContents: String

  22. def canEqual(that: Any): Boolean

    Definition Classes
    IterableLike → Equals
  23. def clear(): Unit

  24. def clone(): AnyRef

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

    Close the block

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

  27. def closeWith(instr: Instruction): Unit

    do nothing if block is already closed

  28. def closed: Boolean

    Is this block closed?

  29. def closed_=(b: Boolean): Unit

  30. def code: Code

  31. def collect[B, That](pf: PartialFunction[Instruction, B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike
  32. def collectFirst[B](pf: PartialFunction[Instruction, B]): Option[B]

    Definition Classes
    TraversableOnce
  33. def combinations(n: Int): Iterator[Seq[Instruction]]

    Definition Classes
    SeqLike
  34. def companion: GenericCompanion[Seq]

    Definition Classes
    Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate
  35. def compose[A](g: (A) ⇒ Int): (A) ⇒ Instruction

    Definition Classes
    Function1
  36. def contains(elem: Any): Boolean

    Definition Classes
    SeqLike
  37. def containsSlice[B](that: GenSeq[B]): Boolean

    Definition Classes
    SeqLike
  38. def copyToArray[B >: Instruction](xs: Array[B], start: Int, len: Int): Unit

    Definition Classes
    IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
  39. def copyToArray[B >: Instruction](xs: Array[B]): Unit

    Definition Classes
    TraversableOnce → GenTraversableOnce
  40. def copyToArray[B >: Instruction](xs: Array[B], start: Int): Unit

    Definition Classes
    TraversableOnce → GenTraversableOnce
  41. def copyToBuffer[B >: Instruction](dest: Buffer[B]): Unit

    Definition Classes
    TraversableOnce
  42. def corresponds[B](that: GenSeq[B])(p: (Instruction, B) ⇒ Boolean): Boolean

    Definition Classes
    SeqLike → GenSeqLike
  43. def count(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    TraversableOnce → GenTraversableOnce
  44. def diff[B >: Instruction](that: GenSeq[B]): Seq[Instruction]

    Definition Classes
    SeqLike → GenSeqLike
  45. def directSuccessors: List[BasicBlock]

  46. def distinct: Seq[Instruction]

    Definition Classes
    SeqLike → GenSeqLike
  47. def drop(n: Int): Seq[Instruction]

    Definition Classes
    IterableLike → TraversableLike → GenTraversableLike
  48. def dropRight(n: Int): Seq[Instruction]

    Definition Classes
    IterableLike
  49. def dropWhile(p: (Instruction) ⇒ Boolean): Seq[Instruction]

    Definition Classes
    TraversableLike → GenTraversableLike
  50. def emit(instrs: Seq[Instruction]): Unit

  51. def emit(instr: 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.

  52. def emit(instr: Instruction): Unit

    Add a new instruction at the end of the block, using the same source position as the last emitted instruction

  53. def emitOnly(instrs: 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.

  54. def endsWith[B](that: GenSeq[B]): Boolean

    Definition Classes
    SeqLike → GenSeqLike
  55. 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.

  56. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    BasicBlock → GenSeqLike → Equals → AnyRef → Any
  58. 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
    BasicBlockProgramPoint
  59. def exceptionHandlerStart_=(b: Boolean): Unit

  60. def exceptionSuccessors: List[BasicBlock]

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

  62. def exists(p: (Instruction) ⇒ Boolean): Boolean

    Definition Classes
    IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
  63. def exitIgnoreMode(): Unit

  64. def filter(p: (Instruction) ⇒ Boolean): Seq[Instruction]

    Definition Classes
    TraversableLike → GenTraversableLike
  65. def filterNot(p: (Instruction) ⇒ Boolean): Seq[Instruction]

    Definition Classes
    TraversableLike → GenTraversableLike
  66. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  67. def find(p: (Instruction) ⇒ Boolean): Option[Instruction]

    Definition Classes
    IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
  68. def firstInstruction: Instruction

  69. def flagsString: String

  70. def flatMap[B, That](f: (Instruction) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike → FilterMonadic
  71. def fold[A1 >: Instruction](z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
    TraversableOnce → GenTraversableOnce
  72. def foldLeft[B](z: B)(op: (B, Instruction) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  73. def foldRight[B](z: B)(op: (Instruction, B) ⇒ B): B

    Definition Classes
    IterableLike → TraversableOnce → GenTraversableOnce
  74. def forall(p: (Instruction) ⇒ Boolean): Boolean

    Definition Classes
    IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
  75. def foreach[U](f: (Instruction) ⇒ U): Unit

    Apply a function to all the instructions of the block.

    Apply a function to all the instructions of the block.

    Definition Classes
    BasicBlock → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
  76. def fromList(is: List[Instruction]): Unit

  77. def fullString: String

  78. def genericBuilder[B]: Builder[B, Seq[B]]

    Definition Classes
    GenericTraversableTemplate
  79. def getArray: Array[Instruction]

    return the underlying array of instructions

  80. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any
  81. def groupBy[K](f: (Instruction) ⇒ K): Map[K, Seq[Instruction]]

    Definition Classes
    TraversableLike → GenTraversableLike
  82. def grouped(size: Int): Iterator[Seq[Instruction]]

    Definition Classes
    IterableLike
  83. def hasDefiniteSize: Boolean

    Definition Classes
    TraversableLike → TraversableOnce → GenTraversableOnce
  84. def hasFlag(flag: Int): Boolean

    Does this block have the given flag?

  85. def hashCode(): Int

    Definition Classes
    BasicBlock → GenSeqLike → AnyRef → Any
  86. def head: Instruction

    Definition Classes
    IterableLike → GenIterableLike → TraversableLike → GenTraversableLike
  87. def headOption: Option[Instruction]

    Definition Classes
    TraversableLike
  88. def ignore: Boolean

    When set, the emit methods will be ignored.

  89. def ignore_=(b: Boolean): Unit

  90. def indexOf(inst: Instruction): Int

    Return the index of inst.

    Return the index of inst. Uses reference equality. Returns -1 if not found.

  91. def indexOf[B >: Instruction](elem: B, from: Int): Int

    Definition Classes
    GenSeqLike
  92. def indexOf[B >: Instruction](elem: B): Int

    Definition Classes
    GenSeqLike
  93. def indexOfSlice[B >: Instruction](that: GenSeq[B], from: Int): Int

    Definition Classes
    SeqLike
  94. def indexOfSlice[B >: Instruction](that: GenSeq[B]): Int

    Definition Classes
    SeqLike
  95. def indexWhere(p: (Instruction) ⇒ Boolean, from: Int): Int

    Definition Classes
    SeqLike → GenSeqLike
  96. def indexWhere(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    GenSeqLike
  97. def indices: Range

    Definition Classes
    SeqLike
  98. def indirectExceptionSuccessors: List[BasicBlock]

    Return a list of successors for 'b' that come from exception handlers covering b's (non-exceptional) successors.

    Return a list of successors for 'b' that come from exception handlers covering b's (non-exceptional) successors. These exception handlers might not cover 'b' itself. This situation corresponds to an exception being thrown as the first thing of one of b's successors.

  99. def init: Seq[Instruction]

    Definition Classes
    TraversableLike
  100. def inits: Iterator[Seq[Instruction]]

    Definition Classes
    TraversableLike
  101. def insertAfter(idx: Int, is: List[Instruction]): Unit

    Insert instructions in 'is' immediately after index 'idx'.

  102. def intersect[B >: Instruction](that: GenSeq[B]): Seq[Instruction]

    Definition Classes
    SeqLike → GenSeqLike
  103. def isDefinedAt(idx: Int): Boolean

    Definition Classes
    GenSeqLike
  104. def isEmpty: Boolean

    Definition Classes
    BasicBlock → IterableLike → GenIterableLike → GenericTraversableTemplate → TraversableLike → TraversableOnce → GenTraversableOnce
  105. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  106. final def isTraversableAgain: Boolean

    Definition Classes
    GenTraversableLike → GenTraversableOnce
  107. def iterator: Iterator[Instruction]

    Return an iterator over the instructions in this basic block.

    Return an iterator over the instructions in this basic block.

    Definition Classes
    BasicBlock → IterableLike → GenIterableLike
  108. val label: Int

  109. def last: Instruction

    Definition Classes
    TraversableLike
  110. def lastIndexOf[B >: Instruction](elem: B, end: Int): Int

    Definition Classes
    GenSeqLike
  111. def lastIndexOf[B >: Instruction](elem: B): Int

    Definition Classes
    GenSeqLike
  112. def lastIndexOfSlice[B >: Instruction](that: GenSeq[B], end: Int): Int

    Definition Classes
    SeqLike
  113. def lastIndexOfSlice[B >: Instruction](that: GenSeq[B]): Int

    Definition Classes
    SeqLike
  114. def lastIndexWhere(p: (Instruction) ⇒ Boolean, end: Int): Int

    Definition Classes
    SeqLike → GenSeqLike
  115. def lastIndexWhere(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    GenSeqLike
  116. def lastInstruction: Instruction

    Return the last instruction of this basic block.

  117. def lastOption: Option[Instruction]

    Definition Classes
    TraversableLike
  118. def length: Int

    The number of instructions in this basic block so far.

    The number of instructions in this basic block so far.

    Definition Classes
    BasicBlock → SeqLike → GenSeqLike
  119. def lengthCompare(len: Int): Int

    Definition Classes
    SeqLike
  120. def lift: (Int) ⇒ Option[Instruction]

    Definition Classes
    PartialFunction
  121. def loopHeader: Boolean

    Is this block the head of a while?

  122. def loopHeader_=(b: Boolean): Unit

  123. def map[B, That](f: (Instruction) ⇒ B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike → FilterMonadic
  124. def max[B >: Instruction](implicit cmp: Ordering[B]): Instruction

    Definition Classes
    TraversableOnce → GenTraversableOnce
  125. def maxBy[B](f: (Instruction) ⇒ B)(implicit cmp: Ordering[B]): Instruction

    Definition Classes
    TraversableOnce → GenTraversableOnce
  126. val method: IMethod

  127. def min[B >: Instruction](implicit cmp: Ordering[B]): Instruction

    Definition Classes
    TraversableOnce → GenTraversableOnce
  128. def minBy[B](f: (Instruction) ⇒ B)(implicit cmp: Ordering[B]): Instruction

    Definition Classes
    TraversableOnce → GenTraversableOnce
  129. def mkString: String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  130. def mkString(sep: String): String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  131. def mkString(start: String, sep: String, end: String): String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  132. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  133. def newBuilder: Builder[Instruction, Seq[Instruction]]

    Attributes
    protected[this]
    Definition Classes
    GenericTraversableTemplate → HasNewBuilder
  134. def nonEmpty: Boolean

    Definition Classes
    TraversableOnce → GenTraversableOnce
  135. final def notify(): Unit

    Definition Classes
    AnyRef
  136. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  137. def open(): Unit

  138. def orElse[A1 <: Int, B1 >: Instruction](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

    Definition Classes
    PartialFunction
  139. def padTo[B >: Instruction, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  140. def par: ParSeq[Instruction]

    Definition Classes
    Parallelizable
  141. def parCombiner: Combiner[Instruction, ParSeq[Instruction]]

    Attributes
    protected[this]
    Definition Classes
    SeqLike → TraversableLike → Parallelizable
  142. def partition(p: (Instruction) ⇒ Boolean): (Seq[Instruction], Seq[Instruction])

    Definition Classes
    TraversableLike → GenTraversableLike
  143. def patch[B >: Instruction, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  144. def permutations: Iterator[Seq[Instruction]]

    Definition Classes
    SeqLike
  145. def predContents: String

  146. def predecessors: List[BasicBlock]

    Returns the predecessors of this block.

    Returns the predecessors of this block.

    Definition Classes
    BasicBlockProgramPoint
  147. var preds: List[BasicBlock]

    Cached predecessors.

  148. def prefixLength(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    GenSeqLike
  149. def print(out: PrintStream): Unit

  150. def print(): Unit

  151. def product[B >: Instruction](implicit num: Numeric[B]): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  152. def reduce[A1 >: Instruction](op: (A1, A1) ⇒ A1): A1

    Definition Classes
    TraversableOnce → GenTraversableOnce
  153. def reduceLeft[B >: Instruction](op: (B, Instruction) ⇒ B): B

    Definition Classes
    TraversableOnce
  154. def reduceLeftOption[B >: Instruction](op: (B, Instruction) ⇒ B): Option[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  155. def reduceOption[A1 >: Instruction](op: (A1, A1) ⇒ A1): Option[A1]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  156. def reduceRight[B >: Instruction](op: (Instruction, B) ⇒ B): B

    Definition Classes
    IterableLike → TraversableOnce → GenTraversableOnce
  157. def reduceRightOption[B >: Instruction](op: (Instruction, B) ⇒ B): Option[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  158. def removeInstructionsAt(positions: Int*): Unit

    Removes instructions found at the given positions.

    Removes instructions found at the given positions.

    positions

    ...

  159. 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.

  160. def replaceInstruction(oldInstr: Instruction, is: List[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

    ..

  161. def replaceInstruction(oldInstr: Instruction, newInstr: 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. It retains the position of the previous instruction.

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

    Replace the instruction at the given position.

    Replace the instruction at the given position. Used by labels when they are anchored. It retains the position of the previous instruction.

  163. def repr: Seq[Instruction]

    Definition Classes
    TraversableLike → GenTraversableLike
  164. def reverse: Seq[Instruction]

    Definition Classes
    SeqLike → GenSeqLike
  165. def reverseIterator: Iterator[Instruction]

    Definition Classes
    SeqLike
  166. def reverseMap[B, That](f: (Instruction) ⇒ B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  167. def reversed: List[Instruction]

    Attributes
    protected[this]
    Definition Classes
    TraversableOnce
  168. def sameElements[B >: Instruction](that: GenIterable[B]): Boolean

    Definition Classes
    IterableLike → GenIterableLike
  169. def scan[B >: Instruction, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike
  170. def scanLeft[B, That](z: B)(op: (B, Instruction) ⇒ B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike
  171. def scanRight[B, That](z: B)(op: (Instruction, B) ⇒ B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    TraversableLike → GenTraversableLike
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.

  172. def segmentLength(p: (Instruction) ⇒ Boolean, from: Int): Int

    Definition Classes
    SeqLike → GenSeqLike
  173. def seq: Seq[Instruction]

    Definition Classes
    Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
  174. def size: Int

    Definition Classes
    SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce
  175. def slice(from: Int, until: Int): Seq[Instruction]

    Definition Classes
    IterableLike → TraversableLike → GenTraversableLike
  176. def sliding[B >: Instruction](size: Int, step: Int): Iterator[Seq[Instruction]]

    Definition Classes
    IterableLike
  177. def sliding[B >: Instruction](size: Int): Iterator[Seq[Instruction]]

    Definition Classes
    IterableLike
  178. def sortBy[B](f: (Instruction) ⇒ B)(implicit ord: Ordering[B]): Seq[Instruction]

    Definition Classes
    SeqLike
  179. def sortWith(lt: (Instruction, Instruction) ⇒ Boolean): Seq[Instruction]

    Definition Classes
    SeqLike
  180. def sorted[B >: Instruction](implicit ord: Ordering[B]): Seq[Instruction]

    Definition Classes
    SeqLike
  181. def span(p: (Instruction) ⇒ Boolean): (Seq[Instruction], Seq[Instruction])

    Definition Classes
    TraversableLike → GenTraversableLike
  182. def splitAt(n: Int): (Seq[Instruction], Seq[Instruction])

    Definition Classes
    TraversableLike → GenTraversableLike
  183. def startsWith[B](that: GenSeq[B], offset: Int): Boolean

    Definition Classes
    SeqLike → GenSeqLike
  184. def startsWith[B](that: GenSeq[B]): Boolean

    Definition Classes
    GenSeqLike
  185. def stringPrefix: String

    Definition Classes
    TraversableLike → GenTraversableLike
  186. def subst(map: Map[Instruction, Instruction]): Unit

    Replaces all instructions found in the map.

    Replaces all instructions found in the map.

    map

    ...

  187. def succContents: String

  188. def successors: List[BasicBlock]

    Definition Classes
    BasicBlockProgramPoint
  189. def sum[B >: Instruction](implicit num: Numeric[B]): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  190. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  191. def tail: Seq[Instruction]

    Definition Classes
    TraversableLike → GenTraversableLike
  192. def tails: Iterator[Seq[Instruction]]

    Definition Classes
    TraversableLike
  193. def take(n: Int): Seq[Instruction]

    Definition Classes
    IterableLike → TraversableLike → GenTraversableLike
  194. def takeRight(n: Int): Seq[Instruction]

    Definition Classes
    IterableLike
  195. def takeWhile(p: (Instruction) ⇒ Boolean): Seq[Instruction]

    Definition Classes
    IterableLike → TraversableLike → GenTraversableLike
  196. def thisCollection: Seq[Instruction]

    Attributes
    protected[this]
    Definition Classes
    SeqLike → IterableLike → TraversableLike
  197. def toArray[B >: Instruction](implicit arg0: ClassManifest[B]): Array[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  198. def toBuffer[B >: Instruction]: Buffer[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  199. def toCollection(repr: Seq[Instruction]): Seq[Instruction]

    Attributes
    protected[this]
    Definition Classes
    SeqLike → IterableLike → TraversableLike
  200. def toIndexedSeq[B >: Instruction]: IndexedSeq[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  201. def toIterable: Iterable[Instruction]

    Definition Classes
    IterableLike → TraversableOnce → GenTraversableOnce
  202. def toIterator: Iterator[Instruction]

    Definition Classes
    TraversableLike → GenTraversableOnce
  203. def toList: List[Instruction]

    Definition Classes
    BasicBlock → TraversableOnce → GenTraversableOnce
  204. def toMap[T, U](implicit ev: <:<[Instruction, (T, U)]): Map[T, U]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  205. def toSeq: Seq[Instruction]

    Definition Classes
    SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce
  206. def toSet[B >: Instruction]: Set[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  207. def toStream: Stream[Instruction]

    Definition Classes
    IterableLike → TraversableLike → GenTraversableOnce
  208. def toString(): String

    Definition Classes
    BasicBlock → SeqLike → TraversableLike → Function1 → AnyRef → Any
  209. def toTraversable: Traversable[Instruction]

    Definition Classes
    TraversableLike → TraversableOnce → GenTraversableOnce
  210. def touched: Boolean

    Has this basic block been modified since the last call to 'successors'?

  211. def touched_=(b: Boolean): Unit

  212. def transpose[B](implicit asTraversable: (Instruction) ⇒ GenTraversableOnce[B]): Seq[Seq[B]]

    Definition Classes
    GenericTraversableTemplate
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.

  213. def union[B >: Instruction, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  214. def unzip[A1, A2](implicit asPair: (Instruction) ⇒ (A1, A2)): (Seq[A1], Seq[A2])

    Definition Classes
    GenericTraversableTemplate
  215. def unzip3[A1, A2, A3](implicit asTriple: (Instruction) ⇒ (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[A3])

    Definition Classes
    GenericTraversableTemplate
  216. def updated[B >: Instruction, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Seq[Instruction], B, That]): That

    Definition Classes
    SeqLike → GenSeqLike
  217. var varsInScope: Set[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.

  218. def view(from: Int, until: Int): SeqView[Instruction, Seq[Instruction]]

    Definition Classes
    SeqLike → IterableLike → TraversableLike
  219. def view: SeqView[Instruction, Seq[Instruction]]

    Definition Classes
    SeqLike → IterableLike → TraversableLike
  220. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()
  223. def withFilter(p: (Instruction) ⇒ Boolean): FilterMonadic[Instruction, Seq[Instruction]]

    Definition Classes
    TraversableLike → FilterMonadic
  224. def zip[A1 >: Instruction, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Seq[Instruction], (A1, B), That]): That

    Definition Classes
    IterableLike → GenIterableLike
  225. def zipAll[B, A1 >: Instruction, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Seq[Instruction], (A1, B), That]): That

    Definition Classes
    IterableLike → GenIterableLike
  226. def zipWithIndex[A1 >: Instruction, That](implicit bf: CanBuildFrom[Seq[Instruction], (A1, Int), That]): That

    Definition Classes
    IterableLike → GenIterableLike

Deprecated Value Members

  1. def elements: Iterator[Instruction]

    Definition Classes
    IterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use iterator' instead

  2. def equalsWith[B](that: Seq[B])(f: (Instruction, B) ⇒ Boolean): Boolean

    Definition Classes
    SeqLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use corresponds instead

  3. def findIndexOf(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    SeqLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) Use indexWhere(p) instead.

  4. def findLastIndexOf(p: (Instruction) ⇒ Boolean): Int

    Definition Classes
    SeqLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use lastIndexWhere instead

  5. def first: Instruction

    Definition Classes
    IterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use head' instead

  6. def firstOption: Option[Instruction]

    Definition Classes
    IterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use headOption' instead

  7. def projection: SeqView[Instruction, Seq[Instruction]]

    Definition Classes
    SeqLike → IterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use view' instead

  8. def reversedElements: Iterator[Instruction]

    Definition Classes
    SeqLike
    Annotations
    @deprecated
    Deprecated

    (Since version 2.8.0) use reverseIterator' instead

Inherited from Seq[Instruction]

Inherited from SeqLike[Instruction, Seq[Instruction]]

Inherited from GenSeq[Instruction]

Inherited from GenSeqLike[Instruction, Seq[Instruction]]

Inherited from Iterable[Instruction]

Inherited from IterableLike[Instruction, Seq[Instruction]]

Inherited from Equals

Inherited from GenIterable[Instruction]

Inherited from GenIterableLike[Instruction, Seq[Instruction]]

Inherited from Traversable[Instruction]

Inherited from GenTraversable[Instruction]

Inherited from GenericTraversableTemplate[Instruction, Seq]

Inherited from TraversableLike[Instruction, Seq[Instruction]]

Inherited from GenTraversableLike[Instruction, Seq[Instruction]]

Inherited from Parallelizable[Instruction, ParSeq[Instruction]]

Inherited from TraversableOnce[Instruction]

Inherited from GenTraversableOnce[Instruction]

Inherited from FilterMonadic[Instruction, Seq[Instruction]]

Inherited from HasNewBuilder[Instruction, Seq[Instruction]]

Inherited from PartialFunction[Int, Instruction]

Inherited from (Int) ⇒ Instruction

Inherited from ProgramPoint[BasicBlock]

Inherited from AnyRef

Inherited from Any