jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/jvm/Code.java

-:03c26c60499c
+:4932bb04c4b8
 package com.sun.tools.javac.jvm;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Types.UniqueType;
+import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import static com.sun.tools.javac.code.TypeTag.BOT;
 import static com.sun.tools.javac.code.TypeTag.INT;
 */
 final Pool pool;
 final MethodSymbol meth;
+final LVTRanges lvtRanges;
 /** Construct a code object, given the settings of the fatcode,
 *  debugging info switches and the CharacterRangeTable.
 */
 public Code(MethodSymbol meth,
 boolean fatcode,
 StackMapFormat stackMap,
 boolean debugCode,
 CRTable crt,
 Symtab syms,
 Types types,
-Pool pool) {
+Pool pool,
+LVTRanges lvtRanges) {
 this.meth = meth;
 this.fatcode = fatcode;
 this.lineMap = lineMap;
 this.lineDebugInfo = lineMap != null;
 this.varDebugInfo = varDebugInfo;
 this.needStackMap = false;
 }
 state = new State();
 lvar = new LocalVar[20];
 this.pool = pool;
+this.lvtRanges = lvtRanges;
 }
 /* **************************************************************************
 * Typecodes & related stuff
 * Emit code
 ****************************************************************************/
 /** The current output code pointer.
 */
-public int curPc() {
+public int curCP() {
-if (pendingJumps != null) resolvePending();
+/*
-if (pendingStatPos != Position.NOPOS) markStatBegin();
+* This method has side-effects because calling it can indirectly provoke
+*  extra code generation, like goto instructions, depending on the context
+*  where it's called.
+*  Use with care or even better avoid using it.
+*/
+if (pendingJumps != null) {
+resolvePending();
+}
+if (pendingStatPos != Position.NOPOS) {
+markStatBegin();
+}
 fixedPc = true;
 return cp;
 }
 /** Emit a byte of code.
 }
 /** Declare an entry point; return current code pointer
 */
 public int entryPoint() {
-int pc = curPc();
+int pc = curCP();
 alive = true;
 pendingStackMap = needStackMap;
 return pc;
 }
 /** Declare an entry point with initial state;
 *  return current code pointer
 */
 public int entryPoint(State state) {
-int pc = curPc();
+int pc = curCP();
 alive = true;
 this.state = state.dup();
 Assert.check(state.stacksize <= max_stack);
 if (debugCode) System.err.println("entry point " + state);
 pendingStackMap = needStackMap;
 /** Declare an entry point with initial state plus a pushed value;
 *  return current code pointer
 */
 public int entryPoint(State state, Type pushed) {
-int pc = curPc();
+int pc = curCP();
 alive = true;
 this.state = state.dup();
 Assert.check(state.stacksize <= max_stack);
 this.state.push(pushed);
 if (debugCode) System.err.println("entry point " + state);
 /** The stack map frame before the last one. */
 StackMapFrame frameBeforeLast = null;
 /** Emit a stack map entry.  */
 public void emitStackMap() {
-int pc = curPc();
+int pc = curCP();
 if (!needStackMap) return;
 switch (stackMap) {
 }
 if (get1(chain.pc) == goto_ &&
 chain.pc + 3 == target && target == cp && !fixedPc) {
 // If goto the next instruction, the jump is not needed:
 // compact the code.
+if (varDebugInfo) {
+adjustAliveRanges(cp, -3);
+}
 cp = cp - 3;
 target = target - 3;
 if (chain.next == null) {
 // This is the only jump to the target. Exit the loop
 // without setting new state. The code is reachable
 if (lv != null && lv.sym.type == old) {
 VarSymbol sym = lv.sym;
 sym = sym.clone(sym.owner);
 sym.type = newtype;
 LocalVar newlv = lvar[i] = new LocalVar(sym);
-// should the following be initialized to cp?
+newlv.aliveRanges = lv.aliveRanges;
-newlv.start_pc = lv.start_pc;
 }
 }
 }
 State join(State other) {
 /** A live range of a local variable. */
 static class LocalVar {
 final VarSymbol sym;
 final char reg;
-char start_pc = Character.MAX_VALUE;
-char length = Character.MAX_VALUE;
+class Range {
+char start_pc = Character.MAX_VALUE;
+char length = Character.MAX_VALUE;
+Range() {}
+Range(char start) {
+this.start_pc = start;
+}
+Range(char start, char length) {
+this.start_pc = start;
+this.length = length;
+}
+boolean closed() {
+return start_pc != Character.MAX_VALUE && length != Character.MAX_VALUE;
+}
+@Override
+public String toString() {
+int currentStartPC = start_pc;
+int currentLength = length;
+return "startpc = " + currentStartPC + " length " + currentLength;
+}
+}
+java.util.List<Range> aliveRanges = new java.util.ArrayList<>();
 LocalVar(VarSymbol v) {
 this.sym = v;
 this.reg = (char)v.adr;
 }
 public LocalVar dup() {
 return new LocalVar(sym);
 }
+Range firstRange() {
+return aliveRanges.isEmpty() ? null : aliveRanges.get(0);
+}
+Range lastRange() {
+return aliveRanges.isEmpty() ? null : aliveRanges.get(aliveRanges.size() - 1);
+}
+@Override
 public String toString() {
-return "" + sym + " in register " + ((int)reg) + " starts at pc=" + ((int)start_pc) + " length=" + ((int)length);
+if (aliveRanges == null) {
-}
+return "empty local var";
+}
+StringBuilder sb = new StringBuilder().append(sym)
+.append(" in register ").append((int)reg).append(" \n");
+for (Range r : aliveRanges) {
+sb.append(" starts at pc=").append(Integer.toString(((int)r.start_pc)))
+.append(" length=").append(Integer.toString(((int)r.length)))
+.append("\n");
+}
+return sb.toString();
+}
+public void openRange(char start) {
+if (!hasOpenRange()) {
+aliveRanges.add(new Range(start));
+}
+}
+public void closeRange(char end) {
+if (isLastRangeInitialized()) {
+Range range = lastRange();
+if (range != null) {
+if (range.length == Character.MAX_VALUE) {
+range.length = end;
+}
+}
+} else {
+if (!aliveRanges.isEmpty()) {
+aliveRanges.remove(aliveRanges.size() - 1);
+}
+}
+}
+public boolean hasOpenRange() {
+if (aliveRanges.isEmpty()) {
+return false;
+}
+Range range = lastRange();
+return range.length == Character.MAX_VALUE;
+}
+public boolean isLastRangeInitialized() {
+if (aliveRanges.isEmpty()) {
+return false;
+}
+Range range = lastRange();
+return range.start_pc != Character.MAX_VALUE;
+}
+public Range getWidestRange() {
+if (aliveRanges.isEmpty()) {
+return new Range();
+} else {
+Range firstRange = firstRange();
+Range lastRange = lastRange();
+char length = (char)(lastRange.length + (lastRange.start_pc - firstRange.start_pc));
+return new Range(firstRange.start_pc, length);
+}
+}
 };
 /** Local variables, indexed by register. */
 LocalVar[] lvar;
 /** Add a new local variable. */
 private void addLocalVar(VarSymbol v) {
 int adr = v.adr;
 lvar = ArrayUtils.ensureCapacity(lvar, adr+1);
 Assert.checkNull(lvar[adr]);
-if (pendingJumps != null) resolvePending();
+if (pendingJumps != null) {
+resolvePending();
+}
 lvar[adr] = new LocalVar(v);
 state.defined.excl(adr);
+}
+public void closeAliveRanges(JCTree tree) {
+closeAliveRanges(tree, cp);
+}
+public void closeAliveRanges(JCTree tree, int closingCP) {
+List<VarSymbol> locals = lvtRanges.getVars(meth, tree);
+for (LocalVar localVar: lvar) {
+for (VarSymbol aliveLocal : locals) {
+if (localVar == null) {
+return;
+}
+if (localVar.sym == aliveLocal && localVar.lastRange() != null) {
+char length = (char)(closingCP - localVar.lastRange().start_pc);
+if (length > 0 && length < Character.MAX_VALUE) {
+localVar.closeRange(length);
+}
+}
+}
+}
+}
+void adjustAliveRanges(int oldCP, int delta) {
+for (LocalVar localVar: lvar) {
+if (localVar == null) {
+return;
+}
+for (LocalVar.Range range: localVar.aliveRanges) {
+if (range.closed() && range.start_pc + range.length >= oldCP) {
+range.length += delta;
+}
+}
+}
+}
+/**
+* Calculates the size of the LocalVariableTable.
+*/
+public int getLVTSize() {
+int result = varBufferSize;
+for (int i = 0; i < varBufferSize; i++) {
+LocalVar var = varBuffer[i];
+result += var.aliveRanges.size() - 1;
+}
+return result;
 }
 /** Set the current variable defined state. */
 public void setDefined(Bits newDefined) {
 if (alive && newDefined != state.defined) {
 if (v == null) {
 state.defined.excl(adr);
 } else {
 state.defined.incl(adr);
 if (cp < Character.MAX_VALUE) {
-if (v.start_pc == Character.MAX_VALUE)
+v.openRange((char)cp);
-v.start_pc = (char)cp;
 }
 }
 }
 /** Mark a register as being undefined. */
 public void setUndefined(int adr) {
 state.defined.excl(adr);
 if (adr < lvar.length &&
 lvar[adr] != null &&
-lvar[adr].start_pc != Character.MAX_VALUE) {
+lvar[adr].isLastRangeInitialized()) {
 LocalVar v = lvar[adr];
-char length = (char)(curPc() - v.start_pc);
+char length = (char)(curCP() - v.lastRange().start_pc);
 if (length > 0 && length < Character.MAX_VALUE) {
 lvar[adr] = v.dup();
-v.length = length;
+v.closeRange(length);
 putVar(v);
 } else {
-v.start_pc = Character.MAX_VALUE;
+v.lastRange().start_pc = Character.MAX_VALUE;
 }
 }
 }
 /** End the scope of a variable. */
 private void endScope(int adr) {
 LocalVar v = lvar[adr];
 if (v != null) {
 lvar[adr] = null;
-if (v.start_pc != Character.MAX_VALUE) {
+if (v.isLastRangeInitialized()) {
-char length = (char)(curPc() - v.start_pc);
+char length = (char)(curCP() - v.lastRange().start_pc);
 if (length < Character.MAX_VALUE) {
-v.length = length;
+v.closeRange(length);
 putVar(v);
 fillLocalVarPosition(v);
 }
 }
 }
 private void fillLocalVarPosition(LocalVar lv) {
 if (lv == null || lv.sym == null || !lv.sym.hasTypeAnnotations())
 return;
 for (Attribute.TypeCompound ta : lv.sym.getRawTypeAttributes()) {
 TypeAnnotationPosition p = ta.position;
-p.lvarOffset = new int[] { (int)lv.start_pc };
+LocalVar.Range widestRange = lv.getWidestRange();
-p.lvarLength = new int[] { (int)lv.length };
+p.lvarOffset = new int[] { (int)widestRange.start_pc };
+p.lvarLength = new int[] { (int)widestRange.length };
 p.lvarIndex = new int[] { (int)lv.reg };
 p.isValidOffset = true;
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/jvm/Code.java

src/share/classes/com/sun/tools/javac/jvm/Code.java