main.cpp File Reference

#include <gcc-plugin.h>
#include <plugin-version.h>
#include <function.h>
#include <tree.h>
#include <c-family/c-pragma.h>
#include <c-family/c-common.h>
#include <iostream>
#include <sstream>
#include <unordered_map>
#include <vector>
#include <cstdio>

Include dependency graph for main.cpp:

Go to the source code of this file.

Classes
struct	seh_handler
struct	seh_function

Macros
#define	trace(...)
#define	is_alpha(c)   (((c)>64 && (c)<91) || ((c)>96 && (c)<123))
#define	VISIBLE   __attribute__((__visibility__("default")))
#define	UNUSED   __attribute__((__unused__))

Functions
static struct seh_function *	get_seh_function ()
static void	mark_seh_function_noinline (void)
static void	handle_seh_pragma (cpp_reader *UNUSED parser)
static void	finish_seh_function (void *event_data, void *UNUSED user_data)
static void	register_seh_pragmas (void *UNUSED event_data, void *UNUSED user_data)
VISIBLE int	plugin_init (struct plugin_name_args *info, struct plugin_gcc_version *version)

Variables
int VISIBLE	plugin_is_GPL_compatible = 1
constexpr size_t	k_header_statement_max_size = 20000
static std::unordered_map< struct function *, struct seh_function * >	func_seh_map = {}

Macro Definition Documentation

is_alpha

#define is_alpha

(

c

)

(((c)>64 && (c)<91) || ((c)>96 && (c)<123))

Definition at line 28 of file main.cpp.

trace

#define trace

(

...

)

Definition at line 25 of file main.cpp.

UNUSED

#define UNUSED   __attribute__((__unused__))

Definition at line 36 of file main.cpp.

VISIBLE

#define VISIBLE   __attribute__((__visibility__("default")))

Definition at line 33 of file main.cpp.

Function Documentation

finish_seh_function()

static void finish_seh_function ( void *  event_data, void *UNUSED  user_data  )

static

Definition at line 172 of file main.cpp.

{
    tree fndef = (tree)event_data;
    struct function* fun = DECL_STRUCT_FUNCTION(fndef);
 
    auto search = func_seh_map.find(fun);
    if (search == func_seh_map.end())
        return;
 
    /* Get our SEH details and remove us from the map */
    seh_function* seh_fun = search->second;
    func_seh_map.erase(search);
 
    if (DECL_FUNCTION_PERSONALITY(fndef) != nullptr)
    {
        error("Function %s has a personality. Are you mixing SEH with C++ exceptions ?",
              IDENTIFIER_POINTER(fndef));
        return;
    }
 
    /* Update asm statement */
    std::stringstream asm_str;
    asm_str << ".seh_handler __C_specific_handler";
    if (seh_fun->unwind)
        asm_str << ", @unwind";
    if (seh_fun->except)
        asm_str << ", @except";
    asm_str << "\n";
    asm_str << "\t.seh_handlerdata\n";
    asm_str << "\t.long " << seh_fun->count << "\n";
 
    for (auto& handler : seh_fun->handlers)
    {
        asm_str << "\n\t.rva " << "__seh2$$begin_try__" << handler.line; /* Begin of tried code */
        asm_str << "\n\t.rva " << "__seh2$$end_try__" << handler.line; /* End of tried code */
        asm_str << "\n\t.rva " << "__seh2$$filter__" << handler.line; /* Filter function */
        if (handler.is_except)
            asm_str << "\n\t.rva " << "__seh2$$begin_except__" << handler.line; /* Called on except */
        else
            asm_str << "\n\t.long 0"; /* No unwind handler */
    }
    asm_str << "\n\t.seh_code\n";
 
    strncpy(const_cast<char*>(TREE_STRING_POINTER(seh_fun->asm_header_text)),
            asm_str.str().c_str(),
            TREE_STRING_LENGTH(seh_fun->asm_header_text));
 
    trace(stderr, "ASM: %s\n", asm_str.str().c_str());
 
    delete seh_fun;
}

Referenced by plugin_init().

get_seh_function()

static struct seh_function * get_seh_function ( )

static

Definition at line 82 of file main.cpp.

{
    auto search = func_seh_map.find(cfun);
    if (search != func_seh_map.end())
        return search->second;
 
    auto seh_fun = new seh_function(cfun);
    func_seh_map.insert({cfun, seh_fun});
 
    return seh_fun;
}

Referenced by handle_seh_pragma().

handle_seh_pragma()

static void handle_seh_pragma ( cpp_reader *UNUSED  parser )

static

Definition at line 115 of file main.cpp.

{
    tree x, arg, line;
    std::stringstream label_decl;
    bool is_except;
 
    if (!cfun)
    {
        error("%<#pragma REACTOS seh%> is not allowed outside functions");
        return;
    }
 
    if ((pragma_lex(&x) != CPP_OPEN_PAREN) ||
        (pragma_lex(&arg) != CPP_NAME) || // except or finally
        (pragma_lex(&x) != CPP_COMMA) ||
        (pragma_lex(&line) != CPP_NUMBER) || // Line number
        (pragma_lex(&x) != CPP_CLOSE_PAREN) ||
        (pragma_lex(&x) != CPP_EOF)
        )
    {
        error("%<#pragma REACTOS seh%> needs two parameters%>");
        return;
    }
 
    trace(stderr, "Pragma: %s, %u\n", IDENTIFIER_POINTER(arg), TREE_INT_CST_LOW(line));
 
    const char* op = IDENTIFIER_POINTER(arg);
 
    seh_function* seh_fun = get_seh_function();
    if (strcmp(op, "__seh$$except") == 0)
    {
        is_except = true;
        seh_fun->except = true;
    }
    else if (strcmp(op, "__seh$$finally") == 0)
    {
        is_except = false;
        seh_fun->unwind = true;
    }
    else
    {
        error("Wrong argument for %<#pragma REACTOS seh%>. Expected \"except\" or \"finally\"");
        return;
    }
    seh_fun->count++;
 
    seh_fun->handlers.push_back({is_except, (unsigned int)TREE_INT_CST_LOW(line)});
 
    /* Make sure we use a frame pointer. REACTOS' PSEH depends on this */
    cfun->machine->accesses_prev_frame = 1;
 
    /* Keep handlerdata generation canonical: one SEH block per function. */
    mark_seh_function_noinline();
}

Referenced by register_seh_pragmas().

mark_seh_function_noinline()

static void mark_seh_function_noinline ( void  )

static

Definition at line 102 of file main.cpp.

{
    tree fndecl = current_function_decl;
 
    if (fndecl == NULL_TREE)
        return;
 
    DECL_UNINLINABLE(fndecl) = 1;
    DECL_DECLARED_INLINE_P(fndecl) = 0;
}

Referenced by handle_seh_pragma().

plugin_init()

VISIBLE int plugin_init	(	struct plugin_name_args *	info,
		struct plugin_gcc_version *	version
	)

Definition at line 234 of file main.cpp.

{
    if (!plugin_default_version_check (version, &gcc_version))
    {
        std::cerr << "This GCC plugin is for version " << GCCPLUGIN_VERSION_MAJOR << "." << GCCPLUGIN_VERSION_MINOR << "\n";
        return 1;
    }
 
    register_callback(info->base_name, PLUGIN_PRAGMAS, register_seh_pragmas, NULL);
    register_callback(info->base_name, PLUGIN_FINISH_PARSE_FUNCTION, finish_seh_function, NULL);
 
    return 0;
}

register_seh_pragmas()

static void register_seh_pragmas ( void *UNUSED  event_data, void *UNUSED  user_data  )

static

Definition at line 226 of file main.cpp.

{
    c_register_pragma("REACTOS", "seh", handle_seh_pragma);
}

Referenced by plugin_init().

Variable Documentation

func_seh_map

std::unordered_map<struct function*, struct seh_function*> func_seh_map = {}

static

Definition at line 78 of file main.cpp.

Referenced by finish_seh_function(), and get_seh_function().

k_header_statement_max_size

constexpr size_t k_header_statement_max_size = 20000

constexpr

Definition at line 42 of file main.cpp.

Referenced by seh_function::seh_function().

plugin_is_GPL_compatible

int VISIBLE plugin_is_GPL_compatible = 1

Definition at line 40 of file main.cpp.