From patchwork Fri Mar 11 02:47:54 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Myers X-Patchwork-Id: 86357 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id E0F53B6F14 for ; Fri, 11 Mar 2011 13:48:09 +1100 (EST) Received: (qmail 24890 invoked by alias); 11 Mar 2011 02:48:07 -0000 Received: (qmail 24879 invoked by uid 22791); 11 Mar 2011 02:48:05 -0000 X-SWARE-Spam-Status: No, hits=-1.6 required=5.0 tests=AWL, BAYES_00, TW_MM, TW_MV, TW_VC, TW_XG, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 11 Mar 2011 02:47:59 +0000 Received: (qmail 8050 invoked from network); 11 Mar 2011 02:47:56 -0000 Received: from unknown (HELO digraph.polyomino.org.uk) (joseph@127.0.0.2) by mail.codesourcery.com with ESMTPA; 11 Mar 2011 02:47:56 -0000 Received: from jsm28 (helo=localhost) by digraph.polyomino.org.uk with local-esmtp (Exim 4.72) (envelope-from ) id 1PxsOQ-0001eJ-Iq; Fri, 11 Mar 2011 02:47:54 +0000 Date: Fri, 11 Mar 2011 02:47:54 +0000 (UTC) From: "Joseph S. Myers" To: gcc-patches@gcc.gnu.org cc: hpenner@de.ibm.com, uweigand@de.ibm.com, Andreas.Krebbel@de.ibm.com Subject: [4.7] Avoid global state in s390_handle_option Message-ID: MIME-Version: 1.0 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org This patch, for 4.7 and relative to a tree with applied, stops the S390 handle_option hook from using global state. S390 already had a processor enumeration, but not one suitable for direct use with Enum in the .opt file for handling -march/-mtune options because two processors (z9-109 and z9-ec) in s390_handle_arch_option have a single PROCESSOR_ value but different flags. Thus, a further enumeration is added that corresponds to the -march/-mtune values, so that those options can use the Enum facility. Three options used sscanf in s390_handle_option to read integer values; two of these are converted to use UInteger in the .opt file because the valid values can all be represented as nonnegative int values. In the case of the third, -mwarn-framesize=, the use of sscanf is retained (now storing into the options structure, of course). One format using HOST_WIDE_INT_PRINT_DEC for a value that changed type is updated; as this was a GCC diagnostic format, not a printf format, use of HOST_WIDE_INT_PRINT_DEC was incorrect there anyway and %wd was the correct way of printing HOST_WIDE_INT; I fixed the other use of HOST_WIDE_INT_PRINT_DEC in that format string, but not some other instances of the same bug in the S390 back end. (For some hosts, HOST_WIDE_INT_PRINT_DEC may only be understood by system printf and not by the GCC pretty-printers at all; furthermore, concatenation with macro expansions does not work with i18n.) Tested building cc1 and xgcc for cross to s390-linux-gnu. Will commit to trunk for 4.7 in the absence of target maintainer objections. 2011-03-10 Joseph Myers * config/s390/s390-opts.h: New. * config/s390/s390.c (s390_tune, s390_tune_flags, s390_arch, s390_arch_flags, s390_warn_framesize, s390_stack_size, s390_stack_guard): Remove. (s390_handle_arch_option): Return void. Take enum s390_arch_option value instead of string and searching array. (s390_handle_option): Don't assert that global structures are in use. Access variables via opts pointer. Use error_at. Don't use sscanf for -mstack-guard= or -mstack-size=. Update call to s390_handle_arch_option. (s390_option_override): Update call to s390_handle_arch_option. (s390_emit_prologue): Use %d format for s390_stack_size in diagnostic. Use %wd for HOST_WIDE_INT. * config/s390/s390.h (enum processor_type): Move to s390-opts.h. (s390_tune, s390_tune_flags, s390_arch, s390_arch_flags): Remove. * config/s390/s390.opt (config/s390/s390-opts.h): New HeaderInclude entry. (s390_arch_string, s390_tune, s390_tune_flags, s390_arch, s390_arch_flags, s390_warn_framesize): New Variable entries. (s390_arch_option): New Enum and EnumValue entries. (march=): Use Enum instead of Var. (mstack-guard=, mstack-size=): Use UInteger and Var. (mtune=): Use Enum. diff -rupN --exclude=.svn gcc-mainline-1/gcc/config/s390/s390-opts.h gcc-mainline/gcc/config/s390/s390-opts.h --- gcc-mainline-1/gcc/config/s390/s390-opts.h 1969-12-31 16:00:00.000000000 -0800 +++ gcc-mainline/gcc/config/s390/s390-opts.h 2011-03-10 17:45:57.000000000 -0800 @@ -0,0 +1,57 @@ +/* Definitions for option handling for IBM S/390. + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2007, 2008, 2009, 2010, 2011 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 +. */ + +#ifndef S390_OPTS_H +#define S390_OPTS_H + +/* Which processor to generate code or schedule for. The cpu attribute + defines a list that mirrors this list, so changes to s390.md must be + made at the same time. */ + +enum processor_type +{ + PROCESSOR_9672_G5, + PROCESSOR_9672_G6, + PROCESSOR_2064_Z900, + PROCESSOR_2084_Z990, + PROCESSOR_2094_Z9_109, + PROCESSOR_2097_Z10, + PROCESSOR_2817_Z196, + PROCESSOR_max +}; + +/* This enumeration must match processor_alias_table in + s390_handle_arch_option. It is different from enum processor_type + because some processors differ for option handling but not for + scheduling. */ + +enum s390_arch_option +{ + s390_arch_g5, + s390_arch_g6, + s390_arch_z900, + s390_arch_z990, + s390_arch_z9_109, + s390_arch_z9_ec, + s390_arch_z10, + s390_arch_z196 +}; + +#endif diff -rupN --exclude=.svn gcc-mainline-1/gcc/config/s390/s390.c gcc-mainline/gcc/config/s390/s390.c --- gcc-mainline-1/gcc/config/s390/s390.c 2011-02-24 08:55:51.000000000 -0800 +++ gcc-mainline/gcc/config/s390/s390.c 2011-03-10 17:54:19.000000000 -0800 @@ -278,17 +278,6 @@ struct s390_address bool literal_pool; }; -/* Which cpu are we tuning for. */ -enum processor_type s390_tune = PROCESSOR_max; -int s390_tune_flags; -/* Which instruction set architecture to use. */ -enum processor_type s390_arch; -int s390_arch_flags; - -HOST_WIDE_INT s390_warn_framesize = 0; -HOST_WIDE_INT s390_stack_size = 0; -HOST_WIDE_INT s390_stack_guard = 0; - /* The following structure is embedded in the machine specific part of struct function. */ @@ -1515,88 +1504,81 @@ s390_option_init_struct (struct gcc_opti opts->x_flag_asynchronous_unwind_tables = 1; } -/* Return true if ARG is the name of a processor. Set *TYPE and *FLAGS - to the associated processor_type and processor_flags if so. */ +/* Set *TYPE and *FLAGS to the associated processor_type and + processor_flags for processor ARCH. */ -static bool -s390_handle_arch_option (const char *arg, +static void +s390_handle_arch_option (enum s390_arch_option arch, enum processor_type *type, int *flags) { + /* This must match enum s390_arch_option in s390-opts.h. */ static struct pta { - const char *const name; /* processor name or nickname. */ const enum processor_type processor; const int flags; /* From enum processor_flags. */ } const processor_alias_table[] = { - {"g5", PROCESSOR_9672_G5, PF_IEEE_FLOAT}, - {"g6", PROCESSOR_9672_G6, PF_IEEE_FLOAT}, - {"z900", PROCESSOR_2064_Z900, PF_IEEE_FLOAT | PF_ZARCH}, - {"z990", PROCESSOR_2084_Z990, PF_IEEE_FLOAT | PF_ZARCH + {PROCESSOR_9672_G5, PF_IEEE_FLOAT}, + {PROCESSOR_9672_G6, PF_IEEE_FLOAT}, + {PROCESSOR_2064_Z900, PF_IEEE_FLOAT | PF_ZARCH}, + {PROCESSOR_2084_Z990, PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT}, - {"z9-109", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH + {PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM}, - {"z9-ec", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH + {PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP }, - {"z10", PROCESSOR_2097_Z10, PF_IEEE_FLOAT | PF_ZARCH + {PROCESSOR_2097_Z10, PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10}, - {"z196", PROCESSOR_2817_Z196, PF_IEEE_FLOAT | PF_ZARCH + {PROCESSOR_2817_Z196, PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10 | PF_Z196 }, }; - size_t i; - - for (i = 0; i < ARRAY_SIZE (processor_alias_table); i++) - if (strcmp (arg, processor_alias_table[i].name) == 0) - { - *type = processor_alias_table[i].processor; - *flags = processor_alias_table[i].flags; - return true; - } - *type = PROCESSOR_max; - *flags = 0; - return false; + *type = processor_alias_table[(int) arch].processor; + *flags = processor_alias_table[(int) arch].flags; } /* Implement TARGET_HANDLE_OPTION. */ static bool -s390_handle_option (struct gcc_options *opts, struct gcc_options *opts_set, +s390_handle_option (struct gcc_options *opts, + struct gcc_options *opts_set ATTRIBUTE_UNUSED, const struct cl_decoded_option *decoded, - location_t loc ATTRIBUTE_UNUSED) + location_t loc) { size_t code = decoded->opt_index; const char *arg = decoded->arg; - - gcc_assert (opts == &global_options); - gcc_assert (opts_set == &global_options_set); + int value = decoded->value; switch (code) { case OPT_march_: - return s390_handle_arch_option (arg, &s390_arch, &s390_arch_flags); + s390_handle_arch_option ((enum s390_arch_option) value, + &opts->x_s390_arch, + &opts->x_s390_arch_flags); + opts->x_s390_arch_string = arg; + return true; case OPT_mstack_guard_: - if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_guard) != 1) - return false; - if (exact_log2 (s390_stack_guard) == -1) - error ("stack guard value must be an exact power of 2"); + if (exact_log2 (value) == -1) + error_at (loc, "stack guard value must be an exact power of 2"); return true; case OPT_mstack_size_: - if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_size) != 1) - return false; - if (exact_log2 (s390_stack_size) == -1) - error ("stack size must be an exact power of 2"); + if (exact_log2 (value) == -1) + error_at (loc, "stack size must be an exact power of 2"); return true; case OPT_mtune_: - return s390_handle_arch_option (arg, &s390_tune, &s390_tune_flags); + s390_handle_arch_option ((enum s390_arch_option) value, + &opts->x_s390_tune, + &opts->x_s390_tune_flags); + return true; case OPT_mwarn_framesize_: - return sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_warn_framesize) == 1; + return sscanf (arg, HOST_WIDE_INT_PRINT_DEC, + &opts->x_s390_warn_framesize) == 1; default: return true; @@ -1622,7 +1604,8 @@ s390_option_override (void) if (!s390_arch_string) { s390_arch_string = TARGET_ZARCH? "z900" : "g5"; - s390_handle_arch_option (s390_arch_string, &s390_arch, &s390_arch_flags); + s390_handle_arch_option ((TARGET_ZARCH ? s390_arch_z900 : s390_arch_g5), + &s390_arch, &s390_arch_flags); } /* This check is triggered when the user specified a wrong -march= @@ -8068,10 +8051,9 @@ s390_emit_prologue (void) if (cfun_frame_layout.frame_size >= s390_stack_size) { - warning (0, "frame size of function %qs is " - HOST_WIDE_INT_PRINT_DEC + warning (0, "frame size of function %qs is %wd" " bytes exceeding user provided stack limit of " - HOST_WIDE_INT_PRINT_DEC " bytes. " + "%d bytes. " "An unconditional trap is added.", current_function_name(), cfun_frame_layout.frame_size, s390_stack_size); diff -rupN --exclude=.svn gcc-mainline-1/gcc/config/s390/s390.h gcc-mainline/gcc/config/s390/s390.h --- gcc-mainline-1/gcc/config/s390/s390.h 2011-02-02 13:22:55.000000000 -0800 +++ gcc-mainline/gcc/config/s390/s390.h 2011-03-10 17:45:27.000000000 -0800 @@ -24,22 +24,6 @@ along with GCC; see the file COPYING3. #ifndef _S390_H #define _S390_H -/* Which processor to generate code or schedule for. The cpu attribute - defines a list that mirrors this list, so changes to s390.md must be - made at the same time. */ - -enum processor_type -{ - PROCESSOR_9672_G5, - PROCESSOR_9672_G6, - PROCESSOR_2064_Z900, - PROCESSOR_2084_Z990, - PROCESSOR_2094_Z9_109, - PROCESSOR_2097_Z10, - PROCESSOR_2817_Z196, - PROCESSOR_max -}; - /* Optional architectural facilities supported by the processor. */ enum processor_flags @@ -53,16 +37,10 @@ enum processor_flags PF_Z196 = 64 }; -extern enum processor_type s390_tune; -extern int s390_tune_flags; - /* This is necessary to avoid a warning about comparing different enum types. */ #define s390_tune_attr ((enum attr_cpu)s390_tune) -extern enum processor_type s390_arch; -extern int s390_arch_flags; - /* These flags indicate that the generated code should run on a cpu providing the respective hardware facility regardless of the current cpu mode (ESA or z/Architecture). */ diff -rupN --exclude=.svn gcc-mainline-1/gcc/config/s390/s390.opt gcc-mainline/gcc/config/s390/s390.opt --- gcc-mainline-1/gcc/config/s390/s390.opt 2011-01-04 03:50:51.000000000 -0800 +++ gcc-mainline/gcc/config/s390/s390.opt 2011-03-10 17:45:08.000000000 -0800 @@ -1,6 +1,6 @@ ; Options for the S/390 / zSeries port of the compiler. -; Copyright (C) 2005, 2006, 2007, 2010 Free Software Foundation, Inc. +; Copyright (C) 2005, 2006, 2007, 2010, 2011 Free Software Foundation, Inc. ; ; This file is part of GCC. ; @@ -18,6 +18,30 @@ ; along with GCC; see the file COPYING3. If not see ; . +HeaderInclude +config/s390/s390-opts.h + +; The architecture name to use in diagnostics. +Variable +const char *s390_arch_string + +; Which cpu are we tuning for. +Variable +enum processor_type s390_tune = PROCESSOR_max + +Variable +int s390_tune_flags + +; Which instruction set architecture to use. +Variable +enum processor_type s390_arch + +Variable +int s390_arch_flags + +Variable +HOST_WIDE_INT s390_warn_framesize = 0 + m31 Target Report RejectNegative Negative(m64) InverseMask(64BIT) 31 bit ABI @@ -27,9 +51,36 @@ Target Report RejectNegative Negative(m3 64 bit ABI march= -Target RejectNegative Joined Var(s390_arch_string) +Target RejectNegative Joined Enum(s390_arch_option) Generate code for given CPU +Enum +Name(s390_arch_option) Type(enum s390_arch_option) + +EnumValue +Enum(s390_arch_option) String(g5) Value(s390_arch_g5) + +EnumValue +Enum(s390_arch_option) String(g6) Value(s390_arch_g6) + +EnumValue +Enum(s390_arch_option) String(z900) Value(s390_arch_z900) + +EnumValue +Enum(s390_arch_option) String(z990) Value(s390_arch_z990) + +EnumValue +Enum(s390_arch_option) String(z9-109) Value(s390_arch_z9_109) + +EnumValue +Enum(s390_arch_option) String(z9-ec) Value(s390_arch_z9_ec) + +EnumValue +Enum(s390_arch_option) String(z10) Value(s390_arch_z10) + +EnumValue +Enum(s390_arch_option) String(z196) Value(s390_arch_z196) + mbackchain Target Report Mask(BACKCHAIN) Maintain backchain pointer @@ -71,15 +122,15 @@ Target Report RejectNegative Negative(mh Disable hardware floating point mstack-guard= -Target RejectNegative Joined +Target RejectNegative Joined UInteger Var(s390_stack_guard) Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered mstack-size= -Target RejectNegative Joined +Target RejectNegative Joined UInteger Var(s390_stack_size) Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit mtune= -Target RejectNegative Joined +Target RejectNegative Joined Enum(s390_arch_option) Schedule code for given CPU mmvcle