c1_Compilation.hpp revision 3719:c3e799c37717 
1/*
2 * Copyright (c) 1999, 2011, 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_VM_C1_C1_COMPILATION_HPP
26#define SHARE_VM_C1_C1_COMPILATION_HPP
27
28#include "ci/ciEnv.hpp"
29#include "code/exceptionHandlerTable.hpp"
30#include "memory/resourceArea.hpp"
31
32class CompilationResourceObj;
33class XHandlers;
34class ExceptionInfo;
35class DebugInformationRecorder;
36class FrameMap;
37class IR;
38class IRScope;
39class Instruction;
40class LinearScan;
41class OopMap;
42class LIR_Emitter;
43class LIR_Assembler;
44class CodeEmitInfo;
45class ciEnv;
46class ciMethod;
47class ValueStack;
48class LIR_OprDesc;
49class C1_MacroAssembler;
50class CFGPrinter;
51typedef LIR_OprDesc* LIR_Opr;
52
53
54define_array(BasicTypeArray, BasicType)
55define_stack(BasicTypeList, BasicTypeArray)
56
57define_array(ExceptionInfoArray, ExceptionInfo*)
58define_stack(ExceptionInfoList,  ExceptionInfoArray)
59
60class Compilation: public StackObj {
61  friend class CompilationResourceObj;
62 private:
63  // compilation specifics
64  Arena* _arena;
65  int _next_id;
66  int _next_block_id;
67  AbstractCompiler*  _compiler;
68  ciEnv*             _env;
69  CompileLog*        _log;
70  ciMethod*          _method;
71  int                _osr_bci;
72  IR*                _hir;
73  int                _max_spills;
74  FrameMap*          _frame_map;
75  C1_MacroAssembler* _masm;
76  bool               _has_exception_handlers;
77  bool               _has_fpu_code;
78  bool               _has_unsafe_access;
79  bool               _would_profile;
80  bool               _has_method_handle_invokes;  // True if this method has MethodHandle invokes.
81  const char*        _bailout_msg;
82  ExceptionInfoList* _exception_info_list;
83  ExceptionHandlerTable _exception_handler_table;
84  ImplicitExceptionTable _implicit_exception_table;
85  LinearScan*        _allocator;
86  CodeOffsets        _offsets;
87  CodeBuffer         _code;
88
89  // compilation helpers
90  void initialize();
91  void build_hir();
92  void emit_lir();
93
94  void emit_code_epilog(LIR_Assembler* assembler);
95  int  emit_code_body();
96
97  int  compile_java_method();
98  void install_code(int frame_size);
99  void compile_method();
100
101  void generate_exception_handler_table();
102
103  ExceptionInfoList* exception_info_list() const { return _exception_info_list; }
104  ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; }
105
106  LinearScan* allocator()                          { return _allocator;      }
107  void        set_allocator(LinearScan* allocator) { _allocator = allocator; }
108
109  Instruction*       _current_instruction;       // the instruction currently being processed
110#ifndef PRODUCT
111  Instruction*       _last_instruction_printed;  // the last instruction printed during traversal
112#endif // PRODUCT
113
114 public:
115  // creation
116  Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method,
117              int osr_bci, BufferBlob* buffer_blob);
118  ~Compilation();
119
120
121  static Compilation* current() {
122    return (Compilation*) ciEnv::current()->compiler_data();
123  }
124
125  // accessors
126  ciEnv* env() const                             { return _env; }
127  CompileLog* log() const                        { return _log; }
128  AbstractCompiler* compiler() const             { return _compiler; }
129  bool has_exception_handlers() const            { return _has_exception_handlers; }
130  bool has_fpu_code() const                      { return _has_fpu_code; }
131  bool has_unsafe_access() const                 { return _has_unsafe_access; }
132  int max_vector_size() const                    { return 0; }
133  ciMethod* method() const                       { return _method; }
134  int osr_bci() const                            { return _osr_bci; }
135  bool is_osr_compile() const                    { return osr_bci() >= 0; }
136  IR* hir() const                                { return _hir; }
137  int max_spills() const                         { return _max_spills; }
138  FrameMap* frame_map() const                    { return _frame_map; }
139  CodeBuffer* code()                             { return &_code; }
140  C1_MacroAssembler* masm() const                { return _masm; }
141  CodeOffsets* offsets()                         { return &_offsets; }
142  Arena* arena()                                 { return _arena; }
143
144  // Instruction ids
145  int get_next_id()                              { return _next_id++; }
146  int number_of_instructions() const             { return _next_id; }
147
148  // BlockBegin ids
149  int get_next_block_id()                        { return _next_block_id++; }
150  int number_of_blocks() const                   { return _next_block_id; }
151
152  // setters
153  void set_has_exception_handlers(bool f)        { _has_exception_handlers = f; }
154  void set_has_fpu_code(bool f)                  { _has_fpu_code = f; }
155  void set_has_unsafe_access(bool f)             { _has_unsafe_access = f; }
156  void set_would_profile(bool f)                 { _would_profile = f; }
157  // Add a set of exception handlers covering the given PC offset
158  void add_exception_handlers_for_pco(int pco, XHandlers* exception_handlers);
159  // Statistics gathering
160  void notice_inlined_method(ciMethod* method);
161
162  // JSR 292
163  bool     has_method_handle_invokes() const { return _has_method_handle_invokes;     }
164  void set_has_method_handle_invokes(bool z) {        _has_method_handle_invokes = z; }
165
166  DebugInformationRecorder* debug_info_recorder() const; // = _env->debug_info();
167  Dependencies* dependency_recorder() const; // = _env->dependencies()
168  ImplicitExceptionTable* implicit_exception_table()     { return &_implicit_exception_table; }
169
170  Instruction* current_instruction() const       { return _current_instruction; }
171  Instruction* set_current_instruction(Instruction* instr) {
172    Instruction* previous = _current_instruction;
173    _current_instruction = instr;
174    return previous;
175  }
176
177#ifndef PRODUCT
178  void maybe_print_current_instruction();
179#endif // PRODUCT
180
181  // error handling
182  void bailout(const char* msg);
183  bool bailed_out() const                        { return _bailout_msg != NULL; }
184  const char* bailout_msg() const                { return _bailout_msg; }
185
186  static int desired_max_code_buffer_size() {
187#ifndef PPC
188    return (int) NMethodSizeLimit;  // default 256K or 512K
189#else
190    // conditional branches on PPC are restricted to 16 bit signed
191    return MIN2((unsigned int)NMethodSizeLimit,32*K);
192#endif
193  }
194  static int desired_max_constant_size() {
195    return desired_max_code_buffer_size() / 10;
196  }
197
198  static bool setup_code_buffer(CodeBuffer* cb, int call_stub_estimate);
199
200  // timers
201  static void print_timers();
202
203#ifndef PRODUCT
204  // debugging support.
205  // produces a file named c1compileonly in the current directory with
206  // directives to compile only the current method and it's inlines.
207  // The file can be passed to the command line option -XX:Flags=<filename>
208  void compile_only_this_method();
209  void compile_only_this_scope(outputStream* st, IRScope* scope);
210  void exclude_this_method();
211#endif // PRODUCT
212
213  bool is_profiling() {
214    return env()->comp_level() == CompLevel_full_profile ||
215           env()->comp_level() == CompLevel_limited_profile;
216  }
217  bool count_invocations() { return is_profiling(); }
218  bool count_backedges()   { return is_profiling(); }
219
220  // Helpers for generation of profile information
221  bool profile_branches() {
222    return env()->comp_level() == CompLevel_full_profile &&
223      C1UpdateMethodData && C1ProfileBranches;
224  }
225  bool profile_calls() {
226    return env()->comp_level() == CompLevel_full_profile &&
227      C1UpdateMethodData && C1ProfileCalls;
228  }
229  bool profile_inlined_calls() {
230    return profile_calls() && C1ProfileInlinedCalls;
231  }
232  bool profile_checkcasts() {
233    return env()->comp_level() == CompLevel_full_profile &&
234      C1UpdateMethodData && C1ProfileCheckcasts;
235  }
236};
237
238
239// Macro definitions for unified bailout-support
240// The methods bailout() and bailed_out() are present in all classes
241// that might bailout, but forward all calls to Compilation
242#define BAILOUT(msg)               { bailout(msg); return;              }
243#define BAILOUT_(msg, res)         { bailout(msg); return res;          }
244
245#define CHECK_BAILOUT()            { if (bailed_out()) return;          }
246#define CHECK_BAILOUT_(res)        { if (bailed_out()) return res;      }
247
248
249class InstructionMark: public StackObj {
250 private:
251  Compilation* _compilation;
252  Instruction*  _previous;
253
254 public:
255  InstructionMark(Compilation* compilation, Instruction* instr) {
256    _compilation = compilation;
257    _previous = _compilation->set_current_instruction(instr);
258  }
259  ~InstructionMark() {
260    _compilation->set_current_instruction(_previous);
261  }
262};
263
264
265//----------------------------------------------------------------------
266// Base class for objects allocated by the compiler in the compilation arena
267class CompilationResourceObj ALLOCATION_SUPER_CLASS_SPEC {
268 public:
269  void* operator new(size_t size) { return Compilation::current()->arena()->Amalloc(size); }
270  void* operator new(size_t size, Arena* arena) {
271    return arena->Amalloc(size);
272  }
273  void  operator delete(void* p) {} // nothing to do
274};
275
276
277//----------------------------------------------------------------------
278// Class for aggregating exception handler information.
279
280// Effectively extends XHandlers class with PC offset of
281// potentially exception-throwing instruction.
282// This class is used at the end of the compilation to build the
283// ExceptionHandlerTable.
284class ExceptionInfo: public CompilationResourceObj {
285 private:
286  int             _pco;                // PC of potentially exception-throwing instruction
287  XHandlers*      _exception_handlers; // flat list of exception handlers covering this PC
288
289 public:
290  ExceptionInfo(int pco, XHandlers* exception_handlers)
291    : _pco(pco)
292    , _exception_handlers(exception_handlers)
293  { }
294
295  int pco()                                      { return _pco; }
296  XHandlers* exception_handlers()                { return _exception_handlers; }
297};
298
299#endif // SHARE_VM_C1_C1_COMPILATION_HPP
300