sharkCompiler.hpp revision 1879:f95d63e2154a 
1/*
2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2008, 2009 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26#ifndef SHARE_VM_SHARK_SHARKCOMPILER_HPP
27#define SHARE_VM_SHARK_SHARKCOMPILER_HPP
28
29#include "ci/ciEnv.hpp"
30#include "ci/ciMethod.hpp"
31#include "compiler/abstractCompiler.hpp"
32#include "compiler/compileBroker.hpp"
33#include "shark/llvmHeaders.hpp"
34#include "shark/sharkMemoryManager.hpp"
35
36class SharkContext;
37
38class SharkCompiler : public AbstractCompiler {
39 public:
40  // Creation
41  SharkCompiler();
42
43  // Name of this compiler
44  const char *name()     { return "shark"; }
45
46  // Missing feature tests
47  bool supports_native() { return true; }
48  bool supports_osr()    { return true; }
49
50  // Customization
51  bool needs_adapters()  { return false; }
52  bool needs_stubs()     { return false; }
53
54  // Initialization
55  void initialize();
56
57  // Compile a normal (bytecode) method and install it in the VM
58  void compile_method(ciEnv* env, ciMethod* target, int entry_bci);
59
60  // Generate a wrapper for a native (JNI) method
61  nmethod* generate_native_wrapper(MacroAssembler* masm,
62                                   methodHandle    target,
63                                   BasicType*      arg_types,
64                                   BasicType       return_type);
65
66  // Free compiled methods (and native wrappers)
67  void free_compiled_method(address code);
68
69  // Each thread generating IR needs its own context.  The normal
70  // context is used for bytecode methods, and is protected from
71  // multiple simultaneous accesses by being restricted to the
72  // compiler thread.  The native context is used for JNI methods,
73  // and is protected from multiple simultaneous accesses by the
74  // adapter handler library lock.
75 private:
76  SharkContext* _normal_context;
77  SharkContext* _native_context;
78
79 public:
80  SharkContext* context() const {
81    if (JavaThread::current()->is_Compiler_thread()) {
82      return _normal_context;
83    }
84    else {
85      assert(AdapterHandlerLibrary_lock->owned_by_self(), "should be");
86      return _native_context;
87    }
88  }
89
90  // The LLVM execution engine is the JIT we use to generate native
91  // code.  It is thread safe, but we need to protect it with a lock
92  // of our own because otherwise LLVM's lock and HotSpot's locks
93  // interleave and deadlock.  The SharkMemoryManager is not thread
94  // safe, and is protected by the same lock as the execution engine.
95 private:
96  Monitor*               _execution_engine_lock;
97  SharkMemoryManager*    _memory_manager;
98  llvm::ExecutionEngine* _execution_engine;
99
100 private:
101  Monitor* execution_engine_lock() const {
102    return _execution_engine_lock;
103  }
104  SharkMemoryManager* memory_manager() const {
105    assert(execution_engine_lock()->owned_by_self(), "should be");
106    return _memory_manager;
107  }
108  llvm::ExecutionEngine* execution_engine() const {
109    assert(execution_engine_lock()->owned_by_self(), "should be");
110    return _execution_engine;
111  }
112
113  // Global access
114 public:
115  static SharkCompiler* compiler() {
116    AbstractCompiler *compiler = CompileBroker::compiler(CompLevel_simple);
117    assert(compiler->is_shark() && compiler->is_initialized(), "should be");
118    return (SharkCompiler *) compiler;
119  }
120
121  // Helpers
122 private:
123  static const char* methodname(const char* klass, const char* method);
124  void generate_native_code(SharkEntry*     entry,
125                            llvm::Function* function,
126                            const char*     name);
127  void free_queued_methods();
128};
129
130#endif // SHARE_VM_SHARK_SHARKCOMPILER_HPP
131