[UPC,01/22] front-end changes

Background
----------

An overview email, describing the UPC-related changes is here:
  https://gcc.gnu.org/ml/gcc-patches/2015-12/msg00005.html

The GUPC branch is described here:
  http://gcc.gnu.org/projects/gupc.html

The UPC-related source code differences are summarized here:
  http://gccupc.org/gupc-changes

All languages (c, c++, fortran, go, lto, objc, obj-c++) have been
bootstrapped; no test suite regressions were introduced,
relative to the GCC trunk.

If you are on the cc-list, your name was chosen either
because you are listed as a maintainer for the area that
applies to the patches described in this email, or you
were a frequent contributor of patches made to files listed
in this email.

In the change log entries included in each patch, the directory
containing the affected files is listed, followed by the files.
When the patches are applied, the change log entries will be
distributed to the appropriate ChangeLog file.

Overview
--------

UPC introduces the following keywords:

    relaxed	shared		strict
    upc_barrier	upc_blocksizeof	upc_elemsizeof
    upc_forall	upc_localsizeof	upc_notify	upc_wait

UPC has three new type qualifiers: shared, strict, and relaxed.
In addition, UPC defines a "layout qualifier", also known as the
"blocking factor".  The "layout qualifier" is an integral constant
which defaults to the value 1.  The maximum blocking factor is
implementation defined.  A value of 0 indicates that there is no
distribution across threads; this is called the "indefinite blocking factor".

The following example illustrates the use of the UPC "shared" qualifier
combined with a layout qualifier.

    #define BLKSIZE 5
    #define N_PER_THREAD (4 * BLKSIZE)
    shared [BLKSIZE] double A[N_PER_THREAD*THREADS];

Above the "[BLKSIZE]" construct is the UPC layout factor; this
specifies that the shared array, A, distributes its elements across
each thread in blocks of 5 elements.  If the program is run with two
threads, then A is distributed as shown below:

    Thread 0	Thread 1
    --------	---------
    A[ 0.. 4]	A[ 5.. 9]
    A[10..14]	A[15..19]
    A[20..24]	A[25..29]
    A[30..34]	A[35..39]

The elements shown for thread 0 are defined as having "affinity"
to thread 0.  Similarly, those elements shown for thread 1 have
affinity to thread 1.  In UPC, a pointer to a shared object can be
cast to a thread local pointer (a "C" pointer), when the designated
shared object has affinity to the referencing thread.

A UPC "pointer-to-shared" (PTS) is a pointer that references a UPC
shared object.  A UPC pointer-to-shared is a "fat" pointer with the
following logical fields:
   (virt_addr, thread, phase)

The virtual address (virt_addr) field is combined with the thread
number (thread) to derive the location of the referenced object
within the UPC shared address space.  The phase field is used
keep track of the current block offset for PTS's that have
a blocking factor that is greater than one.

GUPC implements pointer-to-shared objects using a "struct" internal
representation.  Until recently, GUPC also supported a "packed"
representation, which is more space efficient, but limits the range of
various fields in the UPC pointer-to-shared representation.  We have
decided to support only the "struct" representation so that the
compiler uses a single ABI that supports the full range of addresses,
threads, and blocking factors.

GCC's internal tree representation is extended to record the UPC
"shared", "strict", "relaxed" qualifiers, and the layout qualifier.

UPC introduces several additional new statements:
  - upc_barrier, upc_notify, and upc_wait are synchronization statements.
  - upc_forall is an iterating statement which extends the for statement
    by adding an additional "affinity" clause.  Only iterations where
    the affinity clause is true will be executed on a given thread.

UPC introduces the following unary operators which have a similar
form to C's "sizeof" operator:

  - upc_blocksizeof returns the blocking factor of a UPC shared type
  or expression.
  - upc_elemsizeof returns the element size of a UPC shared type
  or expression.
  - upc_localsizeof returns the maximum size allocated to a thread of
  a UPC shared type or expression.

UPC introduces two reserved identifiers:

  - THREADS gives the number of UPC threads allocated to a UPC program.
  The value may be specified at compile-time via the -fupc-threads=N switch
  (a static thread count), or at run time (a dynamic thread count).
  It is common practice to include THREADS as a multiplier in an array
  index declaration.  If the THREADS multiplier is given at runtime
  (dynamic), the array dimension is said to be "THREADS scaled".
  - MYTHREAD returns the thread number of the current executing thread.
  It is in the range 0..(THREADS-1).

To compile a UPC program, the -fupc compiler switch must be supplied.
The driver program, gupc (aka upc), will implicitly add the -fupc switch
and invoke GCC.  Within GCC, the flag_upc variable is set if -fupc
is supplied; this variable is tested to determine if UPC constructs
should be accepted.

In general, parsing and processing of regular "C" code is ensured
by either protecting the UPC logic with a test for flag_upc, or
by testing the TREE_SHARED() or TYPE_SHARED() flags.  Since
the "shared" flag can only be set when compiling UPC code, it
is safe to test for the shared flag without the need to first
check that flag_upc has been asserted.

To accommodate UPC's "layout qualifier", c_build_qualified_type()
was renamed to c_build_qualified_type_1() and an additional
"layout_qualifier" argument was added.  To limit the impact of this
change on both the C and C++ front-ends, c_build_qualified_type()
is re-defined as a macro which passes a NULL value for the layout_qualifier.

When the -fupc-pthreads-model-tls compilation switch is asserted
UPC threads are implemented as POSIX threads (pthreads).  (Normally,
a UPC thread is mapped to an OS process.)  In this compilation mode,
all file scope "C" variables are "localized" by internally designating
them as TLS (thread-local storage) variables.  This is necessary to
preserve the view that UPC threads have separate per-thread file scope
variables.  The logic in c-family/c-lex.c that tracks the depth of C
system headers is generalized so that it is no longer contingent upon
NO_IMPLICIT_EXTERN_C being asserted.  If c_header_level is greater
than 0, then a variable declaration is assumed to be declared in a
system header, and is not subject to localization.

UPC defines two new kinds of pragmas:

  - #pragma [ upc strict | relaxed | upc_code | c_code ]
  The 'strict' and 'relaxed' clauses can be introduced only
  immediately following an opening brace ({) symbol.  They introduce
  a default UPC consistency mode (relaxed or strict) within the
  bracketed scope.  The 'upc_code' clause specifies that following
  text is to be compiled as UPC code, and the 'c_code' clause specifies
  that the following text is regular C code (and UPC keywords are disabled).
  - #pragma pupc [ on | off ]
  The 'pupc' pragma is defined by the UPC performance monitoring standard.

When UPC shared variable declarations are parsed, they will be assigned
to a "upc_shared" linker section.  This is done in grokdeclarator()
where it calls upc_set_decl_section().  This linker section is ideally
not loadable and is used only to coalesce UPC shared variables and to
assign offsets of those variables within the UPC global shared region.

The UPC lowering pass, upc_genericize(), is called just prior
to c_genericize() in finish_function().  upc_genericize() will
lower all UPC constructs into GENERIC.

In c/c-tree.h, the 'pointer_quals' field is re-implemented as a struct
to support the addition of the UPC "layout qualifier".

	 /* For pointers, the qualifiers on the pointer type.  */
    -    int pointer_quals;
    +    struct {
    +      int quals;
    +      tree upc_layout_qual;
    +    } pointer;

2015-11-30  Gary Funck  <gary@intrepid.com>

	gcc/c-family/
	* c-common.c (flag_upc_threads, flag_upc_pthreads,
	upc_pthreads_model): New.  Declare UPC-related flag variables.
	(c_common_r): Define UPC keywords.
	(c_fully_fold_internal): Avoid attempts to fold references
	to UPC shared components.
	(pointer_int_sum): Drop the shared qualifier on the result type.
	(c_apply_type_quals_to_decl): Apply UPC qualifiers.
	(c_common_get_alias_set): Make UPC pointers-to-shared conflict
	with everything else.
	(upc_num_threads): New.
	(c_sizeof_or_alignof_type): Issue error for mis-use of
	UPC "shared void *" type.
	(c_sizeof_or_alignof_type): Handle sizeof applied to
	UPC shared arrays with index scaled by THREADS.
	(complete_array_type): For incomplete array types,
	force an indefinite layout qualifier.
	(c_common_init_ts): call MARK_TS_COMMON for
	UPC_FORALL_STMT and UPC_SYNC_STMT.
	* c-common.def (UPC_FORALL_STMT, UPC_SYNC_STMT):
	New.  Define UPC-specific statement tree nodes.
	* c-common.h (rid): Add UPC keywords.
	(UPC_IS_KEYWORD): New macro.
	(D_UPC): New macro.
	(flag_upc_threads): New variable extern.
	(flag_upc_pthreads): New variable extern.
	(upc_pthreads_model_kind): New enum.
	(upc_pthreads_model): New variable extern.
	(c_build_qualified_type_1): New prototype, renames
	c_build_qualified_type and adds a UPC layout qualifier argument.
	(c_build_qualified_type): New macro.  Pass NULL for UPC layout
	qualifier to c_build_qualified_type_1().
	(upc_num_threads): New prototype.
	(UPC_SYNC_OP): New macro.  Access the operation field of a
	UPC synchronization statement.
	(UPC_SYNC_ID): New macro.  Access the barrier identifier field of a
	UPC synchronization statement.
	(UPC_SYNC_NOTIFY_OP): New macro.
	(UPC_SYNC_WAIT_OP): New macro.
	(UPC_SYNC_BARRIER_OP): New macro.
	* c-cppbuiltin.c: #include "c-upc-pts.h".
	(strip_section_prefix): New. Remove section name prefixes
	used for Darwin.
	(upc_cpp_builtins): New. Generate UPC specific pre-defined macros.
	(c_cpp_builtins): Call upc_cpp_builtins(), if -fupc is asserted.
	* c-lex.c (fe_file_change): Track C header level for regular "C"
	in addition to C++.  Used by UPC when UPC threads are mapped
	to pthreads; in this case, file scope variables (that are not
	declared in a system header) are converted to TLS variables.
	* c-pragma.c: #include "langhooks.h".
	(UPC_CMODE_STACK_INCREMENT): New macro.
	(pragma_upc_permitted): New variable.
	(upc_cmode): New variable.
	(upc_cmode_stack): New variable.
	(upc_cmode_stack_in_use): New variable.
	(upc_cmode_stack_allocated): New variable.
	(init_pragma_upc): New.  Initialize the variables used to manage
	the current UPC consistency mode (strict/relaxed).
	(handle_pragma_upc): New.  Handle #pragma upc.
	(set_upc_consistency_mode): New.
	(get_upc_consistency_mode): New.
	(permit_pragma_upc): New.
	(deny_pragma_upc): New.
	(pragma_upc_permitted_p): New.
	(push_upc_consistency_mode): New.
	(pop_upc_consistency_mode): New.
	(pragma_pupc_on): New variable.
	(init_pragma_pupc): New.
	(handle_pragma_pupc): New.
	(get_upc_pupc_mode): New.
	(disable_pupc_mode): New.
	(set_pupc_mode): New.
	(handle_pragma_pupc): New.
	(init_pragma): Register the "upc" and "pupc" pragmas,
	if -fupc is asserted.
	* c-pragma.h (deny_pragma_upc): New prototype.
	(get_upc_consistency_mode): New prototype.
	(permit_pragma_upc): New prototype.
	(pop_upc_consistency_mode): New prototype.
	(pragma_upc_permitted_p): New prototype.
	(push_upc_consistency_mode): New prototype.
	(set_upc_consistency_mode): New prototype.
	* c-pretty-print.c (pp_c_cv_qualifiers): Print UPC qualifiers:
	shared, strict, and relaxed.
	gcc/c/
	* c-convert.c: #include "c-upc.h".
	(convert): Drop the 'shared' qualifier when considering conversions
	of expression values.
	* c-decl.c: Add #include "c-upc.h".
	Add #include "c-upc-low.h".
	(c_build_pointer_type): Call build_pointer_type() directly for
	UPC pointers-to-shared.
	(merge_decls): Merge UPC shared flag and layout qualifier
	for variable declarations, set it as volatile.
	(implicit_decl_warning): Add logic to diagnose use of
	deprecated UPC statements ("barrier" instead of "upc_barrier", etc.).
	(undeclared_variable): Likewise.
	(quals_from_declspecs): Extract UPC qualifiers from declspec.
	(finish_decl): Add UPC-specific error diagnostics.
	(finish_decl): Call upc_check_decl(), if -fupc is asserted.
	(grokdeclarator): sharedp, strictp, relaxedp: New variables.
	(grokdeclarator): upc_threads_ref, upc_layout_qualifier,
	upc_elem_block_factor, upc_block_factor: New variables.
	(grokdeclarator): Handle UPC qualifiers (shared, strict, relaxed)
	and UPC layout qualifiers (blocking factor).
	(grokdeclarator): Change calls to c_build_qualified_type() into calls
	to c_build_qualified_type_1(), passing the UPC layout qualifier.
	(grokdeclarator): Call upc_set_decl_section() for UPC shared
	variables, or file scope variables if -fupc-pthreads-model-tls
	is asserted.
	(finish_function): Call upc_genericize(), if -fupc is asserted.
	(make_pointer_declarator): upc_layout_qual: New variable.
	(make_pointer_declarator): Augment pointer qualifiers
	with UPC layout qualifier (blocking factor).
	(build_null_declspecs): Initialize 'upc_layout_qualifier' field.
	Initialize shared_p, strict_p, and relaxed_p fields.
	(declspecs_add_qual): Process UPC shared, strict, relaxed,
	and layout qualifiers.
	* c-objc-common.c: Add #include "options.h"
	Add #include "c-upc-lang.h".  Add #include "c-upc.h".
	(c_objc_common_init): Call upc_lang_init() if -fupc asserted
	and c_common_init() succeeded.
	(upc_types_compatible_p): New. Check for the possible need
	to convert UPC-specific types.
	(c_types_compatible_p): Call upc_types_compatible_p() if comptypes()
	failed and -fupc is asserted.
	* c-parser.c: Add #include "c-upc.h".
	Add #include "c-upc-gasp.h". Add #include "c-upc-pts-ops.h".
	(c_parse_init): Disable UPC keywords, unless -fupc is asserted.
	(c_token_starts_typename): Add UPC qualifiers: shared, strict,
	and relaxed as tokens that can start a typename.
	(c_token_is_qualifier): Add UPC qualifiers: shared, strict,
	and relaxed as qualifier tokens.
	(c_token_starts_declspecs): Add UPC qualifiers: shared, strict,
	and relaxed as tokens that can start a declspec.
	(c_parser_declspecs): Parse UPC qualifiers: shared, strict,
	and relaxed.
	(c_parser_compound_statement_nostart): Process (and allow)
	all #pragma upc statements that occur just after an
	opening brace.  This the only place they're allowed.
	Call push_upc_consistency_mode() and pop_upc_consistency_mode()
	for opening and closing brackets, respectively.
	(c_parser_statement_after_labels): Call c_parser_upc_sync_statement()
	to parse upc_barrier, upc_notify, and upc_wait statements.
	Call c_parser_upc_forall_statement() to parse a upc_forall statement.
	(c_parser_unary_expression): Parse upc_blocksizeof,
	upc_elemsizeof, upc_localsizeof operators.
	(upc_blocksizeof_expr): New. Return the result of upc_blocksizeof
	applied to EXPR.
	(upc_blocksizeof_type): New. Return the result of upc_blocksizeof
	applied to T.
	(upc_elemsizeof_expr): New. Return the result of upc_elemsizeof
	applied to EXPR.
	(upc_elemsizeof_type): New. Return the result of upc_elemsizeof
	applied to T.
	(upc_localsizeof_expr): New. Return the result of upc_localsizeof
	applied to EXPR.
	(upc_localsizeof_type): New. Return the result of upc_localsizeof
	applied to T.
	(c_parser_sizeof_expression): keyword: New variable.
	Handle upc_*_sizeof (type) operations, based on the value of keyword.
	Handle upc_*_sizeof (expr) operations, based on the value of keyword.
	(c_parser_upc_shared_qual): New. Parse UPC shared qualifier,
	inclusive of the layout qualifier (blocking factor).
	(upc_affinity_test): New.  Implement UPC's upc_forall 'affinity' test.
	(c_parser_upc_forall_statement): New. Parse a UPC upc_forall statement.
	(upc_build_sync_stmt): New. For the given kind of UPC synchronization
	statement build a UPC_SYNC_STMT tree node; add it to
	the current statement list.
	(c_parser_upc_sync_statement): New. Parse a UPC synchronization
	statement (upc_barrier, upc_notify, and upc_wait).
	* c-tree.h (struct c_declspecs): upc_layout_qualifier: New field.
	For UPC, this is the blocking factor (layout qualifier).
	shared_p: New field.  Indicates that "shared" was specified.
	strict_p: New field.  Indicates that "strict" was specified.
	relaxed_p: New field.  Indicates that "relaxed" was specified.
	struct pointer: New struct field.  Replaces 'pointer_quals'
	by including 'quals' as a field and introduces a 'upc_layout_qual'
	field to hold the UPC layout qualifier, if present.
	(c_cvt_expr_for_assign): New prototype.
	* c-typeck.c: Add #include "c-upc.h".
	Add #include "c-upc-low.h".
	(qualify_type): result_type: New variable.
	result_quals: New variable.
	result_block_factor: New variable.
	Add logic to merge in a new UPC blocking factor only
	if one/other is NULL. Otherwise, they must match.
	Call c_build_qualified_type_1 with UPC layout qualifier
	(if present) instead of build_qualified_type().
	(common_pointer_type): target_block_factor: New variable.
	If 'target_quals' include "shared", then set 'target_block_factor'
	to the value present in the pointed-to type.
	Call c_build_qualified_type_1() with 'target_block_factor'
	instead of calling build_pointer_type().
	(comptypes_internal): If the type is UPC shared qualified,
	the block sizes have to be equal.
	(default_conversion): Call array_to_pointer_conversion()
	for conversions involving UPC shared array types.
	This helps the UPC lowering pass and bypasses code that
	attempts to optimize regular array references.
	(build_component_ref): Add a gcc_assert() to insure
	that the field tree node does not assert TREE_SHARED().
	sub_elem_type: New variable.
	upc_block_factor: New variable.
	For all references to UPC shared struct components,
	set the UPC blocking factor to 0, as required by the language spec.
	If 'datum' asserts TREE_SHARED(), then set it in 'ref'.
	(build_indirect_ref): If 't' asserts TREE_SHARED(), then
	set it in 'ref'.
	(build_array_ref): For UPC shared array types, avoid checking
	for register arrays.
	(c_pointer_int_sum): New. Return a tree for the sum or difference
	of pointer PTROP and integer INTOP.  Call upc_pts_int_sum()
	for expressions involving UPC pointer-to-shared types.
	(pointer_diff): subtrahend_type: New variable.
	Call upc_pts_diff() if either the target type or
	the subtrahend type is a UPC shared type.
	(build_unary_op): Call upc_pts_increment() for increment/decrement
	operations for UPC shared type values.
	Ensure that the result of an operation on objects that
	are UPC shared qualified, must not be shared qualified.
	(build_conditional_expr): For operations involving UPC shared types,
	return 'upc_null_pts_node' instead of 'null_pointer_node'.
	(build_c_cast): Issue error on attempt to cast to a UPC shared type;
	casts to pointers-to-shared are allowed.
	If a regular "C" null pointer is being cast to UPC pointer-to-shared,
	then set the value to 'upc_null_pts_node'.
	If casting a value that is not UPC shared into a shared type,
	then wrap the value in a non-lvalue expression.
	t_shared: New variable.
	o_shared: New variable.
	For conversions from a pointer-to-shared to a regular "C" pointer,
	or between two pointers-to-shared that are incompatible,
	(as determined the UPC language definition),
	return an explicit COVERT operation.
	Diagnose an attempt to cast a local pointer or an integer to a
	UPC pointer-to-shared as an error.
	For conversions from a UPC pointer-to-shared into an integer,
	return an explicit CONVERT operation.  The UPC lowering pass
	will handle this conversion.
	(build_modify_expr): Drop the shared qualifier, if the lhs is
	UPC shared qualified.  This will prevent the inadvertent creation
	of temporaries with "shared" asserted.
	(ERROR_FOR_ASSIGNMENT): New macro.
	Similar to WARN_FOR_ASSIGNMENT, but used to diagnose certain
	error conditions defined by the UPC language specification
	when converting between pointer-to-shared types and other types.
	(convert_for_assignment): For null pointer constants where the
	value's type is a UPC shared type, return upc_null_pts_node.
	Diagnose attempts to assign a regular "C" pointer into
	a UPC pointer-to-shared as an error.
	For conversions from a UPC null pointer-to-shared into a
	regular "C" pointer, return null_pointer_node.
	Diagnose attempts to assign a UPC pointer-to-shared into
	a regular "C" pointer as an error.
	Diagnose assignments between UPC pointers-to-shared
	with differing block sizes without a cast, as an error.
	Diagnose various cases where an attempt to make UPC pointer-to-shared
	value from an integer, as an error.
	(store_init_value): is_upc_decl_init: New variable.
	Stores the result of calling upc_check_decl_init().
	require_constant: New variable. Will be true if the
	declaration is static does not require UPC-related
	initialization code.
	Call upc_decl_init() if the initialization involves UPC
	constructs that require active initialization when the
	program executes.
	(really_start_incremental_init): Ensure that the result type
	for a construct is not UPC shared qualified.
	(c_cvt_expr_for_assign): New.  Convert EXPR to TYPE if the type of EXPR
	is assignment compatible with TYPE.
	(build_binary_op): Call c_pointer_int_sum() instead of
	pointer_int_sum().
	Diagnose an attempt to compare a UPC pointer-to-shared into
	a regular "C" pointer, as an error.
	Diagnose an attempt to compare UPC pointers-to-shared with
	differing block sizes, as an error.
	For operations that return a UPC "shared void *" result,
	return upc_pts_type_node instead of calling build_pointer_type().
	(c_build_qualified_type_1): Rename from c_build_qualified_type()
	and add a 'layout_qualifier' argument.
	When creating a new qualified type, also consider
	the UPC layout qualifier (blocking factor) when checking
	type equivalence.
	Adjust recursive call to c_build_qualified_type_1().
	* c-upc-gasp.h: New.
	* c-upc.c: New.
	* c-upc.h: New.

[UPC,01/22] front-end changes

Commit Message

Comments

Patch