1/*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2012, 2015 SAP SE. All rights reserved.
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#include "precompiled.hpp"
27#include "asm/macroAssembler.inline.hpp"
28#include "code/compiledIC.hpp"
29#include "code/icBuffer.hpp"
30#include "code/nmethod.hpp"
31#include "memory/resourceArea.hpp"
32#include "runtime/mutexLocker.hpp"
33#include "runtime/safepoint.hpp"
34#ifdef COMPILER2
35#include "opto/matcher.hpp"
36#endif
37
38// ----------------------------------------------------------------------------
39
40// A PPC CompiledDirectStaticCall looks like this:
41//
42// >>>> consts
43//
44// [call target1]
45// [IC cache]
46// [call target2]
47//
48// <<<< consts
49// >>>> insts
50//
51// bl offset16               -+  -+             ??? // How many bits available?
52//                            |   |
53// <<<< insts                 |   |
54// >>>> stubs                 |   |
55//                            |   |- trampoline_stub_Reloc
56// trampoline stub:           | <-+
57//   r2 = toc                 |
58//   r2 = [r2 + offset]       |       // Load call target1 from const section
59//   mtctr r2                 |
60//   bctr                     |- static_stub_Reloc
61// comp_to_interp_stub:   <---+
62//   r1 = toc
63//   ICreg = [r1 + IC_offset]         // Load IC from const section
64//   r1    = [r1 + offset]            // Load call target2 from const section
65//   mtctr r1
66//   bctr
67//
68// <<<< stubs
69//
70// The call instruction in the code either
71// - branches directly to a compiled method if offset encodable in instruction
72// - branches to the trampoline stub if offset to compiled method not encodable
73// - branches to the compiled_to_interp stub if target interpreted
74//
75// Further there are three relocations from the loads to the constants in
76// the constant section.
77//
78// Usage of r1 and r2 in the stubs allows to distinguish them.
79
80const int IC_pos_in_java_to_interp_stub = 8;
81#define __ _masm.
82address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf, address mark/* = NULL*/) {
83#ifdef COMPILER2
84  if (mark == NULL) {
85    // Get the mark within main instrs section which is set to the address of the call.
86    mark = cbuf.insts_mark();
87  }
88
89  // Note that the code buffer's insts_mark is always relative to insts.
90  // That's why we must use the macroassembler to generate a stub.
91  MacroAssembler _masm(&cbuf);
92
93  // Start the stub.
94  address stub = __ start_a_stub(CompiledStaticCall::to_interp_stub_size());
95  if (stub == NULL) {
96    return NULL; // CodeCache is full
97  }
98
99  // For java_to_interp stubs we use R11_scratch1 as scratch register
100  // and in call trampoline stubs we use R12_scratch2. This way we
101  // can distinguish them (see is_NativeCallTrampolineStub_at()).
102  Register reg_scratch = R11_scratch1;
103
104  // Create a static stub relocation which relates this stub
105  // with the call instruction at insts_call_instruction_offset in the
106  // instructions code-section.
107  __ relocate(static_stub_Relocation::spec(mark));
108  const int stub_start_offset = __ offset();
109
110  // Now, create the stub's code:
111  // - load the TOC
112  // - load the inline cache oop from the constant pool
113  // - load the call target from the constant pool
114  // - call
115  __ calculate_address_from_global_toc(reg_scratch, __ method_toc());
116  AddressLiteral ic = __ allocate_metadata_address((Metadata *)NULL);
117  bool success = __ load_const_from_method_toc(as_Register(Matcher::inline_cache_reg_encode()),
118                                               ic, reg_scratch, /*fixed_size*/ true);
119  if (!success) {
120    return NULL; // CodeCache is full
121  }
122
123  if (ReoptimizeCallSequences) {
124    __ b64_patchable((address)-1, relocInfo::none);
125  } else {
126    AddressLiteral a((address)-1);
127    success = __ load_const_from_method_toc(reg_scratch, a, reg_scratch, /*fixed_size*/ true);
128    if (!success) {
129      return NULL; // CodeCache is full
130    }
131    __ mtctr(reg_scratch);
132    __ bctr();
133  }
134
135  // FIXME: Assert that the stub can be identified and patched.
136
137  // Java_to_interp_stub_size should be good.
138  assert((__ offset() - stub_start_offset) <= CompiledStaticCall::to_interp_stub_size(),
139         "should be good size");
140  assert(!is_NativeCallTrampolineStub_at(__ addr_at(stub_start_offset)),
141         "must not confuse java_to_interp with trampoline stubs");
142
143 // End the stub.
144  __ end_a_stub();
145  return stub;
146#else
147  ShouldNotReachHere();
148  return NULL;
149#endif
150}
151#undef __
152
153// Size of java_to_interp stub, this doesn't need to be accurate but it must
154// be larger or equal to the real size of the stub.
155// Used for optimization in Compile::Shorten_branches.
156int CompiledStaticCall::to_interp_stub_size() {
157  return 12 * BytesPerInstWord;
158}
159
160// Relocation entries for call stub, compiled java to interpreter.
161// Used for optimization in Compile::Shorten_branches.
162int CompiledStaticCall::reloc_to_interp_stub() {
163  return 5;
164}
165
166void CompiledDirectStaticCall::set_to_interpreted(const methodHandle& callee, address entry) {
167  address stub = find_stub(/*is_aot*/ false);
168  guarantee(stub != NULL, "stub not found");
169
170  if (TraceICs) {
171    ResourceMark rm;
172    tty->print_cr("CompiledDirectStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
173                  p2i(instruction_address()),
174                  callee->name_and_sig_as_C_string());
175  }
176
177  // Creation also verifies the object.
178  NativeMovConstReg* method_holder = nativeMovConstReg_at(stub + IC_pos_in_java_to_interp_stub);
179  NativeJump*        jump          = nativeJump_at(method_holder->next_instruction_address());
180
181#ifdef ASSERT
182  // read the value once
183  volatile intptr_t data = method_holder->data();
184  volatile address destination = jump->jump_destination();
185  assert(data == 0 || data == (intptr_t)callee(),
186         "a) MT-unsafe modification of inline cache");
187  assert(destination == (address)-1 || destination == entry,
188         "b) MT-unsafe modification of inline cache");
189#endif
190
191  // Update stub.
192  method_holder->set_data((intptr_t)callee());
193  jump->set_jump_destination(entry);
194
195  // Update jump to call.
196  set_destination_mt_safe(stub);
197}
198
199void CompiledDirectStaticCall::set_stub_to_clean(static_stub_Relocation* static_stub) {
200  assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
201  // Reset stub.
202  address stub = static_stub->addr();
203  assert(stub != NULL, "stub not found");
204  // Creation also verifies the object.
205  NativeMovConstReg* method_holder = nativeMovConstReg_at(stub + IC_pos_in_java_to_interp_stub);
206  NativeJump*        jump          = nativeJump_at(method_holder->next_instruction_address());
207  method_holder->set_data(0);
208  jump->set_jump_destination((address)-1);
209}
210
211//-----------------------------------------------------------------------------
212// Non-product mode code
213#ifndef PRODUCT
214
215void CompiledDirectStaticCall::verify() {
216  // Verify call.
217  _call->verify();
218  if (os::is_MP()) {
219    _call->verify_alignment();
220  }
221
222  // Verify stub.
223  address stub = find_stub(/*is_aot*/ false);
224  assert(stub != NULL, "no stub found for static call");
225  // Creation also verifies the object.
226  NativeMovConstReg* method_holder = nativeMovConstReg_at(stub + IC_pos_in_java_to_interp_stub);
227  NativeJump*        jump          = nativeJump_at(method_holder->next_instruction_address());
228
229  // Verify state.
230  assert(is_clean() || is_call_to_compiled() || is_call_to_interpreted(), "sanity check");
231}
232
233#endif // !PRODUCT
234