16  * 2 along with this work; if not, write to the Free Software Foundation,
41 //  - What to do about jsr with different types of local vars?
46 //  - Could extend verifier to provide this information.
47 //    For: one fewer abstract interpreter to maintain. Against: the verifier
48 //    solves a bigger problem so slower (undesirable to force verification of
76 //    Basic block headers are the only merge points. We use this iteration to
81 //    initialize first BB according to method signature;
91 //  To be able to process "ret" bytecodes, we keep track of these return
93 //  processing a "ret" bytecodes, it is not sufficient to know that it gets
94 //  an argument of the right type 'p'; we need to know which address it
95 //  returns to).
155 // Specialization of SignatureIterator - in order to set up first stack frame
210 // Contains function to itereate through all bytecodes
309       return '#';    // Conflict that needs to be rewritten
401   bool fellThrough = false;  // False to get first BB marked.
449   int change = 1; // int to get function pointers to work
456     // If block is not already alive (due to multiple exception handlers to same bb), then
586 /* Requires "pc" to be the head of a basic block; returns that basic
594 // Requires "pc" to be the start of an instruction; returns the basic
649     report_error("Cannot reserve enough memory to analyze this method"); \
685   // If the top bit is set, we don't need to do any more work.
691       // The two values being merged are different.  Raise to top.
767 // it's impossible to interpret the code.  Simultaneously monitor
768 // states are being check to see if they nest statically.  If monitor
790       // When the monitor stacks are not matched, we set _monitor_top to
828     return valCTS; // just to pick something;
836     return valCTS; // just to pick something
859     return CellTypeState::ref; // just to keep the analysis going.
976   // _basic_block that points to each piece.
979   // basic blocks and stack/locals/monitors.  Need to check to make sure
982     report_error("The amount of memory required to analyze this method "
1018     // Initialize all locals to 'uninit' and set stack-height to 0
1024     // If some references must be pre-assigned to null, then set that up
1100   // We do not want to do anything in case the basic-block has not been initialized. This
1107   // Set iterator interval to be the current basicblock
1117       // We do not need to interpret the results of exceptional
1129     assert(itr.next_bci() == lim_bci, "must point to end");
1159       // These bytecodes can trap for rewriting.  We need to assume that
1160       // they do not throw exceptions to make the monitor analysis work.
1181       // monitor stack height is 0, we are about to pop a monitor
1210         // above; now we temporarily set them to the appropriate
1221         // If this is a "catch all" handler, then we do not need to
1239   // we don't care to analyse the types of the catch clauses.)
1241   // We don't set _monitor_top to bad_monitors because there are no successors
1242   // to this exceptional exit.
1326 // Sets the current state to be the state after executing the
1334   // However, not for calls. For calls we do not want to include the arguments, so we postpone the reporting until
1649         // We were asked to push a reference, but the type of the
1773   // isn't too hard to handle and can be made to work if supporting nested
1809     // We need to mark this basic block as changed so that
1810     // this monitorexit will be visited again.  We need to
1811     // do this to ensure that we have accounted for the
1828     // Note: when generateOopMap is fixed to properly handle repeated,
1830     //       fix will need to be removed at that time.
1838     // for the monitors to be properly matched.
1841     // Since there are no successors to the *return bytecode, it
1842     // isn't necessary to set _monitor_top to bad_monitors.
1966 // This is used to parse the signature for fields, since they are very simple...
2035   // We have to initialize all variables here, that can be queried directly
2119 // at the bottom of the call stack, when it returns to compute_map().  The
2122 // to be added as a parameter to every function and checked for every call.
2162   // We now want to report the result of the parse
2190   // We now want to report the result of the parse
2231   // do any rewriting, we just want to recompute the reference set with the
2245   // This following flag is to tempoary supress rewrites. The locals that might conflict will
2246   // all be set to contain values. This is UNSAFE - however, until the rewriting has been completely
2247   // tested it is nice to have.
2277   assert(_new_var_map!=NULL, "nothing to rewrite");
2305 void GenerateOopMap::rewrite_refval_conflict(int from, int to) {
2309     // during rewriting a new method oop is going to be used, and the next time
2310     // around we want to use that.
2315       startOver = rewrite_refval_conflict_inst(&bcs, from, to);
2321    in a ref way, change it to use "to". There's a subtle reason why we
2324    whether we should add one or two variables to the method. If the change
2329 bool GenerateOopMap::rewrite_refval_conflict_inst(BytecodeStream *itr, int from, int to) {
2338     return rewrite_load_or_store(itr, Bytecodes::_aload, Bytecodes::_aload_0, to);
2346       return rewrite_load_or_store(itr, Bytecodes::_astore, Bytecodes::_astore_0, to);
2357 // The argument to this method is:
2377   // If we need to relocate in order to patch the byte, we
2378   // do the patching in a temp. buffer, that is passed to the reloc.
2381   // also relocate that instruction, e.g., if a _goto before it gets widen to a _goto_w.
2382   // Hence, we do not know which bci to patch after relocation.
2502     // Make sure to only check basicblocks that are reachable

Indexes created Tue Jul 24 14:28:13 CEST 2018