interpreterRT_zero.cpp revision 13249:a2753984d2c1 
1/*
2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2007, 2008, 2010 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 "interpreter/interpreter.hpp"
28#include "interpreter/interpreterRuntime.hpp"
29#include "memory/allocation.inline.hpp"
30#include "memory/universe.inline.hpp"
31#include "oops/method.hpp"
32#include "oops/oop.inline.hpp"
33#include "runtime/handles.inline.hpp"
34#include "runtime/icache.hpp"
35#include "runtime/interfaceSupport.hpp"
36#include "runtime/signature.hpp"
37#include "stack_zero.inline.hpp"
38#include "utilities/align.hpp"
39
40void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_int() {
41  push(T_INT);
42  _cif->nargs++;
43}
44
45void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_long() {
46  push(T_LONG);
47  _cif->nargs++;
48}
49
50void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_float() {
51  push(T_FLOAT);
52  _cif->nargs++;
53}
54
55void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_double() {
56  push(T_DOUBLE);
57  _cif->nargs++;
58}
59
60void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_object() {
61  push(T_OBJECT);
62  _cif->nargs++;
63}
64
65void InterpreterRuntime::SignatureHandlerGeneratorBase::push(BasicType type) {
66  ffi_type *ftype = NULL;
67  switch (type) {
68  case T_VOID:
69    ftype = &ffi_type_void;
70    break;
71
72  case T_BOOLEAN:
73    ftype = &ffi_type_uint8;
74    break;
75
76  case T_CHAR:
77    ftype = &ffi_type_uint16;
78    break;
79
80  case T_BYTE:
81    ftype = &ffi_type_sint8;
82    break;
83
84  case T_SHORT:
85    ftype = &ffi_type_sint16;
86    break;
87
88  case T_INT:
89    ftype = &ffi_type_sint32;
90    break;
91
92  case T_LONG:
93    ftype = &ffi_type_sint64;
94    break;
95
96  case T_FLOAT:
97    ftype = &ffi_type_float;
98    break;
99
100  case T_DOUBLE:
101    ftype = &ffi_type_double;
102    break;
103
104  case T_OBJECT:
105  case T_ARRAY:
106    ftype = &ffi_type_pointer;
107    break;
108
109  default:
110    ShouldNotReachHere();
111  }
112  push((intptr_t) ftype);
113}
114
115// For fast signature handlers the "signature handler" is generated
116// into a temporary buffer.  It is then copied to its final location,
117// and pd_set_handler is called on it.  We have this two stage thing
118// to accomodate this.
119
120void InterpreterRuntime::SignatureHandlerGeneratorBase::generate(
121  uint64_t fingerprint) {
122
123  // Build the argument types list
124  pass_object();
125  if (method()->is_static())
126    pass_object();
127  iterate(fingerprint);
128
129  // Tack on the result type
130  push(method()->result_type());
131}
132
133void InterpreterRuntime::SignatureHandler::finalize() {
134  ffi_status status =
135    ffi_prep_cif(cif(),
136                 FFI_DEFAULT_ABI,
137                 argument_count(),
138                 result_type(),
139                 argument_types());
140
141  assert(status == FFI_OK, "should be");
142}
143
144IRT_ENTRY(address,
145          InterpreterRuntime::slow_signature_handler(JavaThread* thread,
146                                                     Method*     method,
147                                                     intptr_t*   unused1,
148                                                     intptr_t*   unused2))
149  ZeroStack *stack = thread->zero_stack();
150
151  int required_words =
152    (align_up(sizeof(ffi_cif), wordSize) >> LogBytesPerWord) +
153    (method->is_static() ? 2 : 1) + method->size_of_parameters() + 1;
154
155  stack->overflow_check(required_words, CHECK_NULL);
156
157  intptr_t *buf = (intptr_t *) stack->alloc(required_words * wordSize);
158  SlowSignatureHandlerGenerator sshg(methodHandle(thread, method), buf);
159  sshg.generate((uint64_t)CONST64(-1));
160
161  SignatureHandler *handler = sshg.handler();
162  handler->finalize();
163
164  return (address) handler;
165IRT_END
166
167void SignatureHandlerLibrary::pd_set_handler(address handlerAddr) {
168  InterpreterRuntime::SignatureHandler *handler =
169    InterpreterRuntime::SignatureHandler::from_handlerAddr(handlerAddr);
170
171  handler->finalize();
172}
173