/** * Check that the conditions of initialization are not broken. * * <p>To summarize the conditions: - Local variables must be initialized before use, (i.e. min * count > 0) - Final local variables (including Formals) cannot be assigned to more than once * (i.e. max count <= 1) - Final non-static fields whose target is this cannot be assigned to more * than once - Final static fields whose target is the current class cannot be assigned to more * than once * * <p>This method is also responsible for maintaining state between the dataflows over * Initializers, by copying back the appropriate MinMaxInitCounts to the map * currClassFinalFieldInitCounts. */ public void check(FlowGraph graph, Term n, Item inItem, Map outItems) throws SemanticException { DataFlowItem dfIn = (DataFlowItem) inItem; if (dfIn == null) { // There is no input data flow item. This can happen if we are // checking an unreachable term, and so no Items have flowed // through the term. For example, in the code fragment: // a: do { break a; } while (++i < 10); // the expression "++i < 10" is unreachable, but the as there is // no unreachable statement, the Java Language Spec permits it. // Set inItem to a default Item dfIn = createInitDFI(); } DataFlowItem dfOut = null; if (outItems != null && !outItems.isEmpty()) { // due to the flow equations, all DataFlowItems in the outItems map // are the same, so just take the first one. dfOut = (DataFlowItem) outItems.values().iterator().next(); } if (n instanceof Local) { checkLocal(graph, (Local) n, dfIn, dfOut); } else if (n instanceof LocalAssign) { checkLocalAssign(graph, (LocalAssign) n, dfIn, dfOut); } else if (n instanceof FieldAssign) { checkFieldAssign(graph, (FieldAssign) n, dfIn, dfOut); } else if (n instanceof ClassBody) { // we need to check that the locals used inside this class body // have all been defined at this point. Set localsUsed = (Set) currCBI.localsUsedInClassBodies.get(n); if (localsUsed != null) { checkLocalsUsedByInnerClass(graph, (ClassBody) n, localsUsed, dfIn, dfOut); } } if (n == graph.finishNode()) { if (currCBI.currCodeDecl instanceof Initializer) { finishInitializer(graph, (Initializer) currCBI.currCodeDecl, dfIn, dfOut); } if (currCBI.currCodeDecl instanceof ConstructorDecl) { finishConstructorDecl(graph, (ConstructorDecl) currCBI.currCodeDecl, dfIn, dfOut); } } }
/** * Before running <code>Pass pass</code> on <code>SourceJob job</code> make sure that all * appropriate scheduling invariants are satisfied, to ensure that all passes of other jobs that * <code>job</code> depends on will have already been done. */ protected void enforceInvariants(Job job, Pass pass) throws CyclicDependencyException { SourceJob srcJob = job.sourceJob(); if (srcJob == null) { return; } BarrierPass lastBarrier = srcJob.lastBarrier(); if (lastBarrier != null) { // make sure that _all_ dependent jobs have completed at least up to // the last barrier (not just children). // // Ideally the invariant should be that only the source jobs that // job _depends on_ should be brought up to the last barrier. // This is work to be done in the future... List allDependentSrcs = new ArrayList(srcJob.dependencies()); Iterator i = allDependentSrcs.iterator(); while (i.hasNext()) { Source s = (Source) i.next(); Object o = jobs.get(s); if (o == COMPLETED_JOB) continue; if (o == null) { throw new InternalCompilerError("Unknown source " + s); } SourceJob sj = (SourceJob) o; if (sj.pending(lastBarrier.id())) { // Make the job run up to the last barrier. // We ignore the return result, since even if the job // fails, we will keep on going and see // how far we get... if (Report.should_report(Report.frontend, 3)) { Report.report(3, "Running " + sj + " to " + lastBarrier.id() + " for " + srcJob); } runToPass(sj, lastBarrier.id()); } } } if (pass instanceof GlobalBarrierPass) { // need to make sure that _all_ jobs have completed just up to // this global barrier. // If we hit a cyclic dependency, ignore it and run the other // jobs up to that pass. Then try again to run the cyclic // pass. If we hit the cycle again for the same job, stop. LinkedList barrierWorklist = new LinkedList(jobs.values()); while (!barrierWorklist.isEmpty()) { Object o = barrierWorklist.removeFirst(); if (o == COMPLETED_JOB) continue; SourceJob sj = (SourceJob) o; if (sj.completed(pass.id()) || sj.nextPass() == sj.passByID(pass.id())) { // the source job has either done this global pass // (which is possible if the job was loaded late in the // game), or is right up to the global barrier. continue; } // Make the job run up to just before the global barrier. // We ignore the return result, since even if the job // fails, we will keep on going and see // how far we get... Pass beforeGlobal = sj.getPreviousTo(pass.id()); if (Report.should_report(Report.frontend, 3)) { Report.report(3, "Running " + sj + " to " + beforeGlobal.id() + " for " + srcJob); } // Don't use runToPass, since that catches the // CyclicDependencyException that we should report // back to the caller. while (!sj.pendingPasses().isEmpty()) { Pass p = (Pass) sj.pendingPasses().get(0); runPass(sj, p); if (p == beforeGlobal) { break; } } } } }