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