1 /* go-reflect-call.c -- call reflection support for Go.
3 Copyright 2009 The Go Authors. All rights reserved.
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file. */
13 #include "go-assert.h"
20 #if defined(USE_LIBFFI) && FFI_GO_CLOSURES
22 /* The functions in this file are only called from reflect_call. As
23 reflect_call calls a libffi function, which will be compiled
24 without -fsplit-stack, it will always run with a large stack. */
26 static size_t go_results_size (const struct __go_func_type
*)
27 __attribute__ ((no_split_stack
));
28 static void go_set_results (const struct __go_func_type
*, unsigned char *,
30 __attribute__ ((no_split_stack
));
32 /* Get the total size required for the result parameters of a
36 go_results_size (const struct __go_func_type
*func
)
39 const struct __go_type_descriptor
**types
;
44 count
= func
->__out
.__count
;
48 types
= (const struct __go_type_descriptor
**) func
->__out
.__values
;
50 /* A single integer return value is always promoted to a full
54 switch (types
[0]->__code
& GO_CODE_MASK
)
65 return sizeof (ffi_arg
);
74 for (i
= 0; i
< count
; ++i
)
78 align
= types
[i
]->__field_align
;
81 off
= (off
+ align
- 1) & ~ (align
- 1);
82 off
+= types
[i
]->__size
;
85 off
= (off
+ maxalign
- 1) & ~ (maxalign
- 1);
87 // The libffi library doesn't understand a struct with no fields.
88 // We generate a struct with a single field of type void. When used
89 // as a return value, libffi will think that requires a byte.
96 /* Copy the results of calling a function via FFI from CALL_RESULT
97 into the addresses in RESULTS. */
100 go_set_results (const struct __go_func_type
*func
, unsigned char *call_result
,
104 const struct __go_type_descriptor
**types
;
108 count
= func
->__out
.__count
;
112 types
= (const struct __go_type_descriptor
**) func
->__out
.__values
;
114 /* A single integer return value is always promoted to a full
118 switch (types
[0]->__code
& GO_CODE_MASK
)
132 unsigned char buf
[sizeof (ffi_arg
)];
137 __builtin_memcpy (&u
.buf
, call_result
, sizeof (ffi_arg
));
140 switch (types
[0]->__size
)
147 __builtin_memcpy (results
[0], &b
, 1);
156 __builtin_memcpy (results
[0], &s
, 2);
165 __builtin_memcpy (results
[0], &w
, 4);
174 __builtin_memcpy (results
[0], &d
, 8);
190 for (i
= 0; i
< count
; ++i
)
195 align
= types
[i
]->__field_align
;
196 size
= types
[i
]->__size
;
197 off
= (off
+ align
- 1) & ~ (align
- 1);
198 __builtin_memcpy (results
[i
], call_result
+ off
, size
);
203 /* The code that converts the Go type to an FFI type is written in Go,
204 so that it can allocate Go heap memory. */
205 extern void ffiFuncToCIF(const struct __go_func_type
*, _Bool
, _Bool
, ffi_cif
*)
206 __asm__ ("runtime.ffiFuncToCIF");
208 /* Call a function. The type of the function is FUNC_TYPE, and the
209 closure is FUNC_VAL. PARAMS is an array of parameter addresses.
210 RESULTS is an array of result addresses.
212 If IS_INTERFACE is true this is a call to an interface method and
213 the first argument is the receiver, which is always a pointer.
214 This argument, the receiver, is not described in FUNC_TYPE.
216 If IS_METHOD is true this is a call to a method expression. The
217 first argument is the receiver. It is described in FUNC_TYPE, but
218 regardless of FUNC_TYPE, it is passed as a pointer. */
221 reflect_call (const struct __go_func_type
*func_type
, FuncVal
*func_val
,
222 _Bool is_interface
, _Bool is_method
, void **params
,
226 unsigned char *call_result
;
228 __go_assert ((func_type
->__common
.__code
& GO_CODE_MASK
) == GO_FUNC
);
229 ffiFuncToCIF (func_type
, is_interface
, is_method
, &cif
);
231 call_result
= (unsigned char *) malloc (go_results_size (func_type
));
233 ffi_call_go (&cif
, func_val
->fn
, call_result
, params
, func_val
);
235 /* Some day we may need to free result values if RESULTS is
238 go_set_results (func_type
, call_result
, results
);
243 #else /* !defined(USE_LIBFFI) */
246 reflect_call (const struct __go_func_type
*func_type
__attribute__ ((unused
)),
247 FuncVal
*func_val
__attribute__ ((unused
)),
248 _Bool is_interface
__attribute__ ((unused
)),
249 _Bool is_method
__attribute__ ((unused
)),
250 void **params
__attribute__ ((unused
)),
251 void **results
__attribute__ ((unused
)))
253 /* Without FFI there is nothing we can do. */
254 runtime_throw("libgo built without FFI does not support "
255 "reflect.Call or runtime.SetFinalizer");
258 #endif /* !defined(USE_LIBFFI) */