1 /*
  2  * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_ASM_CODEBUFFER_HPP
 26 #define SHARE_ASM_CODEBUFFER_HPP
 27 
 28 #include "code/oopRecorder.hpp"
 29 #include "code/relocInfo.hpp"
 30 #include "utilities/align.hpp"
 31 #include "utilities/debug.hpp"
 32 #include "utilities/macros.hpp"
 33 
 34 class PhaseCFG;
 35 class Compile;
 36 class BufferBlob;
 37 class CodeBuffer;
 38 class Label;
 39 
 40 class CodeOffsets: public StackObj {
 41 public:
 42   enum Entries { Entry,
 43                  Verified_Entry,
 44                  Frame_Complete, // Offset in the code where the frame setup is (for forte stackwalks) is complete
 45                  OSR_Entry,
 46                  Exceptions,     // Offset where exception handler lives
 47                  Deopt,          // Offset where deopt handler lives
 48                  DeoptMH,        // Offset where MethodHandle deopt handler lives
 49                  UnwindHandler,  // Offset to default unwind handler
 50                  max_Entries };
 51 
 52   // special value to note codeBlobs where profile (forte) stack walking is
 53   // always dangerous and suspect.
 54 
 55   enum { frame_never_safe = -1 };
 56 
 57 private:
 58   int _values[max_Entries];
 59 
 60 public:
 61   CodeOffsets() {
 62     _values[Entry         ] = 0;
 63     _values[Verified_Entry] = 0;
 64     _values[Frame_Complete] = frame_never_safe;
 65     _values[OSR_Entry     ] = 0;
 66     _values[Exceptions    ] = -1;
 67     _values[Deopt         ] = -1;
 68     _values[DeoptMH       ] = -1;
 69     _values[UnwindHandler ] = -1;
 70   }
 71 
 72   int value(Entries e) { return _values[e]; }
 73   void set_value(Entries e, int val) { _values[e] = val; }
 74 };
 75 
 76 // This class represents a stream of code and associated relocations.
 77 // There are a few in each CodeBuffer.
 78 // They are filled concurrently, and concatenated at the end.
 79 class CodeSection {
 80   friend class CodeBuffer;
 81  public:
 82   typedef int csize_t;  // code size type; would be size_t except for history
 83 
 84  private:
 85   address     _start;           // first byte of contents (instructions)
 86   address     _mark;            // user mark, usually an instruction beginning
 87   address     _end;             // current end address
 88   address     _limit;           // last possible (allocated) end address
 89   relocInfo*  _locs_start;      // first byte of relocation information
 90   relocInfo*  _locs_end;        // first byte after relocation information
 91   relocInfo*  _locs_limit;      // first byte after relocation information buf
 92   address     _locs_point;      // last relocated position (grows upward)
 93   bool        _locs_own;        // did I allocate the locs myself?
 94   bool        _scratch_emit;    // Buffer is used for scratch emit, don't relocate.
 95   char        _index;           // my section number (SECT_INST, etc.)
 96   CodeBuffer* _outer;           // enclosing CodeBuffer
 97 
 98   // (Note:  _locs_point used to be called _last_reloc_offset.)
 99 
100   CodeSection() {
101     _start         = NULL;
102     _mark          = NULL;
103     _end           = NULL;
104     _limit         = NULL;
105     _locs_start    = NULL;
106     _locs_end      = NULL;
107     _locs_limit    = NULL;
108     _locs_point    = NULL;
109     _locs_own      = false;
110     _scratch_emit  = false;
111     debug_only(_index = (char)-1);
112     debug_only(_outer = (CodeBuffer*)badAddress);
113   }
114 
115   void initialize_outer(CodeBuffer* outer, int index) {
116     _outer = outer;
117     _index = index;
118   }
119 
120   void initialize(address start, csize_t size = 0) {
121     assert(_start == NULL, "only one init step, please");
122     _start         = start;
123     _mark          = NULL;
124     _end           = start;
125 
126     _limit         = start + size;
127     _locs_point    = start;
128   }
129 
130   void initialize_locs(int locs_capacity);
131   void expand_locs(int new_capacity);
132   void initialize_locs_from(const CodeSection* source_cs);
133 
134   // helper for CodeBuffer::expand()
135   void take_over_code_from(CodeSection* cs) {
136     _start      = cs->_start;
137     _mark       = cs->_mark;
138     _end        = cs->_end;
139     _limit      = cs->_limit;
140     _locs_point = cs->_locs_point;
141   }
142 
143  public:
144   address     start() const         { return _start; }
145   address     mark() const          { return _mark; }
146   address     end() const           { return _end; }
147   address     limit() const         { return _limit; }
148   csize_t     size() const          { return (csize_t)(_end - _start); }
149   csize_t     mark_off() const      { assert(_mark != NULL, "not an offset");
150                                       return (csize_t)(_mark - _start); }
151   csize_t     capacity() const      { return (csize_t)(_limit - _start); }
152   csize_t     remaining() const     { return (csize_t)(_limit - _end); }
153 
154   relocInfo*  locs_start() const    { return _locs_start; }
155   relocInfo*  locs_end() const      { return _locs_end; }
156   int         locs_count() const    { return (int)(_locs_end - _locs_start); }
157   relocInfo*  locs_limit() const    { return _locs_limit; }
158   address     locs_point() const    { return _locs_point; }
159   csize_t     locs_point_off() const{ return (csize_t)(_locs_point - _start); }
160   csize_t     locs_capacity() const { return (csize_t)(_locs_limit - _locs_start); }
161 
162   int         index() const         { return _index; }
163   bool        is_allocated() const  { return _start != NULL; }
164   bool        is_empty() const      { return _start == _end; }
165   bool        has_locs() const      { return _locs_end != NULL; }
166 
167   // Mark scratch buffer.
168   void        set_scratch_emit()    { _scratch_emit = true; }
169   bool        scratch_emit()        { return _scratch_emit; }
170 
171   CodeBuffer* outer() const         { return _outer; }
172 
173   // is a given address in this section?  (2nd version is end-inclusive)
174   bool contains(address pc) const   { return pc >= _start && pc <  _end; }
175   bool contains2(address pc) const  { return pc >= _start && pc <= _end; }
176   bool allocates(address pc) const  { return pc >= _start && pc <  _limit; }
177   bool allocates2(address pc) const { return pc >= _start && pc <= _limit; }
178 
179   // checks if two CodeSections are disjoint
180   //
181   // limit is an exclusive address and can be the start of another
182   // section.
183   bool disjoint(CodeSection* cs) const { return cs->_limit <= _start || cs->_start >= _limit; }
184 
185   void    set_end(address pc)       { assert(allocates2(pc), "not in CodeBuffer memory: " INTPTR_FORMAT " <= " INTPTR_FORMAT " <= " INTPTR_FORMAT, p2i(_start), p2i(pc), p2i(_limit)); _end = pc; }
186   void    set_mark(address pc)      { assert(contains2(pc), "not in codeBuffer");
187                                       _mark = pc; }
188   void    set_mark()                { _mark = _end; }
189   void    clear_mark()              { _mark = NULL; }
190 
191   void    set_locs_end(relocInfo* p) {
192     assert(p <= locs_limit(), "locs data fits in allocated buffer");
193     _locs_end = p;
194   }
195   void    set_locs_point(address pc) {
196     assert(pc >= locs_point(), "relocation addr may not decrease");
197     assert(allocates2(pc),     "relocation addr must be in this section");
198     _locs_point = pc;
199   }
200 
201   // Code emission
202   void emit_int8(int8_t x1) {
203     address curr = end();
204     *((int8_t*)  curr++) = x1;
205     set_end(curr);
206   }
207 
208   void emit_int16(int16_t x) { *((int16_t*) end()) = x; set_end(end() + sizeof(int16_t)); }
209   void emit_int16(int8_t x1, int8_t x2) {
210     address curr = end();
211     *((int8_t*)  curr++) = x1;
212     *((int8_t*)  curr++) = x2;
213     set_end(curr);
214   }
215 
216   void emit_int24(int8_t x1, int8_t x2, int8_t x3)  {
217     address curr = end();
218     *((int8_t*)  curr++) = x1;
219     *((int8_t*)  curr++) = x2;
220     *((int8_t*)  curr++) = x3;
221     set_end(curr);
222   }
223 
224   void emit_int32(int32_t x) {
225     address curr = end();
226     *((int32_t*) curr) = x;
227     set_end(curr + sizeof(int32_t));
228   }
229   void emit_int32(int8_t x1, int8_t x2, int8_t x3, int8_t x4)  {
230     address curr = end();
231     *((int8_t*)  curr++) = x1;
232     *((int8_t*)  curr++) = x2;
233     *((int8_t*)  curr++) = x3;
234     *((int8_t*)  curr++) = x4;
235     set_end(curr);
236   }
237 
238   void emit_int64( int64_t x)  { *((int64_t*) end()) = x; set_end(end() + sizeof(int64_t)); }
239 
240   void emit_float( jfloat  x)  { *((jfloat*)  end()) = x; set_end(end() + sizeof(jfloat)); }
241   void emit_double(jdouble x)  { *((jdouble*) end()) = x; set_end(end() + sizeof(jdouble)); }
242   void emit_address(address x) { *((address*) end()) = x; set_end(end() + sizeof(address)); }
243 
244   // Share a scratch buffer for relocinfo.  (Hacky; saves a resource allocation.)
245   void initialize_shared_locs(relocInfo* buf, int length);
246 
247   // Manage labels and their addresses.
248   address target(Label& L, address branch_pc);
249 
250   // Emit a relocation.
251   void relocate(address at, RelocationHolder const& rspec, int format = 0);
252   void relocate(address at,    relocInfo::relocType rtype, int format = 0, jint method_index = 0);
253 
254   // alignment requirement for starting offset
255   // Requirements are that the instruction area and the
256   // stubs area must start on CodeEntryAlignment, and
257   // the ctable on sizeof(jdouble)
258   int alignment() const             { return MAX2((int)sizeof(jdouble), (int)CodeEntryAlignment); }
259 
260   // Slop between sections, used only when allocating temporary BufferBlob buffers.
261   static csize_t end_slop()         { return MAX2((int)sizeof(jdouble), (int)CodeEntryAlignment); }
262 
263   csize_t align_at_start(csize_t off) const { return (csize_t) align_up(off, alignment()); }
264 
265   // Ensure there's enough space left in the current section.
266   // Return true if there was an expansion.
267   bool maybe_expand_to_ensure_remaining(csize_t amount);
268 
269 #ifndef PRODUCT
270   void decode();
271   void print(const char* name);
272 #endif //PRODUCT
273 };
274 
275 
276 #ifndef PRODUCT
277 
278 class AsmRemarkCollection;
279 class DbgStringCollection;
280 
281 // The assumption made here is that most code remarks (or comments) added to
282 // the generated assembly code are unique, i.e. there is very little gain in
283 // trying to share the strings between the different offsets tracked in a
284 // buffer (or blob).
285 
286 class AsmRemarks {
287  public:
288   AsmRemarks();
289  ~AsmRemarks();
290 
291   const char* insert(uint offset, const char* remstr);
292 
293   bool is_empty() const;
294 
295   void share(const AsmRemarks &src);
296   void clear();
297   uint print(uint offset, outputStream* strm = tty) const;
298 
299   // For testing purposes only.
300   const AsmRemarkCollection* ref() const { return _remarks; }
301 
302 private:
303   AsmRemarkCollection* _remarks;
304 };
305 
306 // The assumption made here is that the number of debug strings (with a fixed
307 // address requirement) is a rather small set per compilation unit.
308 
309 class DbgStrings {
310  public:
311   DbgStrings();
312  ~DbgStrings();
313 
314   const char* insert(const char* dbgstr);
315 
316   bool is_empty() const;
317 
318   void share(const DbgStrings &src);
319   void clear();
320 
321   // For testing purposes only.
322   const DbgStringCollection* ref() const { return _strings; }
323 
324 private:
325   DbgStringCollection* _strings;
326 };
327 #endif // not PRODUCT
328 
329 
330 #ifdef ASSERT
331 #include "utilities/copy.hpp"
332 
333 class Scrubber {
334  public:
335   Scrubber(void* addr, size_t size) : _addr(addr), _size(size) {}
336  ~Scrubber() {
337     Copy::fill_to_bytes(_addr, _size, badResourceValue);
338   }
339  private:
340   void*  _addr;
341   size_t _size;
342 };
343 #endif // ASSERT
344 
345 // A CodeBuffer describes a memory space into which assembly
346 // code is generated.  This memory space usually occupies the
347 // interior of a single BufferBlob, but in some cases it may be
348 // an arbitrary span of memory, even outside the code cache.
349 //
350 // A code buffer comes in two variants:
351 //
352 // (1) A CodeBuffer referring to an already allocated piece of memory:
353 //     This is used to direct 'static' code generation (e.g. for interpreter
354 //     or stubroutine generation, etc.).  This code comes with NO relocation
355 //     information.
356 //
357 // (2) A CodeBuffer referring to a piece of memory allocated when the
358 //     CodeBuffer is allocated.  This is used for nmethod generation.
359 //
360 // The memory can be divided up into several parts called sections.
361 // Each section independently accumulates code (or data) an relocations.
362 // Sections can grow (at the expense of a reallocation of the BufferBlob
363 // and recopying of all active sections).  When the buffered code is finally
364 // written to an nmethod (or other CodeBlob), the contents (code, data,
365 // and relocations) of the sections are padded to an alignment and concatenated.
366 // Instructions and data in one section can contain relocatable references to
367 // addresses in a sibling section.
368 
369 class CodeBuffer: public StackObj DEBUG_ONLY(COMMA private Scrubber) {
370   friend class CodeSection;
371   friend class StubCodeGenerator;
372 
373  private:
374   // CodeBuffers must be allocated on the stack except for a single
375   // special case during expansion which is handled internally.  This
376   // is done to guarantee proper cleanup of resources.
377   void* operator new(size_t size) throw() { return ResourceObj::operator new(size); }
378   void  operator delete(void* p)          { ShouldNotCallThis(); }
379 
380  public:
381   typedef int csize_t;  // code size type; would be size_t except for history
382   enum {
383     // Here is the list of all possible sections.  The order reflects
384     // the final layout.
385     SECT_FIRST = 0,
386     SECT_CONSTS = SECT_FIRST, // Non-instruction data:  Floats, jump tables, etc.
387     SECT_INSTS,               // Executable instructions.
388     SECT_STUBS,               // Outbound trampolines for supporting call sites.
389     SECT_LIMIT, SECT_NONE = -1
390   };
391 
392  private:
393   enum {
394     sect_bits = 2,      // assert (SECT_LIMIT <= (1<<sect_bits))
395     sect_mask = (1<<sect_bits)-1
396   };
397 
398   const char*  _name;
399 
400   CodeSection  _consts;             // constants, jump tables
401   CodeSection  _insts;              // instructions (the main section)
402   CodeSection  _stubs;              // stubs (call site support), deopt, exception handling
403 
404   CodeBuffer*  _before_expand;  // dead buffer, from before the last expansion
405 
406   BufferBlob*  _blob;           // optional buffer in CodeCache for generated code
407   address      _total_start;    // first address of combined memory buffer
408   csize_t      _total_size;     // size in bytes of combined memory buffer
409 
410   OopRecorder* _oop_recorder;
411 
412   OopRecorder  _default_oop_recorder;  // override with initialize_oop_recorder
413   Arena*       _overflow_arena;
414 
415   address      _last_insn;      // used to merge consecutive memory barriers, loads or stores.
416 
417 #ifndef PRODUCT
418   AsmRemarks   _asm_remarks;
419   DbgStrings   _dbg_strings;
420   bool         _collect_comments; // Indicate if we need to collect block comments at all.
421   address      _decode_begin;     // start address for decode
422   address      decode_begin();
423 #endif
424 
425   void initialize_misc(const char * name) {
426     // all pointers other than code_start/end and those inside the sections
427     assert(name != NULL, "must have a name");
428     _name            = name;
429     _before_expand   = NULL;
430     _blob            = NULL;
431     _oop_recorder    = NULL;
432     _overflow_arena  = NULL;
433     _last_insn       = NULL;
434 
435 #ifndef PRODUCT
436     _decode_begin    = NULL;
437     // Collect block comments, but restrict collection to cases where a disassembly is output.
438     _collect_comments = ( PrintAssembly
439                        || PrintStubCode
440                        || PrintMethodHandleStubs
441                        || PrintInterpreter
442                        || PrintSignatureHandlers
443                        || UnlockDiagnosticVMOptions
444                         );
445 #endif
446   }
447 
448   void initialize(address code_start, csize_t code_size) {
449     _consts.initialize_outer(this,  SECT_CONSTS);
450     _insts.initialize_outer(this,   SECT_INSTS);
451     _stubs.initialize_outer(this,   SECT_STUBS);
452     _total_start = code_start;
453     _total_size  = code_size;
454     // Initialize the main section:
455     _insts.initialize(code_start, code_size);
456     assert(!_stubs.is_allocated(),  "no garbage here");
457     assert(!_consts.is_allocated(), "no garbage here");
458     _oop_recorder = &_default_oop_recorder;
459   }
460 
461   void initialize_section_size(CodeSection* cs, csize_t size);
462 
463   // helper for CodeBuffer::expand()
464   void take_over_code_from(CodeBuffer* cs);
465 
466   // ensure sections are disjoint, ordered, and contained in the blob
467   void verify_section_allocation();
468 
469   // copies combined relocations to the blob, returns bytes copied
470   // (if target is null, it is a dry run only, just for sizing)
471   csize_t copy_relocations_to(CodeBlob* blob) const;
472 
473   // copies combined code to the blob (assumes relocs are already in there)
474   void copy_code_to(CodeBlob* blob);
475 
476   // moves code sections to new buffer (assumes relocs are already in there)
477   void relocate_code_to(CodeBuffer* cb) const;
478 
479   // set up a model of the final layout of my contents
480   void compute_final_layout(CodeBuffer* dest) const;
481 
482   // Expand the given section so at least 'amount' is remaining.
483   // Creates a new, larger BufferBlob, and rewrites the code & relocs.
484   void expand(CodeSection* which_cs, csize_t amount);
485 
486   // Helper for expand.
487   csize_t figure_expanded_capacities(CodeSection* which_cs, csize_t amount, csize_t* new_capacity);
488 
489  public:
490   // (1) code buffer referring to pre-allocated instruction memory
491   CodeBuffer(address code_start, csize_t code_size)
492     DEBUG_ONLY(: Scrubber(this, sizeof(*this)))
493   {
494     assert(code_start != NULL, "sanity");
495     initialize_misc("static buffer");
496     initialize(code_start, code_size);
497     debug_only(verify_section_allocation();)
498   }
499 
500   // (2) CodeBuffer referring to pre-allocated CodeBlob.
501   CodeBuffer(CodeBlob* blob);
502 
503   // (3) code buffer allocating codeBlob memory for code & relocation
504   // info but with lazy initialization.  The name must be something
505   // informative.
506   CodeBuffer(const char* name)
507     DEBUG_ONLY(: Scrubber(this, sizeof(*this)))
508   {
509     initialize_misc(name);
510   }
511 
512   // (4) code buffer allocating codeBlob memory for code & relocation
513   // info.  The name must be something informative and code_size must
514   // include both code and stubs sizes.
515   CodeBuffer(const char* name, csize_t code_size, csize_t locs_size)
516     DEBUG_ONLY(: Scrubber(this, sizeof(*this)))
517   {
518     initialize_misc(name);
519     initialize(code_size, locs_size);
520   }
521 
522   ~CodeBuffer();
523 
524   // Initialize a CodeBuffer constructed using constructor 3.  Using
525   // constructor 4 is equivalent to calling constructor 3 and then
526   // calling this method.  It's been factored out for convenience of
527   // construction.
528   void initialize(csize_t code_size, csize_t locs_size);
529 
530   CodeSection* consts() { return &_consts; }
531   CodeSection* insts() { return &_insts; }
532   CodeSection* stubs() { return &_stubs; }
533 
534   const CodeSection* insts() const { return &_insts; }
535 
536   // present sections in order; return NULL at end; consts is #0, etc.
537   CodeSection* code_section(int n) {
538     // This makes the slightly questionable but portable assumption
539     // that the various members (_consts, _insts, _stubs, etc.) are
540     // adjacent in the layout of CodeBuffer.
541     CodeSection* cs = &_consts + n;
542     assert(cs->index() == n || !cs->is_allocated(), "sanity");
543     return cs;
544   }
545   const CodeSection* code_section(int n) const {  // yucky const stuff
546     return ((CodeBuffer*)this)->code_section(n);
547   }
548   static const char* code_section_name(int n);
549   int section_index_of(address addr) const;
550   bool contains(address addr) const {
551     // handy for debugging
552     return section_index_of(addr) > SECT_NONE;
553   }
554 
555   // A stable mapping between 'locators' (small ints) and addresses.
556   static int locator_pos(int locator)   { return locator >> sect_bits; }
557   static int locator_sect(int locator)  { return locator &  sect_mask; }
558   static int locator(int pos, int sect) { return (pos << sect_bits) | sect; }
559   int        locator(address addr) const;
560   address    locator_address(int locator) const {
561     if (locator < 0)  return NULL;
562     address start = code_section(locator_sect(locator))->start();
563     return start + locator_pos(locator);
564   }
565 
566   // Heuristic for pre-packing the taken/not-taken bit of a predicted branch.
567   bool is_backward_branch(Label& L);
568 
569   // Properties
570   const char* name() const                  { return _name; }
571   void set_name(const char* name)           { _name = name; }
572   CodeBuffer* before_expand() const         { return _before_expand; }
573   BufferBlob* blob() const                  { return _blob; }
574   void    set_blob(BufferBlob* blob);
575   void   free_blob();                       // Free the blob, if we own one.
576 
577   // Properties relative to the insts section:
578   address       insts_begin() const      { return _insts.start();      }
579   address       insts_end() const        { return _insts.end();        }
580   void      set_insts_end(address end)   {        _insts.set_end(end); }
581   address       insts_mark() const       { return _insts.mark();       }
582   void      set_insts_mark()             {        _insts.set_mark();   }
583 
584   // is there anything in the buffer other than the current section?
585   bool    is_pure() const                { return insts_size() == total_content_size(); }
586 
587   // size in bytes of output so far in the insts sections
588   csize_t insts_size() const             { return _insts.size(); }
589 
590   // same as insts_size(), except that it asserts there is no non-code here
591   csize_t pure_insts_size() const        { assert(is_pure(), "no non-code");
592                                            return insts_size(); }
593   // capacity in bytes of the insts sections
594   csize_t insts_capacity() const         { return _insts.capacity(); }
595 
596   // number of bytes remaining in the insts section
597   csize_t insts_remaining() const        { return _insts.remaining(); }
598 
599   // is a given address in the insts section?  (2nd version is end-inclusive)
600   bool insts_contains(address pc) const  { return _insts.contains(pc); }
601   bool insts_contains2(address pc) const { return _insts.contains2(pc); }
602 
603   // Record any extra oops required to keep embedded metadata alive
604   void finalize_oop_references(const methodHandle& method);
605 
606   // Allocated size in all sections, when aligned and concatenated
607   // (this is the eventual state of the content in its final
608   // CodeBlob).
609   csize_t total_content_size() const;
610 
611   // Combined offset (relative to start of first section) of given
612   // section, as eventually found in the final CodeBlob.
613   csize_t total_offset_of(const CodeSection* cs) const;
614 
615   // allocated size of all relocation data, including index, rounded up
616   csize_t total_relocation_size() const;
617 
618   csize_t copy_relocations_to(address buf, csize_t buf_limit, bool only_inst) const;
619 
620   // allocated size of any and all recorded oops
621   csize_t total_oop_size() const {
622     OopRecorder* recorder = oop_recorder();
623     return (recorder == NULL)? 0: recorder->oop_size();
624   }
625 
626   // allocated size of any and all recorded metadata
627   csize_t total_metadata_size() const {
628     OopRecorder* recorder = oop_recorder();
629     return (recorder == NULL)? 0: recorder->metadata_size();
630   }
631 
632   // Configuration functions, called immediately after the CB is constructed.
633   // The section sizes are subtracted from the original insts section.
634   // Note:  Call them in reverse section order, because each steals from insts.
635   void initialize_consts_size(csize_t size)            { initialize_section_size(&_consts,  size); }
636   void initialize_stubs_size(csize_t size)             { initialize_section_size(&_stubs,   size); }
637   // Override default oop recorder.
638   void initialize_oop_recorder(OopRecorder* r);
639 
640   OopRecorder* oop_recorder() const { return _oop_recorder; }
641 
642   address last_insn() const { return _last_insn; }
643   void set_last_insn(address a) { _last_insn = a; }
644   void clear_last_insn() { set_last_insn(NULL); }
645 
646 #ifndef PRODUCT
647   AsmRemarks &asm_remarks() { return _asm_remarks; }
648   DbgStrings &dbg_strings() { return _dbg_strings; }
649 
650   void clear_strings() {
651     _asm_remarks.clear();
652     _dbg_strings.clear();
653   }
654 #endif
655 
656   // Code generation
657   void relocate(address at, RelocationHolder const& rspec, int format = 0) {
658     _insts.relocate(at, rspec, format);
659   }
660   void relocate(address at,    relocInfo::relocType rtype, int format = 0) {
661     _insts.relocate(at, rtype, format);
662   }
663 
664   // Management of overflow storage for binding of Labels.
665   GrowableArray<int>* create_patch_overflow();
666 
667   // NMethod generation
668   void copy_code_and_locs_to(CodeBlob* blob) {
669     assert(blob != NULL, "sane");
670     copy_relocations_to(blob);
671     copy_code_to(blob);
672   }
673   void copy_values_to(nmethod* nm) {
674     if (!oop_recorder()->is_unused()) {
675       oop_recorder()->copy_values_to(nm);
676     }
677   }
678 
679   void block_comment(ptrdiff_t offset, const char* comment) PRODUCT_RETURN;
680   const char* code_string(const char* str) PRODUCT_RETURN_(return NULL;);
681 
682   // Log a little info about section usage in the CodeBuffer
683   void log_section_sizes(const char* name);
684 
685 #ifndef PRODUCT
686  public:
687   // Printing / Decoding
688   // decodes from decode_begin() to code_end() and sets decode_begin to end
689   void    decode();
690   void    print();
691 #endif
692   // Directly disassemble code buffer.
693   void    decode(address start, address end);
694 
695   // The following header contains architecture-specific implementations
696 #include CPU_HEADER(codeBuffer)
697 
698 };
699 
700 inline bool CodeSection::maybe_expand_to_ensure_remaining(csize_t amount) {
701   if (remaining() < amount) { _outer->expand(this, amount); return true; }
702   return false;
703 }
704 
705 #endif // SHARE_ASM_CODEBUFFER_HPP