sharedRuntime_zero.cpp revision 3602:da91efe96a93 
1/*
2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2007, 2008, 2009, 2010, 2011 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#include "precompiled.hpp"
27#include "asm/assembler.hpp"
28#include "assembler_zero.inline.hpp"
29#include "code/debugInfoRec.hpp"
30#include "code/icBuffer.hpp"
31#include "code/vtableStubs.hpp"
32#include "interpreter/interpreter.hpp"
33#include "oops/compiledICHolder.hpp"
34#include "prims/jvmtiRedefineClassesTrace.hpp"
35#include "runtime/sharedRuntime.hpp"
36#include "runtime/vframeArray.hpp"
37#include "vmreg_zero.inline.hpp"
38#ifdef COMPILER1
39#include "c1/c1_Runtime1.hpp"
40#endif
41#ifdef COMPILER2
42#include "opto/runtime.hpp"
43#endif
44#ifdef SHARK
45#include "compiler/compileBroker.hpp"
46#include "shark/sharkCompiler.hpp"
47#endif
48
49
50int SharedRuntime::java_calling_convention(const BasicType *sig_bt,
51                                           VMRegPair *regs,
52                                           int total_args_passed,
53                                           int is_outgoing) {
54  return 0;
55}
56
57AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(
58                        MacroAssembler *masm,
59                        int total_args_passed,
60                        int comp_args_on_stack,
61                        const BasicType *sig_bt,
62                        const VMRegPair *regs,
63                        AdapterFingerPrint *fingerprint) {
64  return AdapterHandlerLibrary::new_entry(
65    fingerprint,
66    ShouldNotCallThisStub(),
67    ShouldNotCallThisStub(),
68    ShouldNotCallThisStub());
69}
70
71nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
72                                                methodHandle method,
73                                                int compile_id,
74                                                int total_args_passed,
75                                                int max_arg,
76                                                BasicType *sig_bt,
77                                                VMRegPair *regs,
78                                                BasicType ret_type) {
79#ifdef SHARK
80  return SharkCompiler::compiler()->generate_native_wrapper(masm,
81                                                            method,
82                                                            compile_id,
83                                                            sig_bt,
84                                                            ret_type);
85#else
86  ShouldNotCallThis();
87#endif // SHARK
88}
89
90int Deoptimization::last_frame_adjust(int callee_parameters,
91                                      int callee_locals) {
92  return 0;
93}
94
95uint SharedRuntime::out_preserve_stack_slots() {
96  ShouldNotCallThis();
97}
98
99static RuntimeStub* generate_empty_runtime_stub(const char* name) {
100  CodeBuffer buffer(name, 0, 0);
101  return RuntimeStub::new_runtime_stub(name, &buffer, 0, 0, NULL, false);
102}
103
104static SafepointBlob* generate_empty_safepoint_blob() {
105  CodeBuffer buffer("handler_blob", 0, 0);
106  return SafepointBlob::create(&buffer, NULL, 0);
107}
108
109static DeoptimizationBlob* generate_empty_deopt_blob() {
110  CodeBuffer buffer("handler_blob", 0, 0);
111  return DeoptimizationBlob::create(&buffer, NULL, 0, 0, 0, 0);
112}
113
114
115void SharedRuntime::generate_deopt_blob() {
116  _deopt_blob = generate_empty_deopt_blob();
117}
118
119SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, bool cause_return) {
120  return generate_empty_safepoint_blob();
121}
122
123RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) {
124  return generate_empty_runtime_stub("resolve_blob");
125}
126
127int SharedRuntime::c_calling_convention(const BasicType *sig_bt,
128                                         VMRegPair *regs,
129                                         int total_args_passed) {
130  ShouldNotCallThis();
131}
132