From 9c08fbb35aa95420268c2762151f22a6a9b90e85 Mon Sep 17 00:00:00 2001 From: tschwinge Date: Wed, 28 Jan 2015 17:03:44 +0000 Subject: [PATCH] nvptx mkoffload. gcc/ * config/nvptx/mkoffload.c: New file. * config/nvptx/t-nvptx: Add build rules for it. * config.gcc [$enable_as_accelerator = yes] (extra_programs): Add mkoffload. * config/nvptx/nvptx.c (nvptx_record_offload_symbol): New function. (TARGET_RECORD_OFFLOAD_SYMBOL): Define macro to use it. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@220209 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 12 + gcc/config.gcc | 5 +- gcc/config/nvptx/mkoffload.c | 907 +++++++++++++++++++++++++++++++++++++++++++ gcc/config/nvptx/nvptx.c | 13 + gcc/config/nvptx/t-nvptx | 9 +- 5 files changed, 944 insertions(+), 2 deletions(-) create mode 100644 gcc/config/nvptx/mkoffload.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 6968b82b43b..6b957bf6086 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,15 @@ +2015-01-28 Thomas Schwinge + Bernd Schmidt + Nathan Sidwell + + * config/nvptx/mkoffload.c: New file. + * config/nvptx/t-nvptx: Add build rules for it. + * config.gcc [$enable_as_accelerator = yes] + (extra_programs): Add mkoffload. + * config/nvptx/nvptx.c (nvptx_record_offload_symbol): New + function. + (TARGET_RECORD_OFFLOAD_SYMBOL): Define macro to use it. + 2015-01-28 Yuri Rumyantsev PR middle-end/64809 diff --git a/gcc/config.gcc b/gcc/config.gcc index bf67bebfe86..abd915e7159 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -2233,7 +2233,10 @@ nios2-*-*) nvptx-*) tm_file="${tm_file} newlib-stdint.h" tmake_file="nvptx/t-nvptx" - tm_file="${tm_file} nvptx/offload.h" + if test x$enable_as_accelerator = xyes; then + extra_programs="${extra_programs} mkoffload\$(exeext)" + tm_file="${tm_file} nvptx/offload.h" + fi ;; pdp11-*-*) tm_file="${tm_file} newlib-stdint.h" diff --git a/gcc/config/nvptx/mkoffload.c b/gcc/config/nvptx/mkoffload.c new file mode 100644 index 00000000000..9138bdd8dd8 --- /dev/null +++ b/gcc/config/nvptx/mkoffload.c @@ -0,0 +1,907 @@ +/* Offload image generation tool for PTX. + + Copyright (C) 2014-2015 Free Software Foundation, Inc. + + Contributed by Nathan Sidwell and + Bernd Schmidt . + + 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 + . */ + +/* Munges PTX assembly into a C source file defining the PTX code as a + string. + + This is not a complete assembler. We presume the source is well + formed from the compiler and can die horribly if it is not. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "intl.h" +#include +#include "obstack.h" +#include "diagnostic-core.h" +#include "collect-utils.h" + +const char tool_name[] = "nvptx mkoffload"; + +#define COMMENT_PREFIX "#" + +typedef enum Kind +{ + /* 0-ff used for single char tokens */ + K_symbol = 0x100, /* a symbol */ + K_label, /* a label defn (i.e. symbol:) */ + K_ident, /* other ident */ + K_dotted, /* dotted identifier */ + K_number, + K_string, + K_comment +} Kind; + +typedef struct Token +{ + unsigned short kind : 12; + unsigned short space : 1; /* preceded by space */ + unsigned short end : 1; /* succeeded by end of line */ + /* Length of token */ + unsigned short len; + + /* Token itself */ + char const *ptr; +} Token; + +/* statement info */ +typedef enum Vis +{ + V_dot = 0, /* random pseudo */ + V_var = 1, /* var decl/defn */ + V_func = 2, /* func decl/defn */ + V_insn = 3, /* random insn */ + V_label = 4, /* label defn */ + V_comment = 5, + V_pred = 6, /* predicate */ + V_mask = 0x7, + V_global = 0x08, /* globalize */ + V_weak = 0x10, /* weakly globalize */ + V_no_eol = 0x20, /* no end of line */ + V_prefix_comment = 0x40 /* prefixed comment */ +} Vis; + +typedef struct Stmt +{ + struct Stmt *next; + Token *tokens; + unsigned char vis; + unsigned len : 12; + unsigned sym : 12; +} Stmt; + +struct id_map +{ + id_map *next; + char *ptx_name; +}; + +static const char *read_file (FILE *); +static Token *tokenize (const char *); + +static void write_token (FILE *, const Token *); +static void write_tokens (FILE *, const Token *, unsigned, int); + +static Stmt *alloc_stmt (unsigned, Token *, Token *, const Token *); +#define alloc_comment(S,E) alloc_stmt (V_comment, S, E, 0) +#define append_stmt(V, S) ((S)->next = *(V), *(V) = (S)) +static Stmt *rev_stmts (Stmt *); +static void write_stmt (FILE *, const Stmt *); +static void write_stmts (FILE *, const Stmt *); + +static Token *parse_insn (Token *); +static Token *parse_list_nosemi (Token *); +static Token *parse_init (Token *); +static Token *parse_file (Token *); + +static Stmt *decls; +static Stmt *vars; +static Stmt *fns; + +static id_map *func_ids, **funcs_tail = &func_ids; +static id_map *var_ids, **vars_tail = &var_ids; + +/* Files to unlink. */ +static const char *ptx_name; +static const char *ptx_cfile_name; + +/* Delete tempfiles. */ + +/* Unlink a temporary file unless requested otherwise. */ + +void +maybe_unlink (const char *file) +{ + if (! debug) + { + if (unlink_if_ordinary (file) + && errno != ENOENT) + fatal_error ("deleting file %s: %m", file); + } + else + fprintf (stderr, "[Leaving %s]\n", file); +} + +void +tool_cleanup (bool) +{ +} + +/* Add or change the value of an environment variable, outputting the + change to standard error if in verbose mode. */ +static void +xputenv (const char *string) +{ + if (verbose) + fprintf (stderr, "%s\n", string); + putenv (CONST_CAST (char *, string)); +} + + +static void +record_id (const char *p1, id_map ***where) +{ + const char *end = strchr (p1, '\n'); + if (!end) + fatal_error ("malformed ptx file"); + + id_map *v = XNEW (id_map); + size_t len = end - p1; + v->ptx_name = XNEWVEC (char, len + 1); + memcpy (v->ptx_name, p1, len); + v->ptx_name[len] = '\0'; + v->next = NULL; + id_map **tail = *where; + *tail = v; + *where = &v->next; +} + +/* Read the whole input file. It will be NUL terminated (but + remember, there could be a NUL in the file itself. */ + +static const char * +read_file (FILE *stream) +{ + size_t alloc = 16384; + size_t base = 0; + char *buffer; + + if (!fseek (stream, 0, SEEK_END)) + { + /* Get the file size. */ + long s = ftell (stream); + if (s >= 0) + alloc = s + 100; + fseek (stream, 0, SEEK_SET); + } + buffer = XNEWVEC (char, alloc); + + for (;;) + { + size_t n = fread (buffer + base, 1, alloc - base - 1, stream); + + if (!n) + break; + base += n; + if (base + 1 == alloc) + { + alloc *= 2; + buffer = XRESIZEVEC (char, buffer, alloc); + } + } + buffer[base] = 0; + return buffer; +} + +/* Read a token, advancing ptr. + If we read a comment, append it to the comments block. */ + +static Token * +tokenize (const char *ptr) +{ + unsigned alloc = 1000; + unsigned num = 0; + Token *toks = XNEWVEC (Token, alloc); + int in_comment = 0; + int not_comment = 0; + + for (;; num++) + { + const char *base; + unsigned kind; + int ws = 0; + int eol = 0; + + again: + base = ptr; + if (in_comment) + goto block_comment; + switch (kind = *ptr++) + { + default: + break; + + case '\n': + eol = 1; + /* Fall through */ + case ' ': + case '\t': + case '\r': + case '\v': + /* White space */ + ws = not_comment; + goto again; + + case '/': + { + if (*ptr == '/') + { + /* line comment. Do not include trailing \n */ + base += 2; + for (; *ptr; ptr++) + if (*ptr == '\n') + break; + kind = K_comment; + } + else if (*ptr == '*') + { + /* block comment */ + base += 2; + ptr++; + + block_comment: + eol = in_comment; + in_comment = 1; + for (; *ptr; ptr++) + { + if (*ptr == '\n') + { + ptr++; + break; + } + if (ptr[0] == '*' && ptr[1] == '/') + { + in_comment = 2; + ptr += 2; + break; + } + } + kind = K_comment; + } + else + break; + } + break; + + case '"': + /* quoted string */ + kind = K_string; + while (*ptr) + if (*ptr == '"') + { + ptr++; + break; + } + else if (*ptr++ == '\\') + ptr++; + break; + + case '.': + if (*ptr < '0' || *ptr > '9') + { + kind = K_dotted; + ws = not_comment; + goto ident; + } + /* FALLTHROUGH */ + case '0'...'9': + kind = K_number; + goto ident; + break; + + case '$': /* local labels. */ + case '%': /* register names, pseudoes etc */ + kind = K_ident; + goto ident; + + case 'a'...'z': + case 'A'...'Z': + case '_': + kind = K_symbol; /* possible symbol name */ + ident: + for (; *ptr; ptr++) + { + if (*ptr >= 'A' && *ptr <= 'Z') + continue; + if (*ptr >= 'a' && *ptr <= 'z') + continue; + if (*ptr >= '0' && *ptr <= '9') + continue; + if (*ptr == '_' || *ptr == '$') + continue; + if (*ptr == '.' && kind != K_dotted) + /* Idents starting with a dot, cannot have internal dots. */ + continue; + if ((*ptr == '+' || *ptr == '-') + && kind == K_number + && (ptr[-1] == 'e' || ptr[-1] == 'E' + || ptr[-1] == 'p' || ptr[-1] == 'P')) + /* exponent */ + continue; + break; + } + if (*ptr == ':') + { + ptr++; + kind = K_label; + } + break; + } + + if (alloc == num) + { + alloc *= 2; + toks = XRESIZEVEC (Token, toks, alloc); + } + Token *tok = toks + num; + + tok->kind = kind; + tok->space = ws; + tok->end = 0; + tok->ptr = base; + tok->len = ptr - base - in_comment; + in_comment &= 1; + not_comment = kind != K_comment; + if (eol && num) + tok[-1].end = 1; + if (!kind) + break; + } + + return toks; +} + +/* Write an encoded token. */ + +static void +write_token (FILE *out, Token const *tok) +{ + if (tok->space) + fputc (' ', out); + + switch (tok->kind) + { + case K_string: + { + const char *c = tok->ptr + 1; + size_t len = tok->len - 2; + + fputs ("\\\"", out); + while (len) + { + const char *bs = (const char *)memchr (c, '\\', len); + size_t l = bs ? bs - c : len; + + fprintf (out, "%.*s", (int)l, c); + len -= l; + c += l; + if (bs) + { + fputs ("\\\\", out); + len--, c++; + } + } + fputs ("\\\"", out); + } + break; + + default: + /* All other tokens shouldn't have anything magic in them */ + fprintf (out, "%.*s", tok->len, tok->ptr); + break; + } + if (tok->end) + fputs ("\\n", out); +} + +static void +write_tokens (FILE *out, Token const *toks, unsigned len, int spc) +{ + fputs ("\t\"", out); + for (; len--; toks++) + write_token (out, toks); + if (spc) + fputs (" ", out); + fputs ("\"", out); +} + +static Stmt * +alloc_stmt (unsigned vis, Token *tokens, Token *end, Token const *sym) +{ + static unsigned alloc = 0; + static Stmt *heap = 0; + + if (!alloc) + { + alloc = 1000; + heap = XNEWVEC (Stmt, alloc); + } + + Stmt *stmt = heap++; + alloc--; + + tokens->space = 0; + stmt->next = 0; + stmt->vis = vis; + stmt->tokens = tokens; + stmt->len = end - tokens; + stmt->sym = sym ? sym - tokens : ~0; + + return stmt; +} + +static Stmt * +rev_stmts (Stmt *stmt) +{ + Stmt *prev = 0; + Stmt *next; + + while (stmt) + { + next = stmt->next; + stmt->next = prev; + prev = stmt; + stmt = next; + } + + return prev; +} + +static void +write_stmt (FILE *out, const Stmt *stmt) +{ + if ((stmt->vis & V_mask) != V_comment) + { + write_tokens (out, stmt->tokens, stmt->len, + (stmt->vis & V_mask) == V_pred); + fputs (stmt->vis & V_no_eol ? "\t" : "\n", out); + } +} + +static void +write_stmts (FILE *out, const Stmt *stmts) +{ + for (; stmts; stmts = stmts->next) + write_stmt (out, stmts); +} + +static Token * +parse_insn (Token *tok) +{ + unsigned depth = 0; + + do + { + Stmt *stmt; + Token *sym = 0; + unsigned s = V_insn; + Token *start = tok; + + switch (tok++->kind) + { + case K_comment: + while (tok->kind == K_comment) + tok++; + stmt = alloc_comment (start, tok); + append_stmt (&fns, stmt); + continue; + + case '{': + depth++; + break; + + case '}': + depth--; + break; + + case K_label: + if (tok[-1].ptr[0] != '$') + sym = tok - 1; + tok[-1].end = 1; + s = V_label; + break; + + case '@': + tok->space = 0; + if (tok->kind == '!') + tok++; + if (tok->kind == K_symbol) + sym = tok; + tok++; + s = V_pred; + break; + + default: + for (; tok->kind != ';'; tok++) + { + if (tok->kind == ',') + tok[1].space = 0; + else if (tok->kind == K_symbol) + sym = tok; + } + tok++->end = 1; + break; + } + + stmt = alloc_stmt (s, start, tok, sym); + append_stmt (&fns, stmt); + + if (!tok[-1].end && tok[0].kind == K_comment) + { + stmt->vis |= V_no_eol; + stmt = alloc_comment (tok, tok + 1); + append_stmt (&fns, stmt); + tok++; + } + } + while (depth); + + return tok; +} + +/* comma separated list of tokens */ + +static Token * +parse_list_nosemi (Token *tok) +{ + Token *start = tok; + + do + if (!(++tok)->kind) + break; + while ((++tok)->kind == ','); + + tok[-1].end = 1; + Stmt *stmt = alloc_stmt (V_dot, start, tok, 0); + append_stmt (&decls, stmt); + + return tok; +} + +#define is_keyword(T,S) \ + (sizeof (S) == (T)->len && !memcmp ((T)->ptr + 1, (S), (T)->len - 1)) + +static Token * +parse_init (Token *tok) +{ + for (;;) + { + Token *start = tok; + Token const *sym = 0; + Stmt *stmt; + + if (tok->kind == K_comment) + { + while (tok->kind == K_comment) + tok++; + stmt = alloc_comment (start, tok); + append_stmt (&vars, stmt); + start = tok; + } + + if (tok->kind == '{') + tok[1].space = 0; + for (; tok->kind != ',' && tok->kind != ';'; tok++) + if (tok->kind == K_symbol) + sym = tok; + tok[1].space = 0; + int end = tok++->kind == ';'; + stmt = alloc_stmt (V_insn, start, tok, sym); + append_stmt (&vars, stmt); + if (!tok[-1].end && tok->kind == K_comment) + { + stmt->vis |= V_no_eol; + stmt = alloc_comment (tok, tok + 1); + append_stmt (&vars, stmt); + tok++; + } + if (end) + break; + } + return tok; +} + +static Token * +parse_file (Token *tok) +{ + Stmt *comment = 0; + + if (tok->kind == K_comment) + { + Token *start = tok; + + while (tok->kind == K_comment) + { + if (strncmp (tok->ptr, ":VAR_MAP ", 9) == 0) + record_id (tok->ptr + 9, &vars_tail); + if (strncmp (tok->ptr, ":FUNC_MAP ", 10) == 0) + record_id (tok->ptr + 10, &funcs_tail); + tok++; + } + comment = alloc_comment (start, tok); + comment->vis |= V_prefix_comment; + } + + if (tok->kind == K_dotted) + { + if (is_keyword (tok, "version") + || is_keyword (tok, "target") + || is_keyword (tok, "address_size")) + { + if (comment) + append_stmt (&decls, comment); + tok = parse_list_nosemi (tok); + } + else + { + unsigned vis = 0; + const Token *def = 0; + unsigned is_decl = 0; + Token *start; + + for (start = tok; + tok->kind && tok->kind != '=' && tok->kind != K_comment + && tok->kind != '{' && tok->kind != ';'; tok++) + { + if (is_keyword (tok, "global") + || is_keyword (tok, "const")) + vis |= V_var; + else if (is_keyword (tok, "func") + || is_keyword (tok, "entry")) + vis |= V_func; + else if (is_keyword (tok, "visible")) + vis |= V_global; + else if (is_keyword (tok, "extern")) + is_decl = 1; + else if (is_keyword (tok, "weak")) + vis |= V_weak; + if (tok->kind == '(') + { + tok[1].space = 0; + tok[0].space = 1; + } + else if (tok->kind == ')' && tok[1].kind != ';') + tok[1].space = 1; + + if (tok->kind == K_symbol) + def = tok; + } + + if (!tok->kind) + { + /* end of file */ + if (comment) + append_stmt (&fns, comment); + } + else if (tok->kind == '{' + || tok->kind == K_comment) + { + /* function defn */ + Stmt *stmt = alloc_stmt (vis, start, tok, def); + if (comment) + { + append_stmt (&fns, comment); + stmt->vis |= V_prefix_comment; + } + append_stmt (&fns, stmt); + tok = parse_insn (tok); + } + else + { + int assign = tok->kind == '='; + + tok++->end = 1; + if ((vis & V_mask) == V_var && !is_decl) + { + /* variable */ + Stmt *stmt = alloc_stmt (vis, start, tok, def); + if (comment) + { + append_stmt (&vars, comment); + stmt->vis |= V_prefix_comment; + } + append_stmt (&vars, stmt); + if (assign) + tok = parse_init (tok); + } + else + { + /* declaration */ + Stmt *stmt = alloc_stmt (vis, start, tok, 0); + if (comment) + { + append_stmt (&decls, comment); + stmt->vis |= V_prefix_comment; + } + append_stmt (&decls, stmt); + } + } + } + } + else + { + /* Something strange. Ignore it. */ + if (comment) + append_stmt (&fns, comment); + + while (tok->kind && !tok->end) + tok++; + } + return tok; +} + +static void +process (FILE *in, FILE *out) +{ + const char *input = read_file (in); + Token *tok = tokenize (input); + + do + tok = parse_file (tok); + while (tok->kind); + + fprintf (out, "static const char ptx_code[] = \n"); + write_stmts (out, rev_stmts (decls)); + write_stmts (out, rev_stmts (vars)); + write_stmts (out, rev_stmts (fns)); + fprintf (out, ";\n\n"); + fprintf (out, "static const char *var_mappings[] = {\n"); + for (id_map *id = var_ids; id; id = id->next) + fprintf (out, "\t\"%s\"%s\n", id->ptx_name, id->next ? "," : ""); + fprintf (out, "};\n\n"); + fprintf (out, "static const char *func_mappings[] = {\n"); + for (id_map *id = func_ids; id; id = id->next) + fprintf (out, "\t\"%s\"%s\n", id->ptx_name, id->next ? "," : ""); + fprintf (out, "};\n\n"); + + fprintf (out, "static const void *target_data[] = {\n"); + fprintf (out, " ptx_code, var_mappings, func_mappings\n"); + fprintf (out, "};\n\n"); + + fprintf (out, "extern void GOMP_offload_register (const void *, int, void *);\n"); + + fprintf (out, "extern void *__OPENMP_TARGET__[];\n\n"); + fprintf (out, "#define PTX_ID 1\n"); + fprintf (out, "static __attribute__((constructor)) void init (void)\n{\n"); + fprintf (out, " GOMP_offload_register (__OPENMP_TARGET__, PTX_ID,\n"); + fprintf (out, " &target_data);\n"); + fprintf (out, "};\n"); +} + +static void +compile_native (const char *infile, const char *outfile, const char *compiler) +{ + const char *collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); + if (!collect_gcc_options) + fatal_error ("environment variable COLLECT_GCC_OPTIONS must be set"); + + struct obstack argv_obstack; + obstack_init (&argv_obstack); + obstack_ptr_grow (&argv_obstack, compiler); + obstack_ptr_grow (&argv_obstack, infile); + obstack_ptr_grow (&argv_obstack, "-c"); + obstack_ptr_grow (&argv_obstack, "-o"); + obstack_ptr_grow (&argv_obstack, outfile); + obstack_ptr_grow (&argv_obstack, NULL); + + const char **new_argv = XOBFINISH (&argv_obstack, const char **); + fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true); + obstack_free (&argv_obstack, NULL); +} + +int +main (int argc, char **argv) +{ + FILE *in = stdin; + FILE *out = stdout; + const char *outname = 0; + + char *collect_gcc = getenv ("COLLECT_GCC"); + if (collect_gcc == NULL) + fatal_error ("COLLECT_GCC must be set."); + const char *gcc_path = dirname (ASTRDUP (collect_gcc)); + const char *gcc_exec = basename (ASTRDUP (collect_gcc)); + + size_t len = (strlen (gcc_path) + 1 + + strlen (GCC_INSTALL_NAME) + + 1); + char *driver = XALLOCAVEC (char, len); + + if (strcmp (gcc_exec, collect_gcc) == 0) + /* collect_gcc has no path, so it was found in PATH. Make sure we also + find accel-gcc in PATH. */ + gcc_path = NULL; + + int driver_used = 0; + if (gcc_path != NULL) + driver_used = sprintf (driver, "%s/", gcc_path); + sprintf (driver + driver_used, "%s", GCC_INSTALL_NAME); + + /* We may be called with all the arguments stored in some file and + passed with @file. Expand them into argv before processing. */ + expandargv (&argc, &argv); + + struct obstack argv_obstack; + obstack_init (&argv_obstack); + obstack_ptr_grow (&argv_obstack, driver); + obstack_ptr_grow (&argv_obstack, "-xlto"); + obstack_ptr_grow (&argv_obstack, "-m64"); + obstack_ptr_grow (&argv_obstack, "-S"); + + for (int ix = 1; ix != argc; ix++) + { + if (!strcmp (argv[ix], "-o") && ix + 1 != argc) + outname = argv[++ix]; + else + obstack_ptr_grow (&argv_obstack, argv[ix]); + } + + ptx_name = make_temp_file (".mkoffload"); + obstack_ptr_grow (&argv_obstack, "-o"); + obstack_ptr_grow (&argv_obstack, ptx_name); + obstack_ptr_grow (&argv_obstack, NULL); + const char **new_argv = XOBFINISH (&argv_obstack, const char **); + + char *execpath = getenv ("GCC_EXEC_PREFIX"); + char *cpath = getenv ("COMPILER_PATH"); + char *lpath = getenv ("LIBRARY_PATH"); + unsetenv ("GCC_EXEC_PREFIX"); + unsetenv ("COMPILER_PATH"); + unsetenv ("LIBRARY_PATH"); + + fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true); + obstack_free (&argv_obstack, NULL); + + xputenv (concat ("GCC_EXEC_PREFIX=", execpath, NULL)); + xputenv (concat ("COMPILER_PATH=", cpath, NULL)); + xputenv (concat ("LIBRARY_PATH=", lpath, NULL)); + + in = fopen (ptx_name, "r"); + if (!in) + fatal_error ("cannot open intermediate ptx file"); + + ptx_cfile_name = make_temp_file (".c"); + + out = fopen (ptx_cfile_name, "w"); + if (!out) + fatal_error ("cannot open '%s'", ptx_cfile_name); + + process (in, out); + fclose (out); + + compile_native (ptx_cfile_name, outname, collect_gcc); + + utils_cleanup (false); + + return 0; +} diff --git a/gcc/config/nvptx/nvptx.c b/gcc/config/nvptx/nvptx.c index 7cfe5505e71..53922bc8e85 100644 --- a/gcc/config/nvptx/nvptx.c +++ b/gcc/config/nvptx/nvptx.c @@ -2030,6 +2030,16 @@ nvptx_vector_alignment (const_tree type) return MIN (align, BIGGEST_ALIGNMENT); } +/* Record a symbol for mkoffload to enter into the mapping table. */ + +static void +nvptx_record_offload_symbol (tree decl) +{ + fprintf (asm_out_file, "//:%s_MAP %s\n", + TREE_CODE (decl) == VAR_DECL ? "VAR" : "FUNC", + IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); +} + /* Implement TARGET_ASM_FILE_START. Write the kinds of things ptxas expects at the start of a file. */ @@ -2133,6 +2143,9 @@ nvptx_file_end (void) #undef TARGET_NO_REGISTER_ALLOCATION #define TARGET_NO_REGISTER_ALLOCATION true +#undef TARGET_RECORD_OFFLOAD_SYMBOL +#define TARGET_RECORD_OFFLOAD_SYMBOL nvptx_record_offload_symbol + #undef TARGET_VECTOR_ALIGNMENT #define TARGET_VECTOR_ALIGNMENT nvptx_vector_alignment diff --git a/gcc/config/nvptx/t-nvptx b/gcc/config/nvptx/t-nvptx index 8fa2136f688..d53471f9551 100644 --- a/gcc/config/nvptx/t-nvptx +++ b/gcc/config/nvptx/t-nvptx @@ -1,2 +1,9 @@ -# +CFLAGS-mkoffload.o += $(DRIVER_DEFINES) \ + -DGCC_INSTALL_NAME=\"$(GCC_INSTALL_NAME)\" +mkoffload.o: $(srcdir)/config/nvptx/mkoffload.c + $(COMPILE) $< + $(POSTCOMPILE) +mkoffload$(exeext): mkoffload.o collect-utils.o libcommon-target.a $(LIBIBERTY) $(LIBDEPS) + +$(LINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ \ + mkoffload.o collect-utils.o libcommon-target.a $(LIBIBERTY) $(LIBS) -- 2.11.4.GIT