libcc1/gdbctx.hh - rust-lang/gcc - Git at Google

 /* Generic GDB-side plugin
    Copyright (C) 2020 Free Software Foundation, Inc.

 This file is part of GCC.

 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 Software Foundation; either version 3, or (at your option) any later
 version.

 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.

 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */

 #ifndef CC1_PLUGIN_GDBCTX_HH
 #define CC1_PLUGIN_GDBCTX_HH

 namespace cc1_plugin
 {
   // The compiler context that we hand back to our caller.
   // Due to this, the entire implementation is in this header.
   template<typename T>
   struct base_gdb_plugin : public T
   {
     base_gdb_plugin (const char *plugin_name_, const char *base_name,
 		     int version)
       : verbose (false),
 	plugin_name (plugin_name_),
 	fe_version (version),
 	compiler_name (base_name),
 	compilerp (new compiler (verbose))
     {
       vtable =
 	{
 	  GCC_FE_VERSION_1,
 	  do_set_arguments_v0,
 	  do_set_source_file,
 	  do_set_print_callback,
 	  do_compile_v0,
 	  do_destroy,
 	  do_set_verbose,
 	  do_compile,
 	  do_set_arguments,
 	  do_set_triplet_regexp,
 	  do_set_driver_filename,
 	};

       this->base.ops = &vtable;
     }

     virtual ~base_gdb_plugin () = default;

     // A convenience function to print something.
     void print (const char *str)
     {
       this->print_function (this->print_datum, str);
     }

     // Set the verbose flag.
     void set_verbose (bool v)
     {
       verbose = v;
       if (compilerp != nullptr)
 	compilerp->set_verbose (v);
     }

     // Make a new connection.
     void set_connection (int fd, int aux_fd)
     {
       connection.reset (new local_connection (fd, aux_fd, this));
     }

     // This is called just before compilation begins.  It should set
     // any needed callbacks on the connection.
     virtual void add_callbacks () = 0;

     // A local subclass of connection that holds a back-pointer to the
     // context object that we provide to our caller.
     class local_connection : public cc1_plugin::connection
     {
     public:

       local_connection (int fd, int aux_fd, base_gdb_plugin<T> *b)
 	: connection (fd, aux_fd),
 	  back_ptr (b)
       {
       }

       void print (const char *buf) override
       {
 	back_ptr->print (buf);
       }

       base_gdb_plugin<T> *back_ptr;
     };

     std::unique_ptr<local_connection> connection;

     void (*print_function) (void *datum, const char *message) = nullptr;
     void *print_datum = nullptr;

     std::vector<std::string> args;
     std::string source_file;

     /* Non-zero as an equivalent to gcc driver option "-v".  */
     bool verbose;

     const char *plugin_name;
     int fe_version;

     const char *compiler_name;
     std::unique_ptr<cc1_plugin::compiler> compilerp;

   private:

     struct gcc_base_vtable vtable;

     static inline base_gdb_plugin<T> *
     get_self (gcc_base_context *s)
     {
       T *sub = (T *) s;
       return static_cast<base_gdb_plugin<T> *> (sub);
     }

     static void
     do_set_verbose (struct gcc_base_context *s, int /* bool */ verbose)
     {
       base_gdb_plugin<T> *self = get_self (s);

       self->set_verbose (verbose != 0);
     }

     static char *
     do_set_arguments (struct gcc_base_context *s,
 		      int argc, char **argv)
     {
       base_gdb_plugin<T> *self = get_self (s);

       std::string compiler;
       char *errmsg = self->compilerp->find (self->compiler_name, compiler);
       if (errmsg != NULL)
 	return errmsg;

       self->args.push_back (compiler);

       for (int i = 0; i < argc; ++i)
 	self->args.push_back (argv[i]);

       return NULL;
     }

     static char *
     do_set_triplet_regexp (struct gcc_base_context *s,
 			   const char *triplet_regexp)
     {
       base_gdb_plugin<T> *self = get_self (s);

       self->compilerp.reset
 	(new cc1_plugin::compiler_triplet_regexp (self->verbose,
 						  triplet_regexp));
       return NULL;
     }

     static char *
     do_set_driver_filename (struct gcc_base_context *s,
 			    const char *driver_filename)
     {
       base_gdb_plugin<T> *self = get_self (s);

       self->compilerp.reset
 	(new cc1_plugin::compiler_driver_filename (self->verbose,
 						   driver_filename));
       return NULL;
     }

     static char *
     do_set_arguments_v0 (struct gcc_base_context *s,
 			 const char *triplet_regexp,
 			 int argc, char **argv)
     {
       char *errmsg = do_set_triplet_regexp (s, triplet_regexp);
       if (errmsg != NULL)
 	return errmsg;

       return do_set_arguments (s, argc, argv);
     }

     static void
     do_set_source_file (struct gcc_base_context *s,
 			const char *file)
     {
       base_gdb_plugin<T> *self = get_self (s);

       self->source_file = file;
     }

     static void
     do_set_print_callback (struct gcc_base_context *s,
 			   void (*print_function) (void *datum,
 						   const char *message),
 			   void *datum)
     {
       base_gdb_plugin<T> *self = get_self (s);

       self->print_function = print_function;
       self->print_datum = datum;
     }

     int fork_exec (char **argv, int spair_fds[2], int stderr_fds[2])
     {
       pid_t child_pid = fork ();

       if (child_pid == -1)
 	{
 	  close (spair_fds[0]);
 	  close (spair_fds[1]);
 	  close (stderr_fds[0]);
 	  close (stderr_fds[1]);
 	  return 0;
 	}

       if (child_pid == 0)
 	{
 	  // Child.
 	  dup2 (stderr_fds[1], 1);
 	  dup2 (stderr_fds[1], 2);
 	  close (stderr_fds[0]);
 	  close (stderr_fds[1]);
 	  close (spair_fds[0]);

 	  execvp (argv[0], argv);
 	  _exit (127);
 	}
       else
 	{
 	  // Parent.
 	  close (spair_fds[1]);
 	  close (stderr_fds[1]);

 	  cc1_plugin::status result = cc1_plugin::FAIL;
 	  if (connection->send ('H')
 	      && ::cc1_plugin::marshall (connection.get (), fe_version))
 	    result = connection->wait_for_query ();

 	  close (spair_fds[0]);
 	  close (stderr_fds[0]);

 	  while (true)
 	    {
 	      int status;

 	      if (waitpid (child_pid, &status, 0) == -1)
 		{
 		  if (errno != EINTR)
 		    return 0;
 		}

 	      if (!WIFEXITED (status) || WEXITSTATUS (status) != 0)
 		return 0;
 	      break;
 	    }

 	  if (!result)
 	    return 0;
 	  return 1;
 	}
     }

     static int
     do_compile (struct gcc_base_context *s,
 		const char *filename)
     {
       base_gdb_plugin<T> *self = get_self (s);

       int fds[2];
       if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) != 0)
 	{
 	  self->print ("could not create socketpair\n");
 	  return 0;
 	}

       int stderr_fds[2];
       if (pipe (stderr_fds) != 0)
 	{
 	  self->print ("could not create pipe\n");
 	  close (fds[0]);
 	  close (fds[1]);
 	  return 0;
 	}

       self->args.push_back (std::string ("-fplugin=") + self->plugin_name);
       self->args.push_back (std::string ("-fplugin-arg-") + self->plugin_name
 			    + "-fd=" + std::to_string (fds[1]));

       self->args.push_back (self->source_file);
       self->args.push_back ("-c");
       self->args.push_back ("-o");
       self->args.push_back (filename);
       if (self->verbose)
 	self->args.push_back ("-v");

       self->set_connection (fds[0], stderr_fds[0]);

       self->add_callbacks ();

       std::vector<char *> argv (self->args.size () + 1);
       for (unsigned int i = 0; i < self->args.size (); ++i)
 	argv[i] = const_cast<char *> (self->args[i].c_str ());

       return self->fork_exec (argv.data (), fds, stderr_fds);
     }

     static int
     do_compile_v0 (struct gcc_base_context *s, const char *filename,
 		   int verbose)
     {
       do_set_verbose (s, verbose);
       return do_compile (s, filename);
     }

     static void
     do_destroy (struct gcc_base_context *s)
     {
       base_gdb_plugin<T> *self = get_self (s);

       delete self;
     }
   };

   // Instances of this rpc<> template function are installed into the
   // "vtable"s.  These functions are parameterized by type and method
   // name and forward the call via the connection.
   template<typename CTX, typename R, const char *&NAME, typename... Arg>
   R rpc (CTX *s, Arg... rest)
   {
     base_gdb_plugin<CTX> *self = (base_gdb_plugin<CTX> *) s;
     R result;

     if (!cc1_plugin::call (self->connection.get (), NAME, &result, rest...))
       return 0;
     return result;
   }
 }

 #endif // CC1_PLUGIN_GDBCTX_HH
	/* Generic GDB-side plugin
	Copyright (C) 2020 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 3, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING3. If not see
	<http://www.gnu.org/licenses/>. */

	#ifndef CC1_PLUGIN_GDBCTX_HH
	#define CC1_PLUGIN_GDBCTX_HH

	namespace cc1_plugin
	{
	// The compiler context that we hand back to our caller.
	// Due to this, the entire implementation is in this header.
	template<typename T>
	struct base_gdb_plugin : public T
	{
	base_gdb_plugin (const char plugin_name_, const char base_name,
	int version)
	: verbose (false),
	plugin_name (plugin_name_),
	fe_version (version),
	compiler_name (base_name),
	compilerp (new compiler (verbose))
	{
	vtable =
	{
	GCC_FE_VERSION_1,
	do_set_arguments_v0,
	do_set_source_file,
	do_set_print_callback,
	do_compile_v0,
	do_destroy,
	do_set_verbose,
	do_compile,
	do_set_arguments,
	do_set_triplet_regexp,
	do_set_driver_filename,
	};

	this->base.ops = &vtable;
	}

	virtual ~base_gdb_plugin () = default;

	// A convenience function to print something.
	void print (const char *str)
	{
	this->print_function (this->print_datum, str);
	}

	// Set the verbose flag.
	void set_verbose (bool v)
	{
	verbose = v;
	if (compilerp != nullptr)
	compilerp->set_verbose (v);
	}

	// Make a new connection.
	void set_connection (int fd, int aux_fd)
	{
	connection.reset (new local_connection (fd, aux_fd, this));
	}

	// This is called just before compilation begins. It should set
	// any needed callbacks on the connection.
	virtual void add_callbacks () = 0;

	// A local subclass of connection that holds a back-pointer to the
	// context object that we provide to our caller.
	class local_connection : public cc1_plugin::connection
	{
	public:

	local_connection (int fd, int aux_fd, base_gdb_plugin<T> *b)
	: connection (fd, aux_fd),
	back_ptr (b)
	{
	}

	void print (const char *buf) override
	{
	back_ptr->print (buf);
	}

	base_gdb_plugin<T> *back_ptr;
	};

	std::unique_ptr<local_connection> connection;

	void (print_function) (void datum, const char *message) = nullptr;
	void *print_datum = nullptr;

	std::vector<std::string> args;
	std::string source_file;

	/* Non-zero as an equivalent to gcc driver option "-v". */
	bool verbose;

	const char *plugin_name;
	int fe_version;

	const char *compiler_name;
	std::unique_ptr<cc1_plugin::compiler> compilerp;

	private:

	struct gcc_base_vtable vtable;

	static inline base_gdb_plugin<T> *
	get_self (gcc_base_context *s)
	{
	T sub = (T ) s;
	return static_cast<base_gdb_plugin<T> *> (sub);
	}

	static void
	do_set_verbose (struct gcc_base_context s, int / bool */ verbose)
	{
	base_gdb_plugin<T> *self = get_self (s);

	self->set_verbose (verbose != 0);
	}

	static char *
	do_set_arguments (struct gcc_base_context *s,
	int argc, char **argv)
	{
	base_gdb_plugin<T> *self = get_self (s);

	std::string compiler;
	char *errmsg = self->compilerp->find (self->compiler_name, compiler);
	if (errmsg != NULL)
	return errmsg;

	self->args.push_back (compiler);

	for (int i = 0; i < argc; ++i)
	self->args.push_back (argv[i]);

	return NULL;
	}

	static char *
	do_set_triplet_regexp (struct gcc_base_context *s,
	const char *triplet_regexp)
	{
	base_gdb_plugin<T> *self = get_self (s);

	self->compilerp.reset
	(new cc1_plugin::compiler_triplet_regexp (self->verbose,
	triplet_regexp));
	return NULL;
	}

	static char *
	do_set_driver_filename (struct gcc_base_context *s,
	const char *driver_filename)
	{
	base_gdb_plugin<T> *self = get_self (s);

	self->compilerp.reset
	(new cc1_plugin::compiler_driver_filename (self->verbose,
	driver_filename));
	return NULL;
	}

	static char *
	do_set_arguments_v0 (struct gcc_base_context *s,
	const char *triplet_regexp,
	int argc, char **argv)
	{
	char *errmsg = do_set_triplet_regexp (s, triplet_regexp);
	if (errmsg != NULL)
	return errmsg;

	return do_set_arguments (s, argc, argv);
	}

	static void
	do_set_source_file (struct gcc_base_context *s,
	const char *file)
	{
	base_gdb_plugin<T> *self = get_self (s);

	self->source_file = file;
	}

	static void
	do_set_print_callback (struct gcc_base_context *s,
	void (print_function) (void datum,
	const char *message),
	void *datum)
	{
	base_gdb_plugin<T> *self = get_self (s);

	self->print_function = print_function;
	self->print_datum = datum;
	}

	int fork_exec (char **argv, int spair_fds[2], int stderr_fds[2])
	{
	pid_t child_pid = fork ();

	if (child_pid == -1)
	{
	close (spair_fds[0]);
	close (spair_fds[1]);
	close (stderr_fds[0]);
	close (stderr_fds[1]);
	return 0;
	}

	if (child_pid == 0)
	{
	// Child.
	dup2 (stderr_fds[1], 1);
	dup2 (stderr_fds[1], 2);
	close (stderr_fds[0]);
	close (stderr_fds[1]);
	close (spair_fds[0]);

	execvp (argv[0], argv);
	_exit (127);
	}
	else
	{
	// Parent.
	close (spair_fds[1]);
	close (stderr_fds[1]);

	cc1_plugin::status result = cc1_plugin::FAIL;
	if (connection->send ('H')
	&& ::cc1_plugin::marshall (connection.get (), fe_version))
	result = connection->wait_for_query ();

	close (spair_fds[0]);
	close (stderr_fds[0]);

	while (true)
	{
	int status;

	if (waitpid (child_pid, &status, 0) == -1)
	{
	if (errno != EINTR)
	return 0;
	}

	if (!WIFEXITED (status) \|\| WEXITSTATUS (status) != 0)
	return 0;
	break;
	}

	if (!result)
	return 0;
	return 1;
	}
	}

	static int
	do_compile (struct gcc_base_context *s,
	const char *filename)
	{
	base_gdb_plugin<T> *self = get_self (s);

	int fds[2];
	if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) != 0)
	{
	self->print ("could not create socketpair\n");
	return 0;
	}

	int stderr_fds[2];
	if (pipe (stderr_fds) != 0)
	{
	self->print ("could not create pipe\n");
	close (fds[0]);
	close (fds[1]);
	return 0;
	}

	self->args.push_back (std::string ("-fplugin=") + self->plugin_name);
	self->args.push_back (std::string ("-fplugin-arg-") + self->plugin_name
	+ "-fd=" + std::to_string (fds[1]));

	self->args.push_back (self->source_file);
	self->args.push_back ("-c");
	self->args.push_back ("-o");
	self->args.push_back (filename);
	if (self->verbose)
	self->args.push_back ("-v");

	self->set_connection (fds[0], stderr_fds[0]);

	self->add_callbacks ();

	std::vector<char *> argv (self->args.size () + 1);
	for (unsigned int i = 0; i < self->args.size (); ++i)
	argv[i] = const_cast<char *> (self->args[i].c_str ());

	return self->fork_exec (argv.data (), fds, stderr_fds);
	}

	static int
	do_compile_v0 (struct gcc_base_context s, const char filename,
	int verbose)
	{
	do_set_verbose (s, verbose);
	return do_compile (s, filename);
	}

	static void
	do_destroy (struct gcc_base_context *s)
	{
	base_gdb_plugin<T> *self = get_self (s);

	delete self;
	}
	};

	// Instances of this rpc<> template function are installed into the
	// "vtable"s. These functions are parameterized by type and method
	// name and forward the call via the connection.
	template<typename CTX, typename R, const char *&NAME, typename... Arg>
	R rpc (CTX *s, Arg... rest)
	{
	base_gdb_plugin<CTX> self = (base_gdb_plugin<CTX> ) s;
	R result;

	if (!cc1_plugin::call (self->connection.get (), NAME, &result, rest...))
	return 0;
	return result;
	}
	}

	#endif // CC1_PLUGIN_GDBCTX_HH