1/* The library used by gdb.
2   Copyright (C) 2014-2022 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */
19
20#include <cc1plugin-config.h>
21#include <vector>
22#include <string>
23#include <sys/socket.h>
24#include <sys/types.h>
25#include <unistd.h>
26#include <sys/wait.h>
27#include <stdio.h>
28#include <errno.h>
29#include <sys/stat.h>
30#include <stdlib.h>
31#include "marshall-cp.hh"
32#include "rpc.hh"
33#include "connection.hh"
34#include "names.hh"
35#include "callbacks.hh"
36#include "libiberty.h"
37#include "compiler-name.hh"
38#include "compiler.hh"
39#include "gdbctx.hh"
40
41// The C compiler context that we hand back to our caller.
42struct libcp1 : public cc1_plugin::base_gdb_plugin<gcc_cp_context>
43{
44  explicit libcp1 (const gcc_cp_fe_vtable *);
45
46  void add_callbacks () override;
47
48  gcc_cp_oracle_function *binding_oracle = nullptr;
49  gcc_cp_symbol_address_function *address_oracle = nullptr;
50  gcc_cp_enter_leave_user_expr_scope_function *enter_scope = nullptr;
51  gcc_cp_enter_leave_user_expr_scope_function *leave_scope = nullptr;
52  void *oracle_datum = nullptr;
53};
54
55libcp1::libcp1 (const gcc_cp_fe_vtable *cv)
56  : cc1_plugin::base_gdb_plugin<gcc_cp_context> ("libcp1plugin",
57						 CP_COMPILER_NAME,
58						 GCC_CP_FE_VERSION_0)
59{
60  cp_ops = cv;
61}
62
63
64
65// Enclose these functions in an anonymous namespace because they
66// shouldn't be exported, but they can't be static because they're
67// used as template arguments.
68namespace {
69  // This is a wrapper function that is called by the RPC system and
70  // that then forwards the call to the library user.  Note that the
71  // return value is not used; the type cannot be 'void' due to
72  // limitations in our simple RPC.
73  int
74  cp_call_binding_oracle (cc1_plugin::connection *conn,
75		       enum gcc_cp_oracle_request request,
76		       const char *identifier)
77  {
78    libcp1 *self = (libcp1 *) (((libcp1::local_connection *) conn)->back_ptr);
79
80    self->binding_oracle (self->oracle_datum, self, request, identifier);
81    return 1;
82  }
83
84  // This is a wrapper function that is called by the RPC system and
85  // that then forwards the call to the library user.
86  gcc_address
87  cp_call_symbol_address (cc1_plugin::connection *conn, const char *identifier)
88  {
89    libcp1 *self = (libcp1 *) (((libcp1::local_connection *) conn)->back_ptr);
90
91    return self->address_oracle (self->oracle_datum, self, identifier);
92  }
93
94  int
95  cp_call_enter_scope (cc1_plugin::connection *conn)
96  {
97    libcp1 *self = (libcp1 *) (((libcp1::local_connection *) conn)->back_ptr);
98
99    self->enter_scope (self->oracle_datum, self);
100    return 1;
101  }
102
103  int
104  cp_call_leave_scope (cc1_plugin::connection *conn)
105  {
106    libcp1 *self = (libcp1 *) (((libcp1::local_connection *) conn)->back_ptr);
107
108    self->leave_scope (self->oracle_datum, self);
109    return 1;
110  }
111} /* anonymous namespace */
112
113
114
115static void
116set_callbacks (struct gcc_cp_context *s,
117	       gcc_cp_oracle_function *binding_oracle,
118	       gcc_cp_symbol_address_function *address_oracle,
119	       gcc_cp_enter_leave_user_expr_scope_function *enter_scope,
120	       gcc_cp_enter_leave_user_expr_scope_function *leave_scope,
121	       void *datum)
122{
123  libcp1 *self = (libcp1 *) s;
124
125  self->binding_oracle = binding_oracle;
126  self->address_oracle = address_oracle;
127  self->enter_scope = enter_scope;
128  self->leave_scope = leave_scope;
129  self->oracle_datum = datum;
130}
131
132static const struct gcc_cp_fe_vtable cp_vtable =
133{
134  GCC_CP_FE_VERSION_0,
135  set_callbacks,
136
137#define GCC_METHOD0(R, N) \
138  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N>,
139#define GCC_METHOD1(R, N, A) \
140  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A>,
141#define GCC_METHOD2(R, N, A, B) \
142  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A, B>,
143#define GCC_METHOD3(R, N, A, B, C) \
144  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A, B, C>,
145#define GCC_METHOD4(R, N, A, B, C, D) \
146  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A, B, C, D>,
147#define GCC_METHOD5(R, N, A, B, C, D, E) \
148  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A, B, C, D, E>,
149#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
150  cc1_plugin::rpc<gcc_cp_context, R, cc1_plugin::cp::N, A, B, C, D, E, F, G>,
151
152#include "gcc-cp-fe.def"
153
154#undef GCC_METHOD0
155#undef GCC_METHOD1
156#undef GCC_METHOD2
157#undef GCC_METHOD3
158#undef GCC_METHOD4
159#undef GCC_METHOD5
160#undef GCC_METHOD7
161};
162
163
164
165void
166libcp1::add_callbacks ()
167{
168  cc1_plugin::callback_ftype *fun
169    = cc1_plugin::invoker<int, enum gcc_cp_oracle_request,
170			  const char *>::invoke<cp_call_binding_oracle>;
171  connection->add_callback ("binding_oracle", fun);
172
173  fun = cc1_plugin::invoker<gcc_address,
174			    const char *>::invoke<cp_call_symbol_address>;
175  connection->add_callback ("address_oracle", fun);
176
177  fun = cc1_plugin::invoker<int>::invoke<cp_call_enter_scope>;
178  connection->add_callback ("enter_scope", fun);
179
180  fun = cc1_plugin::invoker<int>::invoke<cp_call_leave_scope>;
181  connection->add_callback ("leave_scope", fun);
182}
183
184extern "C" gcc_cp_fe_context_function gcc_cp_fe_context;
185
186#ifdef __GNUC__
187#pragma GCC visibility push(default)
188#endif
189
190extern "C"
191struct gcc_cp_context *
192gcc_cp_fe_context (enum gcc_base_api_version base_version,
193		    enum gcc_cp_api_version cp_version)
194{
195  if ((base_version != GCC_FE_VERSION_0 && base_version != GCC_FE_VERSION_1)
196      || cp_version != GCC_CP_FE_VERSION_0)
197    return NULL;
198
199  return new libcp1 (&cp_vtable);
200}
201