C++ register_callback函数代码示例

__visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
{
	int i;
	const char * const plugin_name = plugin_info->base_name;
	const int argc = plugin_info->argc;
	const struct plugin_argument * const argv = plugin_info->argv;

	PASS_INFO(cyc_complexity, "ssa", 1, PASS_POS_INSERT_AFTER);

	if (!plugin_default_version_check(version, &gcc_version)) {
		error_gcc_version(version);
		return 1;
	}

	for (i = 0; i < argc; ++i) {
		if (!strcmp(argv[i].key, "log_file")) {
			has_log_file = true;
			continue;
		}

		error(G_("unknown option '-fplugin-arg-%s-%s'"), plugin_name, argv[i].key);
	}

	register_callback(plugin_name, PLUGIN_START_UNIT,
				&cyc_complexity_start_unit, NULL);
	register_callback (plugin_name, PLUGIN_FINISH_UNIT,
				&cyc_complexity_finish_unit, NULL);
	register_callback(plugin_name, PLUGIN_INFO, NULL,
				&cyc_complexity_plugin_info);
	register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL,
				&cyc_complexity_pass_info);

	return 0;
}

/* module initialization and will be executed automatically when loading. */
void module_init(){
	shutdown = malloc(sizeof(shutdown_config_t));
	register_callback(max_insn_callback, Step_callback);
	register_callback(write_shutdown_callback, Bus_write_callback);
	if(register_option("shutdown_device", do_shutdown_option, "Used to stop machine by writing a special address or set the max executed instruction number.") != No_exp)
		fprintf(stderr,"Can not register shutdown_device option\n");
}

int
plugin_init (struct plugin_name_args* info, struct plugin_gcc_version* ver)
{
  struct register_pass_info pass;
  int i;

  if (strcmp (ver->basever, gcc_version.basever) != 0)
    {
      printf ("tsan: invalid gcc version (expected/actual: %s/%s)\n",
             gcc_version.basever, ver->basever);
      exit(1);
    }

  flag_tsan = 1;
  for (i = 0; i < info->argc; i++)
    {
      if (strcmp (info->argv[i].key, "ignore") == 0)
        flag_tsan_ignore = xstrdup (info->argv[i].value);
    }

  pass.pass = &pass_tsan.pass;
  pass.reference_pass_name = "loop";
  pass.ref_pass_instance_number = 1;
  pass.pos_op = PASS_POS_INSERT_BEFORE;
  register_callback(info->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &pass);
  register_callback(info->base_name, PLUGIN_ALL_PASSES_END, finish_unit, NULL);
  return 0;
}

int plugin_init (struct plugin_name_args *plugin_info,
                 struct plugin_gcc_version *version)
{
  register_callback ("start_unit", PLUGIN_START_UNIT, &start_unit_callback, NULL);
  register_callback ("finish_unit", PLUGIN_FINISH_UNIT, &finish_unit_callback, NULL);
  return 0;
}

int plugin_init(struct plugin_name_args *info, struct plugin_gcc_version *ver)
{
    if (strncmp(ver->basever, myplugin_ver.basever, strlen("X.Y"))) {
        fprintf(stderr, "Your compiler: %s\n", ver->basever);
        fprintf(stderr, "Sorry, you need to use GCC 4.7.\n");
        return -1;
    }

#ifdef DEBUG
    fprintf(stderr, "Initializing plugin\n");
#endif

    struct register_pass_info pass;
    pass.pass = &instrument_assignments_plugin_pass.pass;
    pass.reference_pass_name = "ssa";
    pass.ref_pass_instance_number = 1;
    pass.pos_op = PASS_POS_INSERT_AFTER;

    // Tell gcc we want to be called after the first SSA pass
    register_callback("instrument_plugin", PLUGIN_PASS_MANAGER_SETUP, NULL, &pass);
    register_callback("instrument_plugin", PLUGIN_INFO, NULL, &instrument_assignments_plugin_info);
    register_callback("instrument_plugin", PLUGIN_ATTRIBUTES, register_attributes, NULL);

    return 0;
}

void init_substitute_passes(const char* plugin_name)
{
  // Check if j_out has already been created
  j_tmp = cJSON_GetObjectItem(j_ini, "input_file");
  if (j_tmp==NULL)
  {
    printf("Alchemist error: input_filename is not defined in ini file\n");
    exit(1);
  }

  strcpy(alc_input_file, j_tmp->valuestring);

  j_in=openme_load_json_file(alc_input_file);
  if (j_in==NULL)
  {
    printf("Alchemist error: problem loading input file %s ...\n", alc_input_file);
    exit(1);
  }

  j_in=openme_get_obj(j_in, ALC_PASSES);
  if (j_in==NULL)
  {
    printf("Alchemist error: can't find id '%s' in input file ...\n", ALC_PASSES);
    exit(1);
  }

  register_callback(plugin_name, PLUGIN_ALL_PASSES_START, &substitute_passes, NULL);
  register_callback(plugin_name, PLUGIN_ALL_PASSES_END, &substitute_passes_end, NULL);
  register_callback(plugin_name, PLUGIN_PASS_EXECUTION, &view_pass_execution, NULL);
}

void
_modinit(void)
{
	mod_add_cmd(&privmsg_msgtab);
	mod_add_cmd(&notice_msgtab);
	client_message = register_callback("client_message", NULL);
	channel_message = register_callback("channel_message", NULL);
}

/* some initialization for log functionality */
int bus_log_init() {
    exception_t exp;
    /* register callback function */
    register_callback(log_bus_callback, Bus_read_callback);
    register_callback(log_bus_callback, Bus_write_callback);
    /* add corresponding command */
    add_command("log-bus", com_log_bus, "record every bus access to log file.\n");
}

__visible int plugin_init(struct plugin_name_args *plugin_info,
			  struct plugin_gcc_version *version)
{
	const char * const plugin_name = plugin_info->base_name;
	const int argc = plugin_info->argc;
	const struct plugin_argument *argv = plugin_info->argv;
	int tso = 0;
	int i;

	if (!plugin_default_version_check(version, &gcc_version)) {
		error(G_("incompatible gcc/plugin versions"));
		return 1;
	}

	for (i = 0; i < argc; ++i) {
		if (!strcmp(argv[i].key, "disable"))
			return 0;

		/* all remaining options require a value */
		if (!argv[i].value) {
			error(G_("no value supplied for option '-fplugin-arg-%s-%s'"),
			      plugin_name, argv[i].key);
			return 1;
		}

		if (!strcmp(argv[i].key, "tso")) {
			tso = atoi(argv[i].value);
			continue;
		}

		if (!strcmp(argv[i].key, "offset")) {
			canary_offset = atoi(argv[i].value);
			continue;
		}
		error(G_("unknown option '-fplugin-arg-%s-%s'"),
		      plugin_name, argv[i].key);
		return 1;
	}

	/* create the mask that produces the base of the stack */
	sp_mask = ~((1U << (12 + tso)) - 1);

	PASS_INFO(arm_pertask_ssp_rtl, "expand", 1, PASS_POS_INSERT_AFTER);

	register_callback(plugin_info->base_name, PLUGIN_PASS_MANAGER_SETUP,
			  NULL, &arm_pertask_ssp_rtl_pass_info);

#if BUILDING_GCC_VERSION >= 9000
	register_callback(plugin_info->base_name, PLUGIN_START_UNIT,
			  arm_pertask_ssp_start_unit, NULL);
#endif

	return 0;
}

int
plugin_init (struct plugin_name_args *plugin_info,
             struct plugin_gcc_version *version)
{
  const char *plugin_name = plugin_info->base_name;
  register_callback (plugin_name, PLUGIN_PRE_GENERICIZE,
                     handle_pre_generic, NULL);

  register_callback (plugin_name, PLUGIN_ATTRIBUTES, register_attributes, NULL);
  return 0;
}

static void cov_state_on(char *arg) 
{

	if (cov_state == COV_START) { //run this function first time
		cov_init(prof_start, prof_end);
		register_callback(cov_readmem_callback, Mem_read_callback);
		register_callback(cov_writemem_callback, Mem_write_callback);
		register_callback(cov_execmem_callback, Step_callback);
	}else
		printf("code coverage state: on\n");

	cov_state = COV_ON;
}

int
plugin_init (struct plugin_name_args *plugin_info,
             struct plugin_gcc_version *version)
{
  const char *plugin_name = plugin_info->base_name;

  register_callback (plugin_name, PLUGIN_START_PARSE_FUNCTION,
                     plugin_start_parse_function, NULL);

  register_callback (plugin_name, PLUGIN_FINISH_PARSE_FUNCTION,
                     plugin_finish_parse_function, NULL);
  return 0;
}

/* Non auto translated PV domain, ie, it's not PVH. */
static __init void xen_pvmmu_arch_setup(void)
{
	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments);
	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables);

	HYPERVISOR_vm_assist(VMASST_CMD_enable,
			     VMASST_TYPE_pae_extended_cr3);

	if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) ||
	    register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback))
		BUG();

	xen_enable_sysenter();
	xen_enable_syscall();
}

static int create_register_callback (llist_t **list, /* {{{ */
		const char *name, void *callback, user_data_t *ud)
{
	callback_func_t *cf;

	cf = (callback_func_t *) malloc (sizeof (*cf));
	if (cf == NULL)
	{
		ERROR ("plugin: create_register_callback: malloc failed.");
		return (-1);
	}
	memset (cf, 0, sizeof (*cf));

	cf->cf_callback = callback;
	if (ud == NULL)
	{
		cf->cf_udata.data = NULL;
		cf->cf_udata.free_func = NULL;
	}
	else
	{
		cf->cf_udata = *ud;
	}

	return (register_callback (list, name, cf));
} /* }}} int create_register_callback */

/**
 * \brief Load and parse the Lua file of the requested shader.
 * \param path The path to the lua file, relative to the data folder.
 */
void Shader::load_lua_file(const std::string& path) {

    lua_State* l = luaL_newstate();
    luaL_openlibs(l);  // FIXME don't open the libs
    size_t size;
    char* buffer;

    FileTools::data_file_open_buffer(path, &buffer, &size);
    int load_result = luaL_loadbuffer(l, buffer, size, path.c_str());

    if (load_result != 0) {
        // Syntax error in the lua file.
        Debug::die(std::string("Failed to load ") + path + " : " + lua_tostring(l, -1));
    }
    else {
        // Register the callback and send string parameters to the lua script.
        register_callback(l);
        lua_pushstring(l, Video::get_rendering_driver_name().c_str());
        lua_pushstring(l, shading_language_version.c_str());
        lua_pushstring(l, sampler_type.c_str());

        if (lua_pcall(l, 3, 0, 0) != 0) {

            // Runtime error.
            Debug::die(std::string("Failed to parse ") + path + " : " + lua_tostring(l, -1));
            lua_pop(l, 1);
        }
    }

    FileTools::data_file_close_buffer(buffer);
    lua_close(l);
}