/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1997-2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * interceptor.c -- a functional decomposition of generate.c,
 *      the code generator for apptrace
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include "parser.h"
#include "trace.h"
#include "util.h"
#include "db.h"
#include "symtab.h"
#include "io.h"
#include "bindings.h"
#include "printfuncs.h"
#include "errlog.h"
#include "parseproto.h"

static void generate_i_declarations(char *, int, char *);
static void generate_i_preamble(ENTRY *);
static void generate_i_call();
static int  generate_i_bindings(int);
static void generate_i_postamble(ENTRY *, int, char *, char *);
static void generate_i_evaluations(ENTRY *);
static void generate_i_prints(ENTRY *, char *, char *);
static void generate_i_closedown(char *, int);
static void generate_i_live_vars(ENTRY *);
static void generate_return_printf(int);
static char *variables_get_errorname(void);

/*
 * generate_interceptor -- make code for an individual interceptor, written
 *      as an output grammar
 */
void
generate_interceptor(ENTRY *function)
{
        char    *prototype = symtab_get_prototype(),
                *library_name = db_get_current_library(),
                *function_name,
                *error_name;
        int     void_func;

        errlog(BEGIN, "generate_interceptor() {");

        /* Check for required information. */
        if (validity_of(function) == NO) {
                symtab_set_skip(YES);
                errlog(WARNING|INPUT, "No prototype for interface, "
                        "it will be skipped");
                errlog(END, "}");
                return;
        }

        /* Collect things we'll use more than once. */
        function_name = name_of(function);

        error_name = variables_get_errorname();

        void_func = is_void(function);

        /*
         * Emit "artificial" prototype here so that if there's a
         * disagreement between it and the prototype contained in the
         * declaring header, the compiler will flag it.
         * First #undef the function to make sure the prototype in the header
         * is exposed and to avoid breaking the artificial prototype if it's
         * not.
         */
        {
                decl_t *dp;
                char *buf;
                char const *err;
                size_t s;

                s = strlen(prototype) + 2;
                buf = malloc(s);
                if (buf == NULL)
                        abort();
                (void) strcpy(buf, prototype);
                buf[s - 2] = ';';
                buf[s - 1] = '\0';

                err = decl_Parse(buf, &dp);
                if (err != NULL)
                        errlog(FATAL, "\"%s\", line %d: %s: %s",
                            symtab_get_filename(), line_of(function),
                            err, prototype);

                /* generate the mapfile entry */
                (void) fprintf(Mapfp, "\t__abi_%s;\n", decl_GetName(dp));

                (void) decl_ToString(buf, DTS_DECL, dp, function_name);
                (void) fprintf(Bodyfp, "#line %d \"%s\"\n",
                    line_of(function), symtab_get_filename());
                (void) fprintf(Bodyfp, "#undef %s\n", function_name);
                (void) fprintf(Bodyfp, "extern %s;\n", buf);

                (void) fprintf(Bodyfp, "static %s\n{\n", prototype);

                (void) decl_ToString(buf, DTS_RET, dp, "_return");
                generate_i_declarations(error_name, void_func, buf);
                decl_Destroy(dp);
                free(buf);
        }

        generate_i_preamble(function);
        generate_i_call(function, void_func, library_name, error_name);
        generate_i_postamble(function, void_func, error_name, library_name);

        errlog(END, "}");
}

/*
 * print_function_signature -- print the line defining the function, without
 *      an ``extern'' prefix or either a ``;'' or ''{'' suffix.
 */
void
print_function_signature(char *xtype, char *name, char *formals)
{
        char    buffer[MAXLINE];

        (void) snprintf(buffer, sizeof (buffer), "%s", name);
        (void) fprintf(Bodyfp,  xtype, buffer);
        if (strstr(xtype, "(*") == NULL) {
                (void) fprintf(Bodyfp,  "(%s)", formals);
        }
}


/*
 * generate_i_declarations -- generate the declarations which
 *      are local to the interceptor function itself.
 */
static void
generate_i_declarations(char *errname, int voidfunc, char *ret_str)
{

        errlog(BEGIN, "generate_i_declarations() {");
        if (*errname != '\0') {
                /* Create locals for errno-type variable, */
                (void) fprintf(Bodyfp,
                    "    int saved_errvar = %s;\n", errname);
                (void) fprintf(Bodyfp,  "    int functions_errvar;\n");
        }

        if (need_exception_binding()) {
                /* Create a local for that. */
                (void) fprintf(Bodyfp,  "    int exception = 0;\n");
        }
        if (! voidfunc) {
                /* Create a return value. */
                (void) fprintf(Bodyfp,  "    %s;\n", ret_str);
        }
        (void) fprintf(Bodyfp, "    sigset_t omask;\n");
        (void) putc('\n', Bodyfp);
        errlog(END, "}");
}


/*
 * generate_i_preamble -- do the actions which must occur
 *      before the call.
 */
static void
generate_i_preamble(ENTRY *function)
{
        errlog(BEGIN, "generate_i_preamble() {");
        generate_i_live_vars(function); /* Deferred. */

        if (symtab_get_nonreturn() == YES) {
                /* Make things safe for printing */
                (void) fprintf(Bodyfp,
                    "    abilock(&omask);\n");
                /* Print all the args in terse format. */
                generate_printf(function);
                (void) fputs("    putc('\\n', ABISTREAM);\n\n", Bodyfp);
                /* unlock stdio */
                (void) fprintf(Bodyfp,
                    "    abiunlock(&omask);\n");
        }

        errlog(END, "}");
}

/*
 * generate_i_call -- implement the save/call/restore cycle
 */
static void
generate_i_call(
        ENTRY   *function,
        int     void_func,
        char    *library_name,
        char    *error_name)
{
        char    *function_name = name_of(function),
                *function_cast = symtab_get_cast(),
                *actual_args = symtab_get_actuals();

        errlog(BEGIN, "generate_i_call() {");
        /* Zero the error variable. */
        if (*error_name != '\0') {
                (void) fprintf(Bodyfp,  "    %s = 0;\n", error_name);
        }

        /* Then print the call itself. */
        if (void_func) {
                (void) fprintf(Bodyfp,
                    "    (void) ABI_CALL_REAL(%s, %s, %s)(%s);\n",
                    library_name, function_name, function_cast, actual_args);
        } else {
                (void) fprintf(Bodyfp,
                    "    _return = ABI_CALL_REAL(%s, %s, %s)(%s);\n",
                    library_name, function_name, function_cast, actual_args);
        }

        /* Then set the local copy of the error variable. */
        if (*error_name != '\0') {
                (void) fprintf(Bodyfp,
                    "    functions_errvar = %s;\n", error_name);
        }
        (void) putc('\n', Bodyfp);

        /* Make things safe for printing */
        (void) fprintf(Bodyfp,
            "    abilock(&omask);\n");

        errlog(END, "}");
}

/*
 * generate_i_postamble -- do all the things which come
 *      after the call.  In the case of apptrace, this is most of the work.
 */
static void
generate_i_postamble(ENTRY *function, int void_func,
    char *error_name, char *library_name)
{
        errlog(BEGIN, "generate_i_postamble() {");
        if (symtab_get_nonreturn() == NO) {
                /* Print all the args in terse format. */
                generate_printf(function);
        }

        /* If it isn't supposed to return, and actually ends up here, */
        /* we'd better be prepared to print all sorts of diagnostic stuff */
        (void) putc('\n', Bodyfp);
        if (generate_i_bindings(void_func) == YES) {
                generate_return_printf(void_func);
        }

        generate_i_prints(function, library_name, name_of(function));
        generate_i_evaluations(function); /* Deferred */
        generate_i_closedown(error_name, void_func);
        errlog(END, "}");
}

/*
 * generate_i_bindings -- see about success and failure, so we can decide
 *      what to do next.
 */
static int
generate_i_bindings(int void_func)
{
        ENTRY   *e;
        char *exception;

        exception  = ((e = symtab_get_exception()) != NULL)?
            (name_of(e)? name_of(e): ""): "";

        errlog(BEGIN, "generate_i_bindings() {");
        if (void_func && bindings_exist()) {
                /* To become a warning, as there are spec errors! TBD */
                errlog(FATAL, "exception bindings found in a "
                        "void function");
        } else if (void_func || need_bindings(exception) == NO) {
                (void) fprintf(Bodyfp,
                    "    (void) putc('\\n', ABISTREAM);\n");
                (void) putc('\n', Bodyfp);
                errlog(END, "}");
                return (NO);
        } else {
                /*
                 * Then there is a return value, so we try to
                 * generate exception bindings
                 * and code to print errno on exception.
                 */
                if ((generate_bindings(exception)) != ANTONYMS) {
                        /* Generate code to cross-evaluate them. */
                        (void) fprintf(Bodyfp,
                            "    if (!exception) {\n");
                        errlog(END, "}");
                        return (YES);
                }
        }

        /* should not get here */
        errlog(END, "}");
        return (NO);
}

/*
 * generate_return_printf -- print the return value and end the line
 */
static void
generate_return_printf(int void_func)
{
        errlog(BEGIN, "generate_return_printf() {");
        if (void_func) {
                (void) fprintf(Bodyfp,  "    putc('\\n', ABISTREAM);\n");
                errlog(END, "}");
                return;
        }
        /* If its a non-void function there are bindings. */
        (void) fprintf(Bodyfp,
            "\t/* Just end the line */\n"
            "\tputc('\\n', ABISTREAM);\n"
            "    }\n"
            "    else {\n"
            "        fprintf(ABISTREAM, \"%%s%%d (%%s)\\n\", errnostr, "
            "functions_errvar, strerror((int)functions_errvar));\n"
            "    }\n\n");
        errlog(END, "}");
}

/*
 * generate_i_prints -- if we're doing the verbose stuff,
 *      generate verbose printouts of the variables.
 */
static void
generate_i_prints(ENTRY *function, char *lib, char *func)
{
        ENTRY   *e;

        errlog(BEGIN, "generate_i_prints() {");
        if ((e = symtab_get_first_arg()) != NULL || !is_void(e)) {
                /* Then we have to generate code for verbose reports. */
                (void) fprintf(Bodyfp,  "    if (ABI_VFLAG(%s, %s) != 0) {\n",
                        lib, func);
                generate_printfunc_calls(function);
                (void) fprintf(Bodyfp,  "    }\n");
        }
        (void) putc('\n', Bodyfp);
        errlog(END, "}");
}

/*
 * generate_i_closedown -- restore error variables and return.
 */
static void
generate_i_closedown(char *error_name, int void_func)
{
        errlog(BEGIN, "generate_i_closedown() {");

        /* unlock stdio */
        (void) fprintf(Bodyfp,
            "    abiunlock(&omask);\n");

        if (*error_name != '\0') {
                /* Restore error variables. */
                (void) fprintf(Bodyfp,
                    "    %s = (functions_errvar == 0)? "
                    "            saved_errvar: functions_errvar;\n",
                    error_name);
        }

        /* And return. */
        (void) fprintf(Bodyfp,
            "    return%s;\n",
            (void_func)? "": " _return");
        (void) fprintf(Bodyfp,  "}\n");
        (void) putc('\n', Bodyfp);
        errlog(END, "}");
}


/*
 * generate_i_live_vars -- generate temps for any ``out''
 *      or ``inout'' variables in the function.  Deferred.
 */
/*ARGSUSED*/
static void
generate_i_live_vars(ENTRY *function)
{
        errlog(BEGIN, "generate_i_live_vars() {");
        errlog(END, "}");
}

/*
 * generate_i_evaluations -- generate evaluations for
 *      all the expressions. Deferred.
 */
/*ARGSUSED*/
static void
generate_i_evaluations(ENTRY *function)
{
        errlog(BEGIN, "generate_i_evaluations() {");
        errlog(END, "}");
}


static char *
variables_get_errorname(void)
{
        return ("ABI_ERRNO");
}