[RFC] c++: parser - Support for target address spaces in C++

  Hi,

Presently, GCC supports target address spaces as a GNU extension (cf.
`info -n "(gcc)Named Address Spaces"`).  This is however supported
only by the C frontend, which is a bit sad, since all the GIMPLE
machinery is readily available and, moreover, LLVM supports this GNU
extension both for C and C++.

Here is a first attempt at a patch to enable the support for target
address spaces in C++.  The basic idea is only to make the parser
recognize address spaces, and lower them into GIMPLE, in the same
fashion as the C parser.  This also makes it possible to merge the
function `c_register_addr_space` in one place which is better than
before.

The patch still has some drawbacks compared to its C counterpart.
Namely, much like the `__restrict__` keyword, it is always enabled and
-std=c++11 won't disable it (whereas -std=c11) would reject address
spaces.  Not also that the mangler ignores address spaces, much like
it ignores __restrict__.

Depending on the reception, I'll add further testcases and will update
the relevant part of the documentation.

Cheers,
Paul

Author: Paul Iannetta <piannetta@kalray.eu>
Date:   Wed Oct 5 16:44:36 2022 +0200

    Add support for custom address spaces in C++

gcc/
	* tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.

gcc/c/
	* c-decl.c: Remove c_register_addr_space.

gcc/c-family/
	* c-common.c (c_register_addr_space): Imported from c-decl.c
	* c-common.h: Remove the FIXME.

gcc/cp/
	* cp-tree.h (enum cp_decl_spec): Add addr_space support.
            (struct cp_decl_specifier_seq): Likewise.
	* decl.c (get_type_quals): Likewise.
	* parser.c (cp_parser_type_specifier): Likewise.
            (cp_parser_cv_qualifier_seq_opt): Likewise
	* tree.c: Remove c_register_addr_space stub.

Signed-off-by: Paul Iannetta <piannetta@kalray.eu>
  

On 10/6/22 10:34, Paul Iannetta wrote:
> Hi,
> 
> Presently, GCC supports target address spaces as a GNU extension (cf.
> `info -n "(gcc)Named Address Spaces"`).  This is however supported
> only by the C frontend, which is a bit sad, since all the GIMPLE
> machinery is readily available and, moreover, LLVM supports this GNU
> extension both for C and C++.
> 
> Here is a first attempt at a patch to enable the support for target
> address spaces in C++.  The basic idea is only to make the parser
> recognize address spaces, and lower them into GIMPLE, in the same
> fashion as the C parser.  This also makes it possible to merge the
> function `c_register_addr_space` in one place which is better than
> before.

Great.

> The patch still has some drawbacks compared to its C counterpart.
> Namely, much like the `__restrict__` keyword, it is always enabled and
> -std=c++11 won't disable it (whereas -std=c11) would reject address
> spaces.  Not also that the mangler ignores address spaces, much like
> it ignores __restrict__.

Hmm?  We mangle __restrict:

void f(int *__restrict *p) { } // _Z1fPrPi

but cv-qualifiers (including restrict) are dropped on the top-level type 
of a parameter.

If address spaces should be mangled, it probably makes sense to use the 
same <extended-qualifier> mangling that we already use for attributes in 
write_CV_qualifiers_for_type.

> Depending on the reception, I'll add further testcases and will update
> the relevant part of the documentation.

Please.

> Cheers,
> Paul
> 
> Author: Paul Iannetta <piannetta@kalray.eu>
> Date:   Wed Oct 5 16:44:36 2022 +0200
> 
>      Add support for custom address spaces in C++
> 
> gcc/
> 	* tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> 
> gcc/c/
> 	* c-decl.c: Remove c_register_addr_space.
> 
> gcc/c-family/
> 	* c-common.c (c_register_addr_space): Imported from c-decl.c
> 	* c-common.h: Remove the FIXME.
> 
> gcc/cp/
> 	* cp-tree.h (enum cp_decl_spec): Add addr_space support.
>              (struct cp_decl_specifier_seq): Likewise.
> 	* decl.c (get_type_quals): Likewise.
> 	* parser.c (cp_parser_type_specifier): Likewise.
>              (cp_parser_cv_qualifier_seq_opt): Likewise
> 	* tree.c: Remove c_register_addr_space stub.
> 
> Signed-off-by: Paul Iannetta <piannetta@kalray.eu>
> 
> diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
> index 064c2f263f0..282ba54ab70 100644
> --- a/gcc/c-family/c-common.c
> +++ b/gcc/c-family/c-common.c
> @@ -2615,6 +2615,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>     return build_nonstandard_integer_type (width, unsignedp);
>   }
>   
> +/* Register reserved keyword WORD as qualifier for address space AS.  */
> +
> +void
> +c_register_addr_space (const char *word, addr_space_t as)
> +{
> +  int rid = RID_FIRST_ADDR_SPACE + as;
> +  tree id;
> +
> +  /* Address space qualifiers are only supported
> +     in C with GNU extensions enabled.  */
> +  if (c_dialect_objc () || flag_no_asm)
> +    return;
> +
> +  id = get_identifier (word);
> +  C_SET_RID_CODE (id, rid);
> +  TREE_LANG_FLAG_0 (id) = 1;
> +  ridpointers[rid] = id;
> +}
> +
>   /* The C version of the register_builtin_type langhook.  */
>   
>   void
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index ed39b7764bf..f2c1df0c8de 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -808,9 +808,6 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>   
>   extern tree (*make_fname_decl) (location_t, tree, int);
>   
> -/* In c-decl.c and cp/tree.c.  FIXME.  */
> -extern void c_register_addr_space (const char *str, addr_space_t as);
> -
>   /* In c-common.c.  */
>   extern bool in_late_binary_op;
>   extern const char *c_addr_space_name (addr_space_t as);
> @@ -926,6 +923,7 @@ extern void c_common_finish (void);
>   extern void c_common_parse_file (void);
>   extern FILE *get_dump_info (int, dump_flags_t *);
>   extern alias_set_type c_common_get_alias_set (tree);
> +extern void c_register_addr_space (const char *, addr_space_t);
>   extern void c_register_builtin_type (tree, const char*);
>   extern bool c_promoting_integer_type_p (const_tree);
>   extern bool self_promoting_args_p (const_tree);
> diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
> index 8e24b522ee4..278d1248d1c 100644
> --- a/gcc/c/c-decl.c
> +++ b/gcc/c/c-decl.c
> @@ -11927,25 +11927,6 @@ c_parse_final_cleanups (void)
>     ext_block = NULL;
>   }
>   
> -/* Register reserved keyword WORD as qualifier for address space AS.  */
> -
> -void
> -c_register_addr_space (const char *word, addr_space_t as)
> -{
> -  int rid = RID_FIRST_ADDR_SPACE + as;
> -  tree id;
> -
> -  /* Address space qualifiers are only supported
> -     in C with GNU extensions enabled.  */
> -  if (c_dialect_objc () || flag_no_asm)
> -    return;
> -
> -  id = get_identifier (word);
> -  C_SET_RID_CODE (id, rid);
> -  C_IS_RESERVED_WORD (id) = 1;
> -  ridpointers [rid] = id;
> -}
> -
>   /* Return identifier to look up for omp declare reduction.  */
>   
>   tree
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 15ec4cd199f..4ae971ccb90 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -5974,6 +5974,7 @@ enum cp_decl_spec {
>     ds_const,
>     ds_volatile,
>     ds_restrict,
> +  ds_addr_space,
>     ds_inline,
>     ds_virtual,
>     ds_explicit,
> @@ -6046,6 +6047,8 @@ struct cp_decl_specifier_seq {
>     /* True iff the alternate "__intN__" form of the __intN type has been
>        used.  */
>     BOOL_BITFIELD int_n_alt: 1;
> +  /* The address space that the declaration belongs to.  */
> +  addr_space_t address_space;
>   };
>   
>   /* The various kinds of declarators.  */
> diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
> index 03cd0a3a238..b8fc8b58ac7 100644
> --- a/gcc/cp/decl.c
> +++ b/gcc/cp/decl.c
> @@ -4954,6 +4954,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>       type_quals |= TYPE_QUAL_VOLATILE;
>     if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>       type_quals |= TYPE_QUAL_RESTRICT;
> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>   
>     return type_quals;
>   }
> diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
> index f48c856fa94..8d6b2a44086 100644
> --- a/gcc/cp/parser.c
> +++ b/gcc/cp/parser.c
> @@ -17796,6 +17796,16 @@ cp_parser_type_specifier (cp_parser* parser,
>         break;
>       }
>   
> +
> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> +    {
> +      ds = ds_addr_space;
> +      if (is_cv_qualifier)
> +	*is_cv_qualifier = true;
> +      decl_specs->address_space = keyword - RID_FIRST_ADDR_SPACE;
> +    }
> +
> +
>     /* Handle simple keywords.  */
>     if (ds != ds_last)
>       {
> @@ -21853,6 +21863,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>      GNU Extension:
>   
>      cv-qualifier:
> +     address-space-qualifier
>        __restrict__
>   
>      Returns a bitmask representing the cv-qualifiers.  */
> @@ -21889,6 +21900,13 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>   	  break;
>   	}
>   
> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> +	  token->keyword <= RID_LAST_ADDR_SPACE)
> +	{
> +	  cv_qualifier =
> +	    ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> +	}
> +
>         if (!cv_qualifier)
>   	break;
>   
> diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
> index 10b818d1370..55b57085618 100644
> --- a/gcc/cp/tree.c
> +++ b/gcc/cp/tree.c
> @@ -5749,15 +5749,6 @@ cp_free_lang_data (tree t)
>       DECL_CHAIN (t) = NULL_TREE;
>   }
>   
> -/* Stub for c-common.  Please keep in sync with c-decl.c.
> -   FIXME: If address space support is target specific, then this
> -   should be a C target hook.  But currently this is not possible,
> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> -void
> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> -{
> -}
> -
>   /* Return the number of operands in T that we care about for things like
>      mangling.  */
>   
> diff --git a/gcc/tree.h b/gcc/tree.h
> index bb80e81d389..210ef7b85d7 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -2108,7 +2108,7 @@ extern machine_mode vector_type_mode (const_tree);
>   
>   /* Encode/decode the named memory support as part of the qualifier.  If more
>      than 8 qualifiers are added, these macros need to be adjusted.  */
> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>   #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>   
>   /* Return all qualifiers except for the address space qualifiers.  */
> 
> 
> 
>
  

Hi,

On Thu, Oct 06, 2022 at 01:34:40PM -0400, Jason Merrill wrote:
[snip]
> 
> Hmm?  We mangle __restrict:
> 
> void f(int *__restrict *p) { } // _Z1fPrPi
> 

Indeed, I have overlooked that point.  Thank you for pointing it out.

> but cv-qualifiers (including restrict) are dropped on the top-level type of
> a parameter.
> 
> If address spaces should be mangled, it probably makes sense to use the same
> <extended-qualifier> mangling that we already use for attributes in
> write_CV_qualifiers_for_type.
> 

That's a nice feature! LLVM is using AS<number> to mangle the
address-name qualified types but that would have required an update of
libiberty's demangler in the binutils as well.  Following your advice,
I implemented the mangling of address_names as U<len>__address_name
(eg., U8__seg_fs), underscores may appear but that does not seem to be
a problem.

I don't think that there should be anything to do on the template
side, but I am no expert of what is expected of templates when it
comes to strip or forward qualifiers. So, please tell me if I
overlooked something on that side.

Now concerning the meat of the patch itself.

The C part of the support of address spaces does not appear to have
dedicated tests, especially since it is mostly a target specific
feature.  I, however, added a few tests, one for the mangling,
and others which test the different error messages that might
appear when using address spaces in an unsafe way.

Most of the patch tries to mirror the commit
               309434d678721acedb299f20cdc2b4778062b180
which introduces address spaces to the C front-end.  The C and C++
parsers share a lot but are subtly different so there might be some
discrepancies.  In particular, I ensure that address spaces do not
conflict, that only one address space can be specified at a time, and
that the type conversion mechanism pick the superset of the address
spaces if available. I also forbid address spaces in compound literals.

I have only tested the patch on x86 and on our not-yet-upstream
architecture, without seeing any regressions.

NB: I do not add a DSO for the moment because I have started the process of
assigning copyright to the FSF.

# ------------------------ >8 ------------------------
Add support for custom address spaces in C++

gcc/
        * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.

gcc/c/
        * c-decl.cc: Remove c_register_addr_space.

gcc/c-family/
        * c-common.cc (c_register_addr_space): Imported from c-decl.cc
        (addr_space_superset): Imported from gcc/c/c-typecheck.cc
        * c-common.h: Remove the FIXME.
        (addr_space_superset): Add prototype.

gcc/cp/
        * cp-tree.h (enum cp_decl_spec): Add addr_space support.
        (struct cp_decl_specifier_seq): Likewise.
        * decl.cc (get_type_quals): Likewise.
        (check_tag_decl): Likewise.
        * parser.cc (cp_parser_type_specifier): Likewise.
        (cp_parser_cv_qualifier_seq_opt): Likewise.
        (cp_parser_postfix_expression): Likewise.
        (cp_parser_type_specifier): Likewise.
        (set_and_check_decl_spec_loc): Likewise.
        * typeck.cc (composite_pointer_type): Likewise
        (comp_ptr_ttypes_real): Likewise.
        * tree.cc: Remove c_register_addr_space stub.
        * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
          using the extended qualifier notation.

gcc/doc
        * extend.texi (Named Address Spaces): add a mention about C++
          support.

gcc/testsuite/
        * g++.dg/abi/mangle-addr-space1.C: New test.
        * g++.dg/parse/addr-space.C: New test.
        * g++.dg/parse/addr-space1.C: New test.
        * g++.dg/parse/addr-space2.C: New test.

# ------------------------ >8 ------------------------
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index bb0544eeaea..ff1146ecc25 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
   return IDENTIFIER_POINTER (ridpointers [rid]);
 }
 
+/* Return true if between two named address spaces, whether there is a superset
+   named address space that encompasses both address spaces.  If there is a
+   superset, return which address space is the superset.  */
+
+bool
+addr_space_superset (addr_space_t as1, addr_space_t as2,
+		     addr_space_t * common)
+{
+  if (as1 == as2)
+    {
+      *common = as1;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as1, as2))
+    {
+      *common = as2;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as2, as1))
+    {
+      *common = as1;
+      return true;
+    }
+  else
+    return false;
+}
+
 /* Push current bindings for the function name VAR_DECLS.  */
 
 void
@@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
   return build_nonstandard_integer_type (width, unsignedp);
 }
 
+/* Register reserved keyword WORD as qualifier for address space AS.  */
+
+void
+c_register_addr_space (const char *word, addr_space_t as)
+{
+  int rid = RID_FIRST_ADDR_SPACE + as;
+  tree id;
+
+  /* Address space qualifiers are only supported
+     in C with GNU extensions enabled.  */
+  if (c_dialect_objc () || flag_no_asm)
+    return;
+
+  id = get_identifier (word);
+  C_SET_RID_CODE (id, rid);
+  TREE_LANG_FLAG_0 (id) = 1;
+  ridpointers[rid] = id;
+}
+
 /* The C version of the register_builtin_type langhook.  */
 
 void
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 52a85bfb783..d36f9e4975b 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
 
 extern tree (*make_fname_decl) (location_t, tree, int);
 
-/* In c-decl.cc and cp/tree.cc.  FIXME.  */
-extern void c_register_addr_space (const char *str, addr_space_t as);
-
 /* In c-common.cc.  */
 extern bool in_late_binary_op;
 extern const char *c_addr_space_name (addr_space_t as);
+extern const char *c_addr_space_name (addr_space_t as);
+extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
 extern tree identifier_global_value (tree);
 extern tree identifier_global_tag (tree);
 extern bool names_builtin_p (const char *);
@@ -952,6 +951,7 @@ extern void c_common_finish (void);
 extern void c_common_parse_file (void);
 extern FILE *get_dump_info (int, dump_flags_t *);
 extern alias_set_type c_common_get_alias_set (tree);
+extern void c_register_addr_space (const char *, addr_space_t);
 extern void c_register_builtin_type (tree, const char*);
 extern bool c_promoting_integer_type_p (const_tree);
 extern bool self_promoting_args_p (const_tree);
diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index c701f07befe..e1bb4f1cf37 100644
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
   ext_block = NULL;
 }
 
-/* Register reserved keyword WORD as qualifier for address space AS.  */
-
-void
-c_register_addr_space (const char *word, addr_space_t as)
-{
-  int rid = RID_FIRST_ADDR_SPACE + as;
-  tree id;
-
-  /* Address space qualifiers are only supported
-     in C with GNU extensions enabled.  */
-  if (c_dialect_objc () || flag_no_asm)
-    return;
-
-  id = get_identifier (word);
-  C_SET_RID_CODE (id, rid);
-  C_IS_RESERVED_WORD (id) = 1;
-  ridpointers [rid] = id;
-}
-
 /* Return identifier to look up for omp declare reduction.  */
 
 tree
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index e130196a3a7..17185fd3da4 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
   return type;
 }
 
-/* Return true if between two named address spaces, whether there is a superset
-   named address space that encompasses both address spaces.  If there is a
-   superset, return which address space is the superset.  */
-
-static bool
-addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
-{
-  if (as1 == as2)
-    {
-      *common = as1;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as1, as2))
-    {
-      *common = as2;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as2, as1))
-    {
-      *common = as1;
-      return true;
-    }
-  else
-    return false;
-}
-
 /* Return a variant of TYPE which has all the type qualifiers of LIKE
    as well as those of TYPE.  */
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 72f4398a8f9..f1da04c6c58 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6206,6 +6206,7 @@ enum cp_decl_spec {
   ds_const,
   ds_volatile,
   ds_restrict,
+  ds_addr_space,
   ds_inline,
   ds_virtual,
   ds_explicit,
@@ -6278,6 +6279,8 @@ struct cp_decl_specifier_seq {
   /* True iff the alternate "__intN__" form of the __intN type has been
      used.  */
   BOOL_BITFIELD int_n_alt: 1;
+  /* The address space that the declaration belongs to.  */
+  addr_space_t address_space;
 };
 
 /* The various kinds of declarators.  */
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 9f78c500a15..16cc1917085 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
     type_quals |= TYPE_QUAL_VOLATILE;
   if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
     type_quals |= TYPE_QUAL_RESTRICT;
+  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
 
   return type_quals;
 }
@@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
 	error_at (declspecs->locations[ds_restrict],
 		  "%<__restrict%> can only be specified for objects and "
 		  "functions");
+      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+	error_at (declspecs->locations[ds_addr_space],
+		  "address space can only be specified for objects and "
+		  "functions");
       else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
 	error_at (declspecs->locations[ds_thread],
 		  "%<__thread%> can only be specified for objects "
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index eb53e0ebeb4..06625ad9a4b 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -2509,6 +2509,15 @@ write_CV_qualifiers_for_type (const tree type)
      array.  */
   cp_cv_quals quals = TYPE_QUALS (type);
 
+  if (DECODE_QUAL_ADDR_SPACE (quals))
+    {
+      addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals);
+      const char *as_name = c_addr_space_name (as);
+      write_char ('U');
+      write_unsigned_number (strlen (as_name));
+      write_string (as_name);
+      ++num_qualifiers;
+    }
   if (quals & TYPE_QUAL_RESTRICT)
     {
       write_char ('r');
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 763df6f479b..110ceafc98b 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 		    postfix_expression = error_mark_node;
 		    break;
 		  }
+		if (type != error_mark_node
+		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
+		    && current_function_decl)
+		  {
+		    error
+		      ("compound literal qualified by address-space qualifier");
+		    type = error_mark_node;
+		  }
 		/* Form the representation of the compound-literal.  */
 		postfix_expression
 		  = finish_compound_literal (type, initializer,
@@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
       break;
     }
 
+
+  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
+    {
+      ds = ds_addr_space;
+      if (is_cv_qualifier)
+	*is_cv_qualifier = true;
+    }
+
+
   /* Handle simple keywords.  */
   if (ds != ds_last)
     {
@@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
    GNU Extension:
 
    cv-qualifier:
+     address-space-qualifier
      __restrict__
 
    Returns a bitmask representing the cv-qualifiers.  */
@@ -23812,6 +23830,13 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
 	  break;
 	}
 
+      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
+	  token->keyword <= RID_LAST_ADDR_SPACE)
+	{
+	  cv_qualifier =
+	    ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
+	}
+
       if (!cv_qualifier)
 	break;
 
@@ -32705,6 +32730,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
       decl_specs->locations[ds] = location;
       if (ds == ds_thread)
 	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
+      else if (ds == ds_addr_space)
+	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
     }
   else
     {
@@ -32737,6 +32764,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
 	      error_at (&richloc, "duplicate %qD", token->u.value);
 	    }
 	}
+      else if (ds == ds_addr_space)
+	{
+	  addr_space_t as1 = decl_specs->address_space;
+	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
+
+	  gcc_rich_location richloc (location);
+	  richloc.add_fixit_remove ();
+	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
+	      && as1 != as2)
+	    error_at (&richloc,
+		      "conflicting named address spaces (%s vs %s)",
+		      c_addr_space_name (as1), c_addr_space_name (as2));
+	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
+	    error_at (&richloc,
+		      "duplicate named address space %s",
+		      c_addr_space_name (as1));
+
+	  decl_specs->address_space = as2;
+	}
       else
 	{
 	  static const char *const decl_spec_names[] = {
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 3b37567cbd7..5e14ac837fc 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
     DECL_CHAIN (t) = NULL_TREE;
 }
 
-/* Stub for c-common.  Please keep in sync with c-decl.cc.
-   FIXME: If address space support is target specific, then this
-   should be a C target hook.  But currently this is not possible,
-   because this function is called via REGISTER_TARGET_PRAGMAS.  */
-void
-c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
-{
-}
-
 /* Return the number of operands in T that we care about for things like
    mangling.  */
 
diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index ceb80d9744f..5d48920e687 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
 	  else
 	    return error_mark_node;
         }
+      /* If possible merge the address space into the superset of the address
+	  spaces of t1 and t2, or raise an error. */
+      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
+      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
+      addr_space_t as_common;
+
+      /* If the two named address spaces are different, determine the common
+	 superset address space.  If there isn't one, raise an error.  */
+      if (!addr_space_superset (as_t1, as_t2, &as_common))
+	{
+	  as_common = as_t1;
+	  error_at (location,
+		    "%qT and %qT are in disjoint named address spaces",
+		    t1, t2);
+	}
       result_type
 	= cp_build_qualified_type (void_type_node,
-				   (cp_type_quals (TREE_TYPE (t1))
-				    | cp_type_quals (TREE_TYPE (t2))));
+				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
+				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
+				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
       result_type = build_pointer_type (result_type);
       /* Merge the attributes.  */
       attributes = (*targetm.merge_type_attributes) (t1, t2);
@@ -10805,6 +10821,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
 	      to_more_cv_qualified = true;
 	    }
 
+      /* Warn about conversions between pointers to disjoint
+	 address spaces.  */
+      if (TREE_CODE (from) == POINTER_TYPE
+	  && TREE_CODE (to) == POINTER_TYPE)
+	{
+	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
+	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
+	  addr_space_t as_common;
+
+	  if (!addr_space_superset (as_to, as_from, &as_common))
+	    return false;
+	}
+
 	  if (constp > 0)
 	    constp &= TYPE_READONLY (to);
 	}
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 84e6f6694ab..c89df8778b2 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
 @section Named Address Spaces
 @cindex Named Address Spaces
 
-As an extension, GNU C supports named address spaces as
+As an extension, GNU C and GNU C++ support named address spaces as
 defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
 address spaces in GCC will evolve as the draft technical report
 changes.  Calling conventions for any target might also change.  At
diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
new file mode 100644
index 00000000000..c01f8d6054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do run { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-fabi-version=8 -Wabi -save-temps" }
+// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
+
+int f (int volatile __seg_fs *a)
+{
+  return *a;
+}
+
+int main () {}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
new file mode 100644
index 00000000000..ebb6316054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
new file mode 100644
index 00000000000..2e8ee32a885
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-std=gnu++98" }
+
+int
+main ()
+{
+	struct foo {int a; char b[2];} structure;
+	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
new file mode 100644
index 00000000000..5b2c0f28078
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/tree.h b/gcc/tree.h
index 8844471e9a5..b7da4c5141a 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
 
 /* Encode/decode the named memory support as part of the qualifier.  If more
    than 8 qualifiers are added, these macros need to be adjusted.  */
-#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
+#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
 #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
 
 /* Return all qualifiers except for the address space qualifiers.  */
  

On 10/9/22 12:12, Paul Iannetta wrote:
> Hi,
> 
> On Thu, Oct 06, 2022 at 01:34:40PM -0400, Jason Merrill wrote:
> [snip]
>>
>> Hmm?  We mangle __restrict:
>>
>> void f(int *__restrict *p) { } // _Z1fPrPi
>>
> 
> Indeed, I have overlooked that point.  Thank you for pointing it out.
> 
>> but cv-qualifiers (including restrict) are dropped on the top-level type of
>> a parameter.
>>
>> If address spaces should be mangled, it probably makes sense to use the same
>> <extended-qualifier> mangling that we already use for attributes in
>> write_CV_qualifiers_for_type.
>>
> 
> That's a nice feature! LLVM is using AS<number> to mangle the
> address-name qualified types but that would have required an update of
> libiberty's demangler in the binutils as well.

And they haven't proposed this mangling to

   https://github.com/itanium-cxx-abi/cxx-abi/

yet, either.

> Following your advice,
> I implemented the mangling of address_names as U<len>__address_name
> (eg., U8__seg_fs), underscores may appear but that does not seem to be
> a problem.
> 
> I don't think that there should be anything to do on the template
> side, but I am no expert of what is expected of templates when it
> comes to strip or forward qualifiers. So, please tell me if I
> overlooked something on that side.

You certainly want some template tests, say

template <class T>
int f (T *p) { return *p; }
__seg_fs int *a;
int main() { f(a); }
// test for mangling of f<__seg_fs int>

-----

template <class T>
int f (T __seg_gs *p) { return *p; }
__seg_fs int *a;
int main() { f(a); } // error, conflicting address spaces

> Now concerning the meat of the patch itself.
> 
> The C part of the support of address spaces does not appear to have
> dedicated tests, especially since it is mostly a target specific
> feature.  I, however, added a few tests, one for the mangling,
> and others which test the different error messages that might
> appear when using address spaces in an unsafe way.
> 
> Most of the patch tries to mirror the commit
>                 309434d678721acedb299f20cdc2b4778062b180
> which introduces address spaces to the C front-end.  The C and C++
> parsers share a lot but are subtly different so there might be some
> discrepancies.  In particular, I ensure that address spaces do not
> conflict, that only one address space can be specified at a time, and
> that the type conversion mechanism pick the superset of the address
> spaces if available. I also forbid address spaces in compound literals.
> 
> I have only tested the patch on x86 and on our not-yet-upstream
> architecture, without seeing any regressions.
> 
> NB: I do not add a DSO for the moment because I have started the process of
> assigning copyright to the FSF.
> 
> # ------------------------ >8 ------------------------
> Add support for custom address spaces in C++
> 
> gcc/
>          * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> 
> gcc/c/
>          * c-decl.cc: Remove c_register_addr_space.
> 
> gcc/c-family/
>          * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>          (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>          * c-common.h: Remove the FIXME.
>          (addr_space_superset): Add prototype.
> 
> gcc/cp/
>          * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>          (struct cp_decl_specifier_seq): Likewise.
>          * decl.cc (get_type_quals): Likewise.
>          (check_tag_decl): Likewise.
>          * parser.cc (cp_parser_type_specifier): Likewise.
>          (cp_parser_cv_qualifier_seq_opt): Likewise.
>          (cp_parser_postfix_expression): Likewise.
>          (cp_parser_type_specifier): Likewise.
>          (set_and_check_decl_spec_loc): Likewise.
>          * typeck.cc (composite_pointer_type): Likewise
>          (comp_ptr_ttypes_real): Likewise.
>          * tree.cc: Remove c_register_addr_space stub.
>          * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>            using the extended qualifier notation.
> 
> gcc/doc
>          * extend.texi (Named Address Spaces): add a mention about C++
>            support.
> 
> gcc/testsuite/
>          * g++.dg/abi/mangle-addr-space1.C: New test.
>          * g++.dg/parse/addr-space.C: New test.
>          * g++.dg/parse/addr-space1.C: New test.
>          * g++.dg/parse/addr-space2.C: New test.
> 
> # ------------------------ >8 ------------------------
> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> index bb0544eeaea..ff1146ecc25 100644
> --- a/gcc/c-family/c-common.cc
> +++ b/gcc/c-family/c-common.cc
> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>     return IDENTIFIER_POINTER (ridpointers [rid]);
>   }
>   
> +/* Return true if between two named address spaces, whether there is a superset
> +   named address space that encompasses both address spaces.  If there is a
> +   superset, return which address space is the superset.  */
> +
> +bool
> +addr_space_superset (addr_space_t as1, addr_space_t as2,
> +		     addr_space_t * common)
> +{
> +  if (as1 == as2)
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as1, as2))
> +    {
> +      *common = as2;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as2, as1))
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else
> +    return false;

So it's not possible for the two spaces to both be subsets of a third?

> +}
> +
>   /* Push current bindings for the function name VAR_DECLS.  */
>   
>   void
> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>     return build_nonstandard_integer_type (width, unsignedp);
>   }
>   
> +/* Register reserved keyword WORD as qualifier for address space AS.  */
> +
> +void
> +c_register_addr_space (const char *word, addr_space_t as)
> +{
> +  int rid = RID_FIRST_ADDR_SPACE + as;
> +  tree id;
> +
> +  /* Address space qualifiers are only supported
> +     in C with GNU extensions enabled.  */
> +  if (c_dialect_objc () || flag_no_asm)
> +    return;
> +
> +  id = get_identifier (word);
> +  C_SET_RID_CODE (id, rid);
> +  TREE_LANG_FLAG_0 (id) = 1;
> +  ridpointers[rid] = id;
> +}
> +
>   /* The C version of the register_builtin_type langhook.  */
>   
>   void
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 52a85bfb783..d36f9e4975b 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>   
>   extern tree (*make_fname_decl) (location_t, tree, int);
>   
> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> -extern void c_register_addr_space (const char *str, addr_space_t as);
> -
>   /* In c-common.cc.  */
>   extern bool in_late_binary_op;
>   extern const char *c_addr_space_name (addr_space_t as);
> +extern const char *c_addr_space_name (addr_space_t as);
> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>   extern tree identifier_global_value (tree);
>   extern tree identifier_global_tag (tree);
>   extern bool names_builtin_p (const char *);
> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>   extern void c_common_parse_file (void);
>   extern FILE *get_dump_info (int, dump_flags_t *);
>   extern alias_set_type c_common_get_alias_set (tree);
> +extern void c_register_addr_space (const char *, addr_space_t);
>   extern void c_register_builtin_type (tree, const char*);
>   extern bool c_promoting_integer_type_p (const_tree);
>   extern bool self_promoting_args_p (const_tree);
> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> index c701f07befe..e1bb4f1cf37 100644
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>     ext_block = NULL;
>   }
>   
> -/* Register reserved keyword WORD as qualifier for address space AS.  */
> -
> -void
> -c_register_addr_space (const char *word, addr_space_t as)
> -{
> -  int rid = RID_FIRST_ADDR_SPACE + as;
> -  tree id;
> -
> -  /* Address space qualifiers are only supported
> -     in C with GNU extensions enabled.  */
> -  if (c_dialect_objc () || flag_no_asm)
> -    return;
> -
> -  id = get_identifier (word);
> -  C_SET_RID_CODE (id, rid);
> -  C_IS_RESERVED_WORD (id) = 1;
> -  ridpointers [rid] = id;
> -}
> -
>   /* Return identifier to look up for omp declare reduction.  */
>   
>   tree
> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> index e130196a3a7..17185fd3da4 100644
> --- a/gcc/c/c-typeck.cc
> +++ b/gcc/c/c-typeck.cc
> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>     return type;
>   }
>   
> -/* Return true if between two named address spaces, whether there is a superset
> -   named address space that encompasses both address spaces.  If there is a
> -   superset, return which address space is the superset.  */
> -
> -static bool
> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> -{
> -  if (as1 == as2)
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as1, as2))
> -    {
> -      *common = as2;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as2, as1))
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else
> -    return false;
> -}
> -
>   /* Return a variant of TYPE which has all the type qualifiers of LIKE
>      as well as those of TYPE.  */
>   
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 72f4398a8f9..f1da04c6c58 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>     ds_const,
>     ds_volatile,
>     ds_restrict,
> +  ds_addr_space,
>     ds_inline,
>     ds_virtual,
>     ds_explicit,
> @@ -6278,6 +6279,8 @@ struct cp_decl_specifier_seq {
>     /* True iff the alternate "__intN__" form of the __intN type has been
>        used.  */
>     BOOL_BITFIELD int_n_alt: 1;
> +  /* The address space that the declaration belongs to.  */
> +  addr_space_t address_space;

New non-bit-fields should be added before the bit-fields.

>   };
>   
>   /* The various kinds of declarators.  */
> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> index 9f78c500a15..16cc1917085 100644
> --- a/gcc/cp/decl.cc
> +++ b/gcc/cp/decl.cc
> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>       type_quals |= TYPE_QUAL_VOLATILE;
>     if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>       type_quals |= TYPE_QUAL_RESTRICT;
> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>   
>     return type_quals;
>   }
> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>   	error_at (declspecs->locations[ds_restrict],
>   		  "%<__restrict%> can only be specified for objects and "
>   		  "functions");
> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +	error_at (declspecs->locations[ds_addr_space],
> +		  "address space can only be specified for objects and "
> +		  "functions");
>         else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>   	error_at (declspecs->locations[ds_thread],
>   		  "%<__thread%> can only be specified for objects "
> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> index eb53e0ebeb4..06625ad9a4b 100644
> --- a/gcc/cp/mangle.cc
> +++ b/gcc/cp/mangle.cc
> @@ -2509,6 +2509,15 @@ write_CV_qualifiers_for_type (const tree type)
>        array.  */
>     cp_cv_quals quals = TYPE_QUALS (type);
>   
> +  if (DECODE_QUAL_ADDR_SPACE (quals))
> +    {
> +      addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals);

This can be

if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))

so you don't need to repeat it.

> +      const char *as_name = c_addr_space_name (as);
> +      write_char ('U');
> +      write_unsigned_number (strlen (as_name));
> +      write_string (as_name);
> +      ++num_qualifiers;
> +    }
>     if (quals & TYPE_QUAL_RESTRICT)
>       {
>         write_char ('r');
> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> index 763df6f479b..110ceafc98b 100644
> --- a/gcc/cp/parser.cc
> +++ b/gcc/cp/parser.cc
> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>   		    postfix_expression = error_mark_node;
>   		    break;
>   		  }
> +		if (type != error_mark_node
> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> +		    && current_function_decl)
> +		  {
> +		    error
> +		      ("compound literal qualified by address-space qualifier");
> +		    type = error_mark_node;
> +		  }
>   		/* Form the representation of the compound-literal.  */
>   		postfix_expression
>   		  = finish_compound_literal (type, initializer,
> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>         break;
>       }
>   
> +
> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> +    {
> +      ds = ds_addr_space;
> +      if (is_cv_qualifier)
> +	*is_cv_qualifier = true;
> +    }
> +
> +
>     /* Handle simple keywords.  */
>     if (ds != ds_last)
>       {
> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>      GNU Extension:
>   
>      cv-qualifier:
> +     address-space-qualifier
>        __restrict__
>   
>      Returns a bitmask representing the cv-qualifiers.  */
> @@ -23812,6 +23830,13 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>   	  break;
>   	}
>   
> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> +	  token->keyword <= RID_LAST_ADDR_SPACE)
> +	{
> +	  cv_qualifier =
> +	    ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> +	}

We usually omit braces around a single statement.

> +
>         if (!cv_qualifier)
>   	break;
>   
> @@ -32705,6 +32730,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>         decl_specs->locations[ds] = location;
>         if (ds == ds_thread)
>   	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> +      else if (ds == ds_addr_space)
> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>       }
>     else
>       {
> @@ -32737,6 +32764,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>   	      error_at (&richloc, "duplicate %qD", token->u.value);
>   	    }
>   	}
> +      else if (ds == ds_addr_space)
> +	{
> +	  addr_space_t as1 = decl_specs->address_space;
> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> +
> +	  gcc_rich_location richloc (location);
> +	  richloc.add_fixit_remove ();
> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> +	      && as1 != as2)
> +	    error_at (&richloc,
> +		      "conflicting named address spaces (%s vs %s)",
> +		      c_addr_space_name (as1), c_addr_space_name (as2));
> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> +	    error_at (&richloc,
> +		      "duplicate named address space %s",
> +		      c_addr_space_name (as1));
> +
> +	  decl_specs->address_space = as2;
> +	}
>         else
>   	{
>   	  static const char *const decl_spec_names[] = {
> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> index 3b37567cbd7..5e14ac837fc 100644
> --- a/gcc/cp/tree.cc
> +++ b/gcc/cp/tree.cc
> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>       DECL_CHAIN (t) = NULL_TREE;
>   }
>   
> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> -   FIXME: If address space support is target specific, then this
> -   should be a C target hook.  But currently this is not possible,
> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> -void
> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> -{
> -}
> -
>   /* Return the number of operands in T that we care about for things like
>      mangling.  */
>   
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index ceb80d9744f..5d48920e687 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>   	  else
>   	    return error_mark_node;
>           }
> +      /* If possible merge the address space into the superset of the address
> +	  spaces of t1 and t2, or raise an error. */
> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> +      addr_space_t as_common;
> +
> +      /* If the two named address spaces are different, determine the common
> +	 superset address space.  If there isn't one, raise an error.  */
> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> +	{
> +	  as_common = as_t1;
> +	  error_at (location,
> +		    "%qT and %qT are in disjoint named address spaces",
> +		    t1, t2);
> +	}
>         result_type
>   	= cp_build_qualified_type (void_type_node,
> -				   (cp_type_quals (TREE_TYPE (t1))
> -				    | cp_type_quals (TREE_TYPE (t2))));
> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>         result_type = build_pointer_type (result_type);
>         /* Merge the attributes.  */
>         attributes = (*targetm.merge_type_attributes) (t1, t2);
> @@ -10805,6 +10821,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>   	      to_more_cv_qualified = true;
>   	    }
>   
> +      /* Warn about conversions between pointers to disjoint
> +	 address spaces.  */
> +      if (TREE_CODE (from) == POINTER_TYPE
> +	  && TREE_CODE (to) == POINTER_TYPE)
> +	{
> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> +	  addr_space_t as_common;
> +
> +	  if (!addr_space_superset (as_to, as_from, &as_common))
> +	    return false;
> +	}
> +
>   	  if (constp > 0)
>   	    constp &= TYPE_READONLY (to);
>   	}
> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> index 84e6f6694ab..c89df8778b2 100644
> --- a/gcc/doc/extend.texi
> +++ b/gcc/doc/extend.texi
> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>   @section Named Address Spaces
>   @cindex Named Address Spaces
>   
> -As an extension, GNU C supports named address spaces as
> +As an extension, GNU C and GNU C++ support named address spaces as
>   defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>   address spaces in GCC will evolve as the draft technical report
>   changes.  Calling conventions for any target might also change.  At
> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> new file mode 100644
> index 00000000000..c01f8d6054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> +
> +int f (int volatile __seg_fs *a)
> +{
> +  return *a;
> +}
> +
> +int main () {}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> new file mode 100644
> index 00000000000..ebb6316054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> new file mode 100644
> index 00000000000..2e8ee32a885
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-std=gnu++98" }
> +
> +int
> +main ()
> +{
> +	struct foo {int a; char b[2];} structure;
> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> new file mode 100644
> index 00000000000..5b2c0f28078
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/tree.h b/gcc/tree.h
> index 8844471e9a5..b7da4c5141a 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>   
>   /* Encode/decode the named memory support as part of the qualifier.  If more
>      than 8 qualifiers are added, these macros need to be adjusted.  */
> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>   #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>   
>   /* Return all qualifiers except for the address space qualifiers.  */
> 
> 
> 
>
  

Thank you very much for the comments.

On Mon, Oct 10, 2022 at 03:20:13PM -0400, Jason Merrill wrote:
> On 10/9/22 12:12, Paul Iannetta wrote:
> > That's a nice feature! LLVM is using AS<number> to mangle the
> > address-name qualified types but that would have required an update of
> > libiberty's demangler in the binutils as well.
> 
> And they haven't proposed this mangling to
> 
>   https://github.com/itanium-cxx-abi/cxx-abi/
> 
> yet, either.

When looking at clang/lib/AST/{Microsoft,Itamium}Mangle.cpp, the
comments may suggest that they wanted to implement them as extended
qualifiers prefixed by an `U' but that's not what they ended up doing.

> You certainly want some template tests, say
> 
> template <class T>
> int f (T *p) { return *p; }
> __seg_fs int *a;
> int main() { f(a); }
> // test for mangling of f<__seg_fs int>
> 
> -----
> 
> template <class T>
> int f (T __seg_gs *p) { return *p; }
> __seg_fs int *a;
> int main() { f(a); } // error, conflicting address spaces

Indeed, I was getting the first one right by a stroke of luck but not
the second.  I've consequently adapted the part which checks and
computes the unification of cv-qualifiers in the presence of address
spaces.  The idea being that a type parameter T can match any address
spaces but an address-space qualified parameter can't accept more
general address spaces than itself.

> > +/* Return true if between two named address spaces, whether there is a superset
> > +   named address space that encompasses both address spaces.  If there is a
> > +   superset, return which address space is the superset.  */
> > +
> > +bool
> > +addr_space_superset (addr_space_t as1, addr_space_t as2,
> > +		     addr_space_t * common)
> > +{
> > +  if (as1 == as2)
> > +    {
> > +      *common = as1;
> > +      return true;
> > +    }
> > +  else if (targetm.addr_space.subset_p (as1, as2))
> > +    {
> > +      *common = as2;
> > +      return true;
> > +    }
> > +  else if (targetm.addr_space.subset_p (as2, as1))
> > +    {
> > +      *common = as1;
> > +      return true;
> > +    }
> > +  else
> > +    return false;
> 
> So it's not possible for the two spaces to both be subsets of a third?
> 

According to the [N1275, page 38]:
Address spaces may overlap in a nested fashion. For any two address
spaces, either the address spaces must be disjoint, they must be
equivalent, or one must be a subset of the other. [...] There is no
requirement that named address spaces (intrinsic or otherwise) be
subsets of the generic address space.
[N1275]: https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1275.pdf

Hence, two disjoint address spaces can't be subsets of a third, per
the draft.

> 
> New non-bit-fields should be added before the bit-fields.
> 

Done.

> > diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> > index eb53e0ebeb4..06625ad9a4b 100644
> > --- a/gcc/cp/mangle.cc
> > +++ b/gcc/cp/mangle.cc
> > @@ -2509,6 +2509,15 @@ write_CV_qualifiers_for_type (const tree type)
> >        array.  */
> >     cp_cv_quals quals = TYPE_QUALS (type);
> > +  if (DECODE_QUAL_ADDR_SPACE (quals))
> > +    {
> > +      addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals);
> 
> This can be
> 
> if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
> 
> so you don't need to repeat it.

I thought this was c++17 only, but in fact c++17 only broadened the
idiom.  Nice! (It would be even nicer to have this feature in C as
well)
> > diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> > index 763df6f479b..110ceafc98b 100644
> > --- a/gcc/cp/parser.cc
> > +++ b/gcc/cp/parser.cc
> > [...]
> > @@ -23812,6 +23830,13 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
> >   	  break;
> >   	}
> > +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> > +	  token->keyword <= RID_LAST_ADDR_SPACE)
> > +	{
> > +	  cv_qualifier =
> > +	    ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> > +	}
> 
> We usually omit braces around a single statement.
> 
Done.

# ------------------------ >8 ------------------------
Add support for custom address spaces in C++

gcc/
        * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.

gcc/c/
        * c-decl.cc: Remove c_register_addr_space.

gcc/c-family/
        * c-common.cc (c_register_addr_space): Imported from c-decl.cc
        (addr_space_superset): Imported from gcc/c/c-typecheck.cc
        * c-common.h: Remove the FIXME.
        (addr_space_superset): New declaration.

gcc/cp/
        * cp-tree.h (enum cp_decl_spec): Add addr_space support.
        (struct cp_decl_specifier_seq): Likewise.
        * decl.cc (get_type_quals): Likewise.
        (check_tag_decl): Likewise.
        * parser.cc (cp_parser_type_specifier): Likewise.
        (cp_parser_cv_qualifier_seq_opt): Likewise.
        (cp_parser_postfix_expression): Likewise.
        (cp_parser_type_specifier): Likewise.
        (set_and_check_decl_spec_loc): Likewise.
        * typeck.cc (composite_pointer_type): Likewise
        (comp_ptr_ttypes_real): Likewise.
        * pt.cc (check_cv_quals_for_unify): Likewise.
        (unify): Likewise.
        * tree.cc: Remove c_register_addr_space stub.
        * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
          using the extended qualifier notation.

gcc/doc
        * extend.texi (Named Address Spaces): add a mention about C++
          support.

gcc/testsuite/
        * g++.dg/abi/mangle-addr-space1.C: New test.
        * g++.dg/abi/mangle-addr-space2.C: New test.
        * g++.dg/parse/addr-space.C: New test.
        * g++.dg/parse/addr-space1.C: New test.
        * g++.dg/parse/addr-space2.C: New test.
        * g++.dg/parse/template/spec-addr-space.C: New test.

# ------------------------ >8 ------------------------
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index bb0544eeaea..ff1146ecc25 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
   return IDENTIFIER_POINTER (ridpointers [rid]);
 }
 
+/* Return true if between two named address spaces, whether there is a superset
+   named address space that encompasses both address spaces.  If there is a
+   superset, return which address space is the superset.  */
+
+bool
+addr_space_superset (addr_space_t as1, addr_space_t as2,
+		     addr_space_t * common)
+{
+  if (as1 == as2)
+    {
+      *common = as1;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as1, as2))
+    {
+      *common = as2;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as2, as1))
+    {
+      *common = as1;
+      return true;
+    }
+  else
+    return false;
+}
+
 /* Push current bindings for the function name VAR_DECLS.  */
 
 void
@@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
   return build_nonstandard_integer_type (width, unsignedp);
 }
 
+/* Register reserved keyword WORD as qualifier for address space AS.  */
+
+void
+c_register_addr_space (const char *word, addr_space_t as)
+{
+  int rid = RID_FIRST_ADDR_SPACE + as;
+  tree id;
+
+  /* Address space qualifiers are only supported
+     in C with GNU extensions enabled.  */
+  if (c_dialect_objc () || flag_no_asm)
+    return;
+
+  id = get_identifier (word);
+  C_SET_RID_CODE (id, rid);
+  TREE_LANG_FLAG_0 (id) = 1;
+  ridpointers[rid] = id;
+}
+
 /* The C version of the register_builtin_type langhook.  */
 
 void
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 52a85bfb783..d36f9e4975b 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
 
 extern tree (*make_fname_decl) (location_t, tree, int);
 
-/* In c-decl.cc and cp/tree.cc.  FIXME.  */
-extern void c_register_addr_space (const char *str, addr_space_t as);
-
 /* In c-common.cc.  */
 extern bool in_late_binary_op;
 extern const char *c_addr_space_name (addr_space_t as);
+extern const char *c_addr_space_name (addr_space_t as);
+extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
 extern tree identifier_global_value (tree);
 extern tree identifier_global_tag (tree);
 extern bool names_builtin_p (const char *);
@@ -952,6 +951,7 @@ extern void c_common_finish (void);
 extern void c_common_parse_file (void);
 extern FILE *get_dump_info (int, dump_flags_t *);
 extern alias_set_type c_common_get_alias_set (tree);
+extern void c_register_addr_space (const char *, addr_space_t);
 extern void c_register_builtin_type (tree, const char*);
 extern bool c_promoting_integer_type_p (const_tree);
 extern bool self_promoting_args_p (const_tree);
diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index c701f07befe..e1bb4f1cf37 100644
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
   ext_block = NULL;
 }
 
-/* Register reserved keyword WORD as qualifier for address space AS.  */
-
-void
-c_register_addr_space (const char *word, addr_space_t as)
-{
-  int rid = RID_FIRST_ADDR_SPACE + as;
-  tree id;
-
-  /* Address space qualifiers are only supported
-     in C with GNU extensions enabled.  */
-  if (c_dialect_objc () || flag_no_asm)
-    return;
-
-  id = get_identifier (word);
-  C_SET_RID_CODE (id, rid);
-  C_IS_RESERVED_WORD (id) = 1;
-  ridpointers [rid] = id;
-}
-
 /* Return identifier to look up for omp declare reduction.  */
 
 tree
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index b271af9bedb..c4b01368534 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
   return type;
 }
 
-/* Return true if between two named address spaces, whether there is a superset
-   named address space that encompasses both address spaces.  If there is a
-   superset, return which address space is the superset.  */
-
-static bool
-addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
-{
-  if (as1 == as2)
-    {
-      *common = as1;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as1, as2))
-    {
-      *common = as2;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as2, as1))
-    {
-      *common = as1;
-      return true;
-    }
-  else
-    return false;
-}
-
 /* Return a variant of TYPE which has all the type qualifiers of LIKE
    as well as those of TYPE.  */
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 72f4398a8f9..82a6d72f5df 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6206,6 +6206,7 @@ enum cp_decl_spec {
   ds_const,
   ds_volatile,
   ds_restrict,
+  ds_addr_space,
   ds_inline,
   ds_virtual,
   ds_explicit,
@@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
   cp_storage_class storage_class;
   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
   int int_n_idx;
+  /* The address space that the declaration belongs to.  */
+  addr_space_t address_space;
   /* True iff TYPE_SPEC defines a class or enum.  */
   BOOL_BITFIELD type_definition_p : 1;
   /* True iff multiple types were (erroneously) specified for this
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 9f78c500a15..16cc1917085 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
     type_quals |= TYPE_QUAL_VOLATILE;
   if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
     type_quals |= TYPE_QUAL_RESTRICT;
+  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
 
   return type_quals;
 }
@@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
 	error_at (declspecs->locations[ds_restrict],
 		  "%<__restrict%> can only be specified for objects and "
 		  "functions");
+      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+	error_at (declspecs->locations[ds_addr_space],
+		  "address space can only be specified for objects and "
+		  "functions");
       else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
 	error_at (declspecs->locations[ds_thread],
 		  "%<__thread%> can only be specified for objects "
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index eb53e0ebeb4..8ea6b7c903e 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
      array.  */
   cp_cv_quals quals = TYPE_QUALS (type);
 
+  if (addr_space_t as DECODE_QUAL_ADDR_SPACE (quals))
+    {
+      const char *as_name = c_addr_space_name (as);
+      write_char ('U');
+      write_unsigned_number (strlen (as_name));
+      write_string (as_name);
+      ++num_qualifiers;
+    }
   if (quals & TYPE_QUAL_RESTRICT)
     {
       write_char ('r');
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 763df6f479b..f0169d83ab0 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 		    postfix_expression = error_mark_node;
 		    break;
 		  }
+		if (type != error_mark_node
+		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
+		    && current_function_decl)
+		  {
+		    error
+		      ("compound literal qualified by address-space qualifier");
+		    type = error_mark_node;
+		  }
 		/* Form the representation of the compound-literal.  */
 		postfix_expression
 		  = finish_compound_literal (type, initializer,
@@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
       break;
     }
 
+
+  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
+    {
+      ds = ds_addr_space;
+      if (is_cv_qualifier)
+	*is_cv_qualifier = true;
+    }
+
+
   /* Handle simple keywords.  */
   if (ds != ds_last)
     {
@@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
    GNU Extension:
 
    cv-qualifier:
+     address-space-qualifier
      __restrict__
 
    Returns a bitmask representing the cv-qualifiers.  */
@@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
 	  break;
 	}
 
+      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
+	  token->keyword <= RID_LAST_ADDR_SPACE)
+	cv_qualifier =
+	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
+
       if (!cv_qualifier)
 	break;
 
@@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
       decl_specs->locations[ds] = location;
       if (ds == ds_thread)
 	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
+      else if (ds == ds_addr_space)
+	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
     }
   else
     {
@@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
 	      error_at (&richloc, "duplicate %qD", token->u.value);
 	    }
 	}
+      else if (ds == ds_addr_space)
+	{
+	  addr_space_t as1 = decl_specs->address_space;
+	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
+
+	  gcc_rich_location richloc (location);
+	  richloc.add_fixit_remove ();
+	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
+	      && as1 != as2)
+	    error_at (&richloc,
+		      "conflicting named address spaces (%s vs %s)",
+		      c_addr_space_name (as1), c_addr_space_name (as2));
+	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
+	    error_at (&richloc,
+		      "duplicate named address space %s",
+		      c_addr_space_name (as1));
+
+	  decl_specs->address_space = as2;
+	}
       else
 	{
 	  static const char *const decl_spec_names[] = {
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index bef31416fb7..5bb5d657155 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
 static int
 check_cv_quals_for_unify (int strict, tree arg, tree parm)
 {
-  int arg_quals = cp_type_quals (arg);
-  int parm_quals = cp_type_quals (parm);
+  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
+  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
+
+  /*  Try to unify ARG's address space into PARM's address space.
+      If PARM does not have any address space qualifiers (ie., as_parm is 0),
+      there are no constraints on address spaces for this type.  */
+  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
+  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
+  addr_space_t as_common;
+  addr_space_superset (as_arg, as_parm, &as_common);
+
+  if (!(as_parm == as_common || as_parm == 0))
+    return 0;
 
   if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
       && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
@@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
 					 arg, parm))
 	    return unify_cv_qual_mismatch (explain_p, parm, arg);
 
+	  int arg_cv_quals = cp_type_quals (arg);
+	  int parm_cv_quals = cp_type_quals (parm);
+
+	  /* If PARM does not contain any address spaces constraints it can
+	     fully match the address space of ARG.  However, if PARM contains an
+	     address space constraints, it becomes the upper bound.  That is,
+	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
+	     ended up here, it means that `check_cv_quals_for_unify' succeeded
+	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
+	     AS_PARM.  */
+	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
+	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
+	  addr_space_t as_common = !as_parm ? as_arg : as_parm;
+
 	  /* Consider the case where ARG is `const volatile int' and
 	     PARM is `const T'.  Then, T should be `volatile int'.  */
-	  arg = cp_build_qualified_type_real
-	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
+	  int unified_cv =
+	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
+	    | ENCODE_QUAL_ADDR_SPACE (as_common);
+	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
 	  if (arg == error_mark_node)
 	    return unify_invalid (explain_p);
 
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 3b37567cbd7..5e14ac837fc 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
     DECL_CHAIN (t) = NULL_TREE;
 }
 
-/* Stub for c-common.  Please keep in sync with c-decl.cc.
-   FIXME: If address space support is target specific, then this
-   should be a C target hook.  But currently this is not possible,
-   because this function is called via REGISTER_TARGET_PRAGMAS.  */
-void
-c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
-{
-}
-
 /* Return the number of operands in T that we care about for things like
    mangling.  */
 
diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index ceb80d9744f..5d48920e687 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
 	  else
 	    return error_mark_node;
         }
+      /* If possible merge the address space into the superset of the address
+	  spaces of t1 and t2, or raise an error. */
+      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
+      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
+      addr_space_t as_common;
+
+      /* If the two named address spaces are different, determine the common
+	 superset address space.  If there isn't one, raise an error.  */
+      if (!addr_space_superset (as_t1, as_t2, &as_common))
+	{
+	  as_common = as_t1;
+	  error_at (location,
+		    "%qT and %qT are in disjoint named address spaces",
+		    t1, t2);
+	}
       result_type
 	= cp_build_qualified_type (void_type_node,
-				   (cp_type_quals (TREE_TYPE (t1))
-				    | cp_type_quals (TREE_TYPE (t2))));
+				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
+				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
+				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
       result_type = build_pointer_type (result_type);
       /* Merge the attributes.  */
       attributes = (*targetm.merge_type_attributes) (t1, t2);
@@ -10805,6 +10821,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
 	      to_more_cv_qualified = true;
 	    }
 
+      /* Warn about conversions between pointers to disjoint
+	 address spaces.  */
+      if (TREE_CODE (from) == POINTER_TYPE
+	  && TREE_CODE (to) == POINTER_TYPE)
+	{
+	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
+	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
+	  addr_space_t as_common;
+
+	  if (!addr_space_superset (as_to, as_from, &as_common))
+	    return false;
+	}
+
 	  if (constp > 0)
 	    constp &= TYPE_READONLY (to);
 	}
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index ac3db88566d..1e0d436c02c 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
 @section Named Address Spaces
 @cindex Named Address Spaces
 
-As an extension, GNU C supports named address spaces as
+As an extension, GNU C and GNU C++ support named address spaces as
 defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
 address spaces in GCC will evolve as the draft technical report
 changes.  Calling conventions for any target might also change.  At
diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
new file mode 100644
index 00000000000..c01f8d6054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do run { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-fabi-version=8 -Wabi -save-temps" }
+// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
+
+int f (int volatile __seg_fs *a)
+{
+  return *a;
+}
+
+int main () {}
diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
new file mode 100644
index 00000000000..862bbbdcdf2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
@@ -0,0 +1,9 @@
+// { dg-do run { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-fabi-version=8 -Wabi -save-temps" }
+// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
+
+template <class T>
+int f (T *p) { return *p; }
+int g (__seg_fs int *p) { return *p; }
+__seg_fs int *a;
+int main() { f(a); }
diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
new file mode 100644
index 00000000000..ebb6316054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
new file mode 100644
index 00000000000..2e8ee32a885
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-std=gnu++98" }
+
+int
+main ()
+{
+	struct foo {int a; char b[2];} structure;
+	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
new file mode 100644
index 00000000000..5b2c0f28078
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
new file mode 100644
index 00000000000..ae9f4de0e1f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
@@ -0,0 +1,8 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+template <class T>
+int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
+				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
+__seg_fs int *a;
+int main() { f(a); } // { dg-error "no matching" }
+// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
diff --git a/gcc/tree.h b/gcc/tree.h
index 8844471e9a5..b7da4c5141a 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
 
 /* Encode/decode the named memory support as part of the qualifier.  If more
    than 8 qualifiers are added, these macros need to be adjusted.  */
-#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
+#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
 #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
 
 /* Return all qualifiers except for the address space qualifiers.  */
  

On 10/11/22 18:03, Paul Iannetta wrote:
> Thank you very much for the comments.
> 
> On Mon, Oct 10, 2022 at 03:20:13PM -0400, Jason Merrill wrote:
>> On 10/9/22 12:12, Paul Iannetta wrote:
>>> That's a nice feature! LLVM is using AS<number> to mangle the
>>> address-name qualified types but that would have required an update of
>>> libiberty's demangler in the binutils as well.
>>
>> And they haven't proposed this mangling to
>>
>>    https://github.com/itanium-cxx-abi/cxx-abi/
>>
>> yet, either.
> 
> When looking at clang/lib/AST/{Microsoft,Itamium}Mangle.cpp, the
> comments may suggest that they wanted to implement them as extended
> qualifiers prefixed by an `U' but that's not what they ended up doing.
> 
>> You certainly want some template tests, say
>>
>> template <class T>
>> int f (T *p) { return *p; }
>> __seg_fs int *a;
>> int main() { f(a); }
>> // test for mangling of f<__seg_fs int>
>>
>> -----
>>
>> template <class T>
>> int f (T __seg_gs *p) { return *p; }
>> __seg_fs int *a;
>> int main() { f(a); } // error, conflicting address spaces
> 
> Indeed, I was getting the first one right by a stroke of luck but not
> the second.  I've consequently adapted the part which checks and
> computes the unification of cv-qualifiers in the presence of address
> spaces.  The idea being that a type parameter T can match any address
> spaces but an address-space qualified parameter can't accept more
> general address spaces than itself.
> 
>>> +/* Return true if between two named address spaces, whether there is a superset
>>> +   named address space that encompasses both address spaces.  If there is a
>>> +   superset, return which address space is the superset.  */
>>> +
>>> +bool
>>> +addr_space_superset (addr_space_t as1, addr_space_t as2,
>>> +		     addr_space_t * common)
>>> +{
>>> +  if (as1 == as2)
>>> +    {
>>> +      *common = as1;
>>> +      return true;
>>> +    }
>>> +  else if (targetm.addr_space.subset_p (as1, as2))
>>> +    {
>>> +      *common = as2;
>>> +      return true;
>>> +    }
>>> +  else if (targetm.addr_space.subset_p (as2, as1))
>>> +    {
>>> +      *common = as1;
>>> +      return true;
>>> +    }
>>> +  else
>>> +    return false;
>>
>> So it's not possible for the two spaces to both be subsets of a third?
>>
> 
> According to the [N1275, page 38]:
> Address spaces may overlap in a nested fashion. For any two address
> spaces, either the address spaces must be disjoint, they must be
> equivalent, or one must be a subset of the other. [...] There is no
> requirement that named address spaces (intrinsic or otherwise) be
> subsets of the generic address space.
> [N1275]: https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1275.pdf
> 
> Hence, two disjoint address spaces can't be subsets of a third, per
> the draft.
> 
>>
>> New non-bit-fields should be added before the bit-fields.
>>
> 
> Done.
> 
>>> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
>>> index eb53e0ebeb4..06625ad9a4b 100644
>>> --- a/gcc/cp/mangle.cc
>>> +++ b/gcc/cp/mangle.cc
>>> @@ -2509,6 +2509,15 @@ write_CV_qualifiers_for_type (const tree type)
>>>         array.  */
>>>      cp_cv_quals quals = TYPE_QUALS (type);
>>> +  if (DECODE_QUAL_ADDR_SPACE (quals))
>>> +    {
>>> +      addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals);
>>
>> This can be
>>
>> if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
>>
>> so you don't need to repeat it.
> 
> I thought this was c++17 only, but in fact c++17 only broadened the
> idiom.  Nice! (It would be even nicer to have this feature in C as
> well)
>>> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
>>> index 763df6f479b..110ceafc98b 100644
>>> --- a/gcc/cp/parser.cc
>>> +++ b/gcc/cp/parser.cc
>>> [...]
>>> @@ -23812,6 +23830,13 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>>>    	  break;
>>>    	}
>>> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
>>> +	  token->keyword <= RID_LAST_ADDR_SPACE)
>>> +	{
>>> +	  cv_qualifier =
>>> +	    ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
>>> +	}
>>
>> We usually omit braces around a single statement.
>>
> Done.
> 
> # ------------------------ >8 ------------------------
> Add support for custom address spaces in C++
> 
> gcc/
>          * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> 
> gcc/c/
>          * c-decl.cc: Remove c_register_addr_space.
> 
> gcc/c-family/
>          * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>          (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>          * c-common.h: Remove the FIXME.
>          (addr_space_superset): New declaration.
> 
> gcc/cp/
>          * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>          (struct cp_decl_specifier_seq): Likewise.
>          * decl.cc (get_type_quals): Likewise.
>          (check_tag_decl): Likewise.
>          * parser.cc (cp_parser_type_specifier): Likewise.
>          (cp_parser_cv_qualifier_seq_opt): Likewise.
>          (cp_parser_postfix_expression): Likewise.
>          (cp_parser_type_specifier): Likewise.
>          (set_and_check_decl_spec_loc): Likewise.
>          * typeck.cc (composite_pointer_type): Likewise
>          (comp_ptr_ttypes_real): Likewise.
>          * pt.cc (check_cv_quals_for_unify): Likewise.
>          (unify): Likewise.
>          * tree.cc: Remove c_register_addr_space stub.
>          * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>            using the extended qualifier notation.
> 
> gcc/doc
>          * extend.texi (Named Address Spaces): add a mention about C++
>            support.
> 
> gcc/testsuite/
>          * g++.dg/abi/mangle-addr-space1.C: New test.
>          * g++.dg/abi/mangle-addr-space2.C: New test.
>          * g++.dg/parse/addr-space.C: New test.
>          * g++.dg/parse/addr-space1.C: New test.
>          * g++.dg/parse/addr-space2.C: New test.
>          * g++.dg/parse/template/spec-addr-space.C: New test.
> 
> # ------------------------ >8 ------------------------
> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> index bb0544eeaea..ff1146ecc25 100644
> --- a/gcc/c-family/c-common.cc
> +++ b/gcc/c-family/c-common.cc
> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>     return IDENTIFIER_POINTER (ridpointers [rid]);
>   }
>   
> +/* Return true if between two named address spaces, whether there is a superset
> +   named address space that encompasses both address spaces.  If there is a
> +   superset, return which address space is the superset.  */
> +
> +bool
> +addr_space_superset (addr_space_t as1, addr_space_t as2,
> +		     addr_space_t * common)
> +{
> +  if (as1 == as2)
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as1, as2))
> +    {
> +      *common = as2;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as2, as1))
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else
> +    return false;
> +}
> +
>   /* Push current bindings for the function name VAR_DECLS.  */
>   
>   void
> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>     return build_nonstandard_integer_type (width, unsignedp);
>   }
>   
> +/* Register reserved keyword WORD as qualifier for address space AS.  */
> +
> +void
> +c_register_addr_space (const char *word, addr_space_t as)
> +{
> +  int rid = RID_FIRST_ADDR_SPACE + as;
> +  tree id;
> +
> +  /* Address space qualifiers are only supported
> +     in C with GNU extensions enabled.  */
> +  if (c_dialect_objc () || flag_no_asm)
> +    return;
> +
> +  id = get_identifier (word);
> +  C_SET_RID_CODE (id, rid);
> +  TREE_LANG_FLAG_0 (id) = 1;
> +  ridpointers[rid] = id;
> +}
> +
>   /* The C version of the register_builtin_type langhook.  */
>   
>   void
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 52a85bfb783..d36f9e4975b 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>   
>   extern tree (*make_fname_decl) (location_t, tree, int);
>   
> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> -extern void c_register_addr_space (const char *str, addr_space_t as);
> -
>   /* In c-common.cc.  */
>   extern bool in_late_binary_op;
>   extern const char *c_addr_space_name (addr_space_t as);
> +extern const char *c_addr_space_name (addr_space_t as);
> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>   extern tree identifier_global_value (tree);
>   extern tree identifier_global_tag (tree);
>   extern bool names_builtin_p (const char *);
> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>   extern void c_common_parse_file (void);
>   extern FILE *get_dump_info (int, dump_flags_t *);
>   extern alias_set_type c_common_get_alias_set (tree);
> +extern void c_register_addr_space (const char *, addr_space_t);
>   extern void c_register_builtin_type (tree, const char*);
>   extern bool c_promoting_integer_type_p (const_tree);
>   extern bool self_promoting_args_p (const_tree);
> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> index c701f07befe..e1bb4f1cf37 100644
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>     ext_block = NULL;
>   }
>   
> -/* Register reserved keyword WORD as qualifier for address space AS.  */
> -
> -void
> -c_register_addr_space (const char *word, addr_space_t as)
> -{
> -  int rid = RID_FIRST_ADDR_SPACE + as;
> -  tree id;
> -
> -  /* Address space qualifiers are only supported
> -     in C with GNU extensions enabled.  */
> -  if (c_dialect_objc () || flag_no_asm)
> -    return;
> -
> -  id = get_identifier (word);
> -  C_SET_RID_CODE (id, rid);
> -  C_IS_RESERVED_WORD (id) = 1;
> -  ridpointers [rid] = id;
> -}
> -
>   /* Return identifier to look up for omp declare reduction.  */
>   
>   tree
> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> index b271af9bedb..c4b01368534 100644
> --- a/gcc/c/c-typeck.cc
> +++ b/gcc/c/c-typeck.cc
> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>     return type;
>   }
>   
> -/* Return true if between two named address spaces, whether there is a superset
> -   named address space that encompasses both address spaces.  If there is a
> -   superset, return which address space is the superset.  */
> -
> -static bool
> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> -{
> -  if (as1 == as2)
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as1, as2))
> -    {
> -      *common = as2;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as2, as1))
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else
> -    return false;
> -}
> -
>   /* Return a variant of TYPE which has all the type qualifiers of LIKE
>      as well as those of TYPE.  */
>   
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 72f4398a8f9..82a6d72f5df 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>     ds_const,
>     ds_volatile,
>     ds_restrict,
> +  ds_addr_space,
>     ds_inline,
>     ds_virtual,
>     ds_explicit,
> @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
>     cp_storage_class storage_class;
>     /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>     int int_n_idx;
> +  /* The address space that the declaration belongs to.  */
> +  addr_space_t address_space;
>     /* True iff TYPE_SPEC defines a class or enum.  */
>     BOOL_BITFIELD type_definition_p : 1;
>     /* True iff multiple types were (erroneously) specified for this
> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> index 9f78c500a15..16cc1917085 100644
> --- a/gcc/cp/decl.cc
> +++ b/gcc/cp/decl.cc
> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>       type_quals |= TYPE_QUAL_VOLATILE;
>     if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>       type_quals |= TYPE_QUAL_RESTRICT;
> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>   
>     return type_quals;
>   }
> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>   	error_at (declspecs->locations[ds_restrict],
>   		  "%<__restrict%> can only be specified for objects and "
>   		  "functions");
> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +	error_at (declspecs->locations[ds_addr_space],
> +		  "address space can only be specified for objects and "
> +		  "functions");
>         else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>   	error_at (declspecs->locations[ds_thread],
>   		  "%<__thread%> can only be specified for objects "
> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> index eb53e0ebeb4..8ea6b7c903e 100644
> --- a/gcc/cp/mangle.cc
> +++ b/gcc/cp/mangle.cc
> @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
>        array.  */
>     cp_cv_quals quals = TYPE_QUALS (type);
>   
> +  if (addr_space_t as DECODE_QUAL_ADDR_SPACE (quals))

Let's still include the =, rather than rely on the parens from the macro.

> +    {
> +      const char *as_name = c_addr_space_name (as);
> +      write_char ('U');
> +      write_unsigned_number (strlen (as_name));
> +      write_string (as_name);
> +      ++num_qualifiers;
> +    }
>     if (quals & TYPE_QUAL_RESTRICT)
>       {
>         write_char ('r');
> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> index 763df6f479b..f0169d83ab0 100644
> --- a/gcc/cp/parser.cc
> +++ b/gcc/cp/parser.cc
> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>   		    postfix_expression = error_mark_node;
>   		    break;
>   		  }
> +		if (type != error_mark_node
> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> +		    && current_function_decl)
> +		  {
> +		    error
> +		      ("compound literal qualified by address-space qualifier");
> +		    type = error_mark_node;
> +		  }

It surprises that this is the only place we complain about an object 
with an address-space qualifier.  Shouldn't we also complain about e.g. 
automatic variables/parameters or non-static data members with 
address-space qualified type?

>   		/* Form the representation of the compound-literal.  */
>   		postfix_expression
>   		  = finish_compound_literal (type, initializer,
> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>         break;
>       }
>   
> +
> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> +    {
> +      ds = ds_addr_space;
> +      if (is_cv_qualifier)
> +	*is_cv_qualifier = true;
> +    }
> +
> +
>     /* Handle simple keywords.  */
>     if (ds != ds_last)
>       {
> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>      GNU Extension:
>   
>      cv-qualifier:
> +     address-space-qualifier
>        __restrict__
>   
>      Returns a bitmask representing the cv-qualifiers.  */
> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>   	  break;
>   	}
>   
> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> +	  token->keyword <= RID_LAST_ADDR_SPACE)
> +	cv_qualifier =
> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> +
>         if (!cv_qualifier)
>   	break;
>   
> @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>         decl_specs->locations[ds] = location;
>         if (ds == ds_thread)
>   	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> +      else if (ds == ds_addr_space)
> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>       }
>     else
>       {
> @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>   	      error_at (&richloc, "duplicate %qD", token->u.value);
>   	    }
>   	}
> +      else if (ds == ds_addr_space)
> +	{
> +	  addr_space_t as1 = decl_specs->address_space;
> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> +
> +	  gcc_rich_location richloc (location);
> +	  richloc.add_fixit_remove ();
> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> +	      && as1 != as2)
> +	    error_at (&richloc,
> +		      "conflicting named address spaces (%s vs %s)",
> +		      c_addr_space_name (as1), c_addr_space_name (as2));
> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> +	    error_at (&richloc,
> +		      "duplicate named address space %s",
> +		      c_addr_space_name (as1));
> +
> +	  decl_specs->address_space = as2;
> +	}
>         else
>   	{
>   	  static const char *const decl_spec_names[] = {
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index bef31416fb7..5bb5d657155 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
>   static int
>   check_cv_quals_for_unify (int strict, tree arg, tree parm)
>   {
> -  int arg_quals = cp_type_quals (arg);
> -  int parm_quals = cp_type_quals (parm);
> +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
> +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
> +
> +  /*  Try to unify ARG's address space into PARM's address space.
> +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
> +      there are no constraints on address spaces for this type.  */
> +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
> +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
> +  addr_space_t as_common;
> +  addr_space_superset (as_arg, as_parm, &as_common);
> +
> +  if (!(as_parm == as_common || as_parm == 0))
> +    return 0;
>   
>     if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
>         && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
> @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
>   					 arg, parm))
>   	    return unify_cv_qual_mismatch (explain_p, parm, arg);
>   
> +	  int arg_cv_quals = cp_type_quals (arg);
> +	  int parm_cv_quals = cp_type_quals (parm);
> +
> +	  /* If PARM does not contain any address spaces constraints it can
> +	     fully match the address space of ARG.  However, if PARM contains an
> +	     address space constraints, it becomes the upper bound.  That is,
> +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
> +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
> +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
> +	     AS_PARM.  */
> +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
> +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
> +	  addr_space_t as_common = !as_parm ? as_arg : as_parm;
> +
>   	  /* Consider the case where ARG is `const volatile int' and
>   	     PARM is `const T'.  Then, T should be `volatile int'.  */
> -	  arg = cp_build_qualified_type_real
> -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
> +	  int unified_cv =
> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
>   	  if (arg == error_mark_node)
>   	    return unify_invalid (explain_p);
>   
> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> index 3b37567cbd7..5e14ac837fc 100644
> --- a/gcc/cp/tree.cc
> +++ b/gcc/cp/tree.cc
> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>       DECL_CHAIN (t) = NULL_TREE;
>   }
>   
> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> -   FIXME: If address space support is target specific, then this
> -   should be a C target hook.  But currently this is not possible,
> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> -void
> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> -{
> -}
> -
>   /* Return the number of operands in T that we care about for things like
>      mangling.  */
>   
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index ceb80d9744f..5d48920e687 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>   	  else
>   	    return error_mark_node;
>           }
> +      /* If possible merge the address space into the superset of the address
> +	  spaces of t1 and t2, or raise an error. */
> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> +      addr_space_t as_common;
> +
> +      /* If the two named address spaces are different, determine the common
> +	 superset address space.  If there isn't one, raise an error.  */
> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> +	{
> +	  as_common = as_t1;
> +	  error_at (location,
> +		    "%qT and %qT are in disjoint named address spaces",
> +		    t1, t2);
> +	}
>         result_type
>   	= cp_build_qualified_type (void_type_node,
> -				   (cp_type_quals (TREE_TYPE (t1))
> -				    | cp_type_quals (TREE_TYPE (t2))));
> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>         result_type = build_pointer_type (result_type);
>         /* Merge the attributes.  */
>         attributes = (*targetm.merge_type_attributes) (t1, t2);
> @@ -10805,6 +10821,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>   	      to_more_cv_qualified = true;
>   	    }
>   
> +      /* Warn about conversions between pointers to disjoint
> +	 address spaces.  */
> +      if (TREE_CODE (from) == POINTER_TYPE
> +	  && TREE_CODE (to) == POINTER_TYPE)
> +	{
> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> +	  addr_space_t as_common;
> +
> +	  if (!addr_space_superset (as_to, as_from, &as_common))
> +	    return false;
> +	}
> +
>   	  if (constp > 0)
>   	    constp &= TYPE_READONLY (to);
>   	}
> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> index ac3db88566d..1e0d436c02c 100644
> --- a/gcc/doc/extend.texi
> +++ b/gcc/doc/extend.texi
> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>   @section Named Address Spaces
>   @cindex Named Address Spaces
>   
> -As an extension, GNU C supports named address spaces as
> +As an extension, GNU C and GNU C++ support named address spaces as
>   defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>   address spaces in GCC will evolve as the draft technical report
>   changes.  Calling conventions for any target might also change.  At
> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> new file mode 100644
> index 00000000000..c01f8d6054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> +
> +int f (int volatile __seg_fs *a)
> +{
> +  return *a;
> +}
> +
> +int main () {}
> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> new file mode 100644
> index 00000000000..862bbbdcdf2
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> @@ -0,0 +1,9 @@
> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
> +
> +template <class T>
> +int f (T *p) { return *p; }
> +int g (__seg_fs int *p) { return *p; }
> +__seg_fs int *a;
> +int main() { f(a); }
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> new file mode 100644
> index 00000000000..ebb6316054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> new file mode 100644
> index 00000000000..2e8ee32a885
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-std=gnu++98" }
> +
> +int
> +main ()
> +{
> +	struct foo {int a; char b[2];} structure;
> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> new file mode 100644
> index 00000000000..5b2c0f28078
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> new file mode 100644
> index 00000000000..ae9f4de0e1f
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> @@ -0,0 +1,8 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +template <class T>
> +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
> +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
> +__seg_fs int *a;
> +int main() { f(a); } // { dg-error "no matching" }
> +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
> diff --git a/gcc/tree.h b/gcc/tree.h
> index 8844471e9a5..b7da4c5141a 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>   
>   /* Encode/decode the named memory support as part of the qualifier.  If more
>      than 8 qualifiers are added, these macros need to be adjusted.  */
> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>   #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>   
>   /* Return all qualifiers except for the address space qualifiers.  */
> 
> 
> 
>
  

On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
> 
> It surprises that this is the only place we complain about an object with an
> address-space qualifier.  Shouldn't we also complain about e.g. automatic
> variables/parameters or non-static data members with address-space qualified
> type?
> 

Indeed, I was missing quite a few things here.  Thanks.
I used the draft as basis this time and imported from the C
implementation the relevant parts.  This time, the errors get properly
emitted when an address space is unduly specified; and comparisons,
assignments and comparisons are taken care of.

There are quite a few things I would like to clarify concerning some
implementation details.
  - A variable with automatic storage (which is neither a pointer nor
    a reference) cannot be qualified with an address space.  I detect
    this by the combination of `sc_none' and `! toplevel_bindings_p ()',
    but I've also seen the use of `at_function_scope' at other places.
    And I'm unsure which one is appropriate here.
    This detection happens at the very end of grokdeclarator because I
    need to know that the type is a pointer, which is not know until
    very late in the function.
  - I'm having some trouble deciding whether I include those three
    stub programs as tests, they all compile fine and clang accepts
    them as well.

Ex1:
```
int __seg_fs * fs1;
int __seg_gs * gs1;

template<typename T> struct strip;
template<typename T> struct strip<__seg_fs T *> { typedef T type; };
template<typename T> struct strip<__seg_gs T *> { typedef T type; };

int
main ()
{
    *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
    return 0;
}
```

Ex2:
```
int __seg_fs * fs1;
int __seg_fs * fs2;

template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }

int
main ()
{
    f (fs1, gs1);
    f (gs1, fs1);
    return 0;
}
```

Ex3:
```
int __seg_fs * fs1;
int __seg_gs * gs1;

template<typename T, typename U>
auto f (T __seg_fs * a, U __seg_gs * b)
{
    return *(T *) a == *(U *) b;
}

int
main ()
{
    return f (fs1, gs1);
}
```


Add support for custom address spaces in C++

gcc/
        * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.

gcc/c/
        * c-decl.cc: Remove c_register_addr_space.

gcc/c-family/
        * c-common.cc (c_register_addr_space): Imported from c-decl.cc
        (addr_space_superset): Imported from gcc/c/c-typecheck.cc
        * c-common.h: Remove the FIXME.
        (addr_space_superset): New declaration.

gcc/cp/
        * cp-tree.h (enum cp_decl_spec): Add addr_space support.
        (struct cp_decl_specifier_seq): Likewise.
        * decl.cc (get_type_quals): Likewise.
        (check_tag_decl): Likewise.
	(grokdeclarator): Likewise.
        * parser.cc (cp_parser_type_specifier): Likewise.
        (cp_parser_cv_qualifier_seq_opt): Likewise.
        (cp_parser_postfix_expression): Likewise.
        (cp_parser_type_specifier): Likewise.
        (set_and_check_decl_spec_loc): Likewise.
        * typeck.cc (composite_pointer_type): Likewise
        (comp_ptr_ttypes_real): Likewise.
	(same_type_ignoring_top_level_qualifiers_p): Likewise.
        * pt.cc (check_cv_quals_for_unify): Likewise.
        (unify): Likewise.
        * tree.cc: Remove c_register_addr_space stub.
        * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
          using the extended qualifier notation.

gcc/doc
        * extend.texi (Named Address Spaces): add a mention about C++
          support.

gcc/testsuite/
        * g++.dg/abi/mangle-addr-space1.C: New test.
        * g++.dg/abi/mangle-addr-space2.C: New test.
        * g++.dg/parse/addr-space.C: New test.
        * g++.dg/parse/addr-space1.C: New test.
        * g++.dg/parse/addr-space2.C: New test.
        * g++.dg/parse/template/spec-addr-space.C: New test.
        * g++.dg/ext/addr-space-decl.C: New test.
        * g++.dg/ext/addr-space-ref.C: New test.
        * g++.dg/ext/addr-space-ops.C: New test.

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# Date:      Sun Oct 9 16:02:22 2022 +0200
#
# On branch releases/gcc-12
# Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
#   (use "git push" to publish your local commits)
#
# Changes to be committed:
#	modified:   gcc/c-family/c-common.cc
#	modified:   gcc/c-family/c-common.h
#	modified:   gcc/c/c-decl.cc
#	modified:   gcc/c/c-typeck.cc
#	modified:   gcc/cp/cp-tree.h
#	modified:   gcc/cp/decl.cc
#	modified:   gcc/cp/mangle.cc
#	modified:   gcc/cp/parser.cc
#	modified:   gcc/cp/pt.cc
#	modified:   gcc/cp/tree.cc
#	modified:   gcc/cp/typeck.cc
#	modified:   gcc/doc/extend.texi
#	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
#	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
#	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
#	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
#	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
#	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
#	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
#	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
#	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
#	modified:   gcc/tree.h
#
# Untracked files:
#	Makefile
#	addr-space-decl.C
#	addr-space-decl.s
#	addr-space-ops.C
#	addr-space-ref.C
#	addr-space-template.C
#	addr-space-template.s
#	addr-space-template2.C
#	addr-space-template2.C.006t.gimple
#	addr-space-template2.s
#	addr-space-traits.C
#	addr-space4.C
#	addr-space4.C.006t.gimple
#	addr-space4.s
#	build-x86_64-pc-linux-gnu/
#	compare
#	host-x86_64-pc-linux-gnu/
#	mangle-addr-space1.s
#	prev-x86_64-pc-linux-gnu/
#	rename
#	stage1-x86_64-pc-linux-gnu/
#	stage_current
#	stage_final
#	stage_last
#	x86_64-pc-linux-gnu/
#
# ------------------------ >8 ------------------------
# Do not modify or remove the line above.
# Everything below it will be ignored.
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index bb0544eeaea..ff1146ecc25 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
   return IDENTIFIER_POINTER (ridpointers [rid]);
 }
 
+/* Return true if between two named address spaces, whether there is a superset
+   named address space that encompasses both address spaces.  If there is a
+   superset, return which address space is the superset.  */
+
+bool
+addr_space_superset (addr_space_t as1, addr_space_t as2,
+		     addr_space_t * common)
+{
+  if (as1 == as2)
+    {
+      *common = as1;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as1, as2))
+    {
+      *common = as2;
+      return true;
+    }
+  else if (targetm.addr_space.subset_p (as2, as1))
+    {
+      *common = as1;
+      return true;
+    }
+  else
+    return false;
+}
+
 /* Push current bindings for the function name VAR_DECLS.  */
 
 void
@@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
   return build_nonstandard_integer_type (width, unsignedp);
 }
 
+/* Register reserved keyword WORD as qualifier for address space AS.  */
+
+void
+c_register_addr_space (const char *word, addr_space_t as)
+{
+  int rid = RID_FIRST_ADDR_SPACE + as;
+  tree id;
+
+  /* Address space qualifiers are only supported
+     in C with GNU extensions enabled.  */
+  if (c_dialect_objc () || flag_no_asm)
+    return;
+
+  id = get_identifier (word);
+  C_SET_RID_CODE (id, rid);
+  TREE_LANG_FLAG_0 (id) = 1;
+  ridpointers[rid] = id;
+}
+
 /* The C version of the register_builtin_type langhook.  */
 
 void
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 52a85bfb783..d36f9e4975b 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
 
 extern tree (*make_fname_decl) (location_t, tree, int);
 
-/* In c-decl.cc and cp/tree.cc.  FIXME.  */
-extern void c_register_addr_space (const char *str, addr_space_t as);
-
 /* In c-common.cc.  */
 extern bool in_late_binary_op;
 extern const char *c_addr_space_name (addr_space_t as);
+extern const char *c_addr_space_name (addr_space_t as);
+extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
 extern tree identifier_global_value (tree);
 extern tree identifier_global_tag (tree);
 extern bool names_builtin_p (const char *);
@@ -952,6 +951,7 @@ extern void c_common_finish (void);
 extern void c_common_parse_file (void);
 extern FILE *get_dump_info (int, dump_flags_t *);
 extern alias_set_type c_common_get_alias_set (tree);
+extern void c_register_addr_space (const char *, addr_space_t);
 extern void c_register_builtin_type (tree, const char*);
 extern bool c_promoting_integer_type_p (const_tree);
 extern bool self_promoting_args_p (const_tree);
diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index c701f07befe..e1bb4f1cf37 100644
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
   ext_block = NULL;
 }
 
-/* Register reserved keyword WORD as qualifier for address space AS.  */
-
-void
-c_register_addr_space (const char *word, addr_space_t as)
-{
-  int rid = RID_FIRST_ADDR_SPACE + as;
-  tree id;
-
-  /* Address space qualifiers are only supported
-     in C with GNU extensions enabled.  */
-  if (c_dialect_objc () || flag_no_asm)
-    return;
-
-  id = get_identifier (word);
-  C_SET_RID_CODE (id, rid);
-  C_IS_RESERVED_WORD (id) = 1;
-  ridpointers [rid] = id;
-}
-
 /* Return identifier to look up for omp declare reduction.  */
 
 tree
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index b271af9bedb..c4b01368534 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
   return type;
 }
 
-/* Return true if between two named address spaces, whether there is a superset
-   named address space that encompasses both address spaces.  If there is a
-   superset, return which address space is the superset.  */
-
-static bool
-addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
-{
-  if (as1 == as2)
-    {
-      *common = as1;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as1, as2))
-    {
-      *common = as2;
-      return true;
-    }
-  else if (targetm.addr_space.subset_p (as2, as1))
-    {
-      *common = as1;
-      return true;
-    }
-  else
-    return false;
-}
-
 /* Return a variant of TYPE which has all the type qualifiers of LIKE
    as well as those of TYPE.  */
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 72f4398a8f9..82a6d72f5df 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6206,6 +6206,7 @@ enum cp_decl_spec {
   ds_const,
   ds_volatile,
   ds_restrict,
+  ds_addr_space,
   ds_inline,
   ds_virtual,
   ds_explicit,
@@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
   cp_storage_class storage_class;
   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
   int int_n_idx;
+  /* The address space that the declaration belongs to.  */
+  addr_space_t address_space;
   /* True iff TYPE_SPEC defines a class or enum.  */
   BOOL_BITFIELD type_definition_p : 1;
   /* True iff multiple types were (erroneously) specified for this
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 9f78c500a15..fa5a1ddb21d 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
     type_quals |= TYPE_QUAL_VOLATILE;
   if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
     type_quals |= TYPE_QUAL_RESTRICT;
+  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
 
   return type_quals;
 }
@@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
 	error_at (declspecs->locations[ds_restrict],
 		  "%<__restrict%> can only be specified for objects and "
 		  "functions");
+      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
+	error_at (declspecs->locations[ds_addr_space],
+		  "address space can only be specified for objects and "
+		  "functions");
       else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
 	error_at (declspecs->locations[ds_thread],
 		  "%<__thread%> can only be specified for objects "
@@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
     if (!processing_template_decl)
       cp_apply_type_quals_to_decl (type_quals, decl);
 
+    addr_space_t address_space = declspecs->address_space;
+    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
+      {
+	if (decl_context == NORMAL)
+	  {
+	    switch (storage_class)
+	      {
+	      case sc_auto:
+		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
+		       c_addr_space_name (address_space), name);
+		break;
+	      case sc_register:
+		error ("%qs combined with %<register%> qualifier for %qs",
+		       c_addr_space_name (address_space), name);
+		break;
+	      case sc_none:
+		if (! toplevel_bindings_p ())
+		  error ("%qs specified for auto variable %qs",
+			 c_addr_space_name (address_space), name);
+		break;
+	      case sc_mutable:
+		error ("%qs combined with %<mutable%> qualifier for %qs",
+		       c_addr_space_name (address_space), name);
+		break;
+	      case sc_static:
+	      case sc_extern:
+		break;
+	      default:
+		gcc_unreachable ();
+	      }
+	  }
+	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
+	  {
+	    if (name)
+	      error ("%qs specified for parameter %qs",
+		     c_addr_space_name (address_space), name);
+	    else
+	      error ("%qs specified for unnamed parameter",
+		     c_addr_space_name (address_space));
+	  }
+	else if (decl_context == FIELD)
+	  {
+	    if (name)
+	      error ("%qs specified for structure field %qs",
+		     c_addr_space_name (address_space), name);
+	    else
+	      error ("%qs specified for structure field",
+		     c_addr_space_name (address_space));
+	  }
+      }
+
     return decl;
   }
 }
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index eb53e0ebeb4..16cb2ff4332 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
      array.  */
   cp_cv_quals quals = TYPE_QUALS (type);
 
+  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
+    {
+      const char *as_name = c_addr_space_name (as);
+      write_char ('U');
+      write_unsigned_number (strlen (as_name));
+      write_string (as_name);
+      ++num_qualifiers;
+    }
   if (quals & TYPE_QUAL_RESTRICT)
     {
       write_char ('r');
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 763df6f479b..f0169d83ab0 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 		    postfix_expression = error_mark_node;
 		    break;
 		  }
+		if (type != error_mark_node
+		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
+		    && current_function_decl)
+		  {
+		    error
+		      ("compound literal qualified by address-space qualifier");
+		    type = error_mark_node;
+		  }
 		/* Form the representation of the compound-literal.  */
 		postfix_expression
 		  = finish_compound_literal (type, initializer,
@@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
       break;
     }
 
+
+  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
+    {
+      ds = ds_addr_space;
+      if (is_cv_qualifier)
+	*is_cv_qualifier = true;
+    }
+
+
   /* Handle simple keywords.  */
   if (ds != ds_last)
     {
@@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
    GNU Extension:
 
    cv-qualifier:
+     address-space-qualifier
      __restrict__
 
    Returns a bitmask representing the cv-qualifiers.  */
@@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
 	  break;
 	}
 
+      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
+	  token->keyword <= RID_LAST_ADDR_SPACE)
+	cv_qualifier =
+	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
+
       if (!cv_qualifier)
 	break;
 
@@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
       decl_specs->locations[ds] = location;
       if (ds == ds_thread)
 	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
+      else if (ds == ds_addr_space)
+	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
     }
   else
     {
@@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
 	      error_at (&richloc, "duplicate %qD", token->u.value);
 	    }
 	}
+      else if (ds == ds_addr_space)
+	{
+	  addr_space_t as1 = decl_specs->address_space;
+	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
+
+	  gcc_rich_location richloc (location);
+	  richloc.add_fixit_remove ();
+	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
+	      && as1 != as2)
+	    error_at (&richloc,
+		      "conflicting named address spaces (%s vs %s)",
+		      c_addr_space_name (as1), c_addr_space_name (as2));
+	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
+	    error_at (&richloc,
+		      "duplicate named address space %s",
+		      c_addr_space_name (as1));
+
+	  decl_specs->address_space = as2;
+	}
       else
 	{
 	  static const char *const decl_spec_names[] = {
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index bef31416fb7..c9d1c01f4ce 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
 static int
 check_cv_quals_for_unify (int strict, tree arg, tree parm)
 {
-  int arg_quals = cp_type_quals (arg);
-  int parm_quals = cp_type_quals (parm);
+  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
+  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
+
+  /*  Try to unify ARG's address space into PARM's address space.
+      If PARM does not have any address space qualifiers (ie., as_parm is 0),
+      there are no constraints on address spaces for this type.  */
+  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
+  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
+  addr_space_t as_common;
+  addr_space_superset (as_arg, as_parm, &as_common);
+
+  if (!(as_parm == as_common || as_parm == 0))
+    return 0;
 
   if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
       && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
@@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
 					 arg, parm))
 	    return unify_cv_qual_mismatch (explain_p, parm, arg);
 
+	  int arg_cv_quals = cp_type_quals (arg);
+	  int parm_cv_quals = cp_type_quals (parm);
+
+	  /* If PARM does not contain any address space constraints it can
+	     fully match the address space of ARG.  However, if PARM contains an
+	     address space constraint, it becomes the upper bound.  That is,
+	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
+	     ended up here, it means that `check_cv_quals_for_unify' succeeded
+	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
+	     AS_PARM.  */
+	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
+	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
+	  addr_space_t as_common = as_parm ? 0 : as_arg;
+
 	  /* Consider the case where ARG is `const volatile int' and
 	     PARM is `const T'.  Then, T should be `volatile int'.  */
-	  arg = cp_build_qualified_type_real
-	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
+	  int unified_cv =
+	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
+	    | ENCODE_QUAL_ADDR_SPACE (as_common);
+	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
 	  if (arg == error_mark_node)
 	    return unify_invalid (explain_p);
 
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 3b37567cbd7..5e14ac837fc 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
     DECL_CHAIN (t) = NULL_TREE;
 }
 
-/* Stub for c-common.  Please keep in sync with c-decl.cc.
-   FIXME: If address space support is target specific, then this
-   should be a C target hook.  But currently this is not possible,
-   because this function is called via REGISTER_TARGET_PRAGMAS.  */
-void
-c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
-{
-}
-
 /* Return the number of operands in T that we care about for things like
    mangling.  */
 
diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index ceb80d9744f..7d810c6a12c 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
 	  else
 	    return error_mark_node;
         }
+      /* If possible merge the address space into the superset of the address
+	  spaces of t1 and t2, or raise an error. */
+      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
+      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
+      addr_space_t as_common;
+
+      /* If the two named address spaces are different, determine the common
+	 superset address space.  If there isn't one, raise an error.  */
+      if (!addr_space_superset (as_t1, as_t2, &as_common))
+	{
+	  as_common = as_t1;
+	  error_at (location,
+		    "%qT and %qT are in disjoint named address spaces",
+		    t1, t2);
+	}
       result_type
 	= cp_build_qualified_type (void_type_node,
-				   (cp_type_quals (TREE_TYPE (t1))
-				    | cp_type_quals (TREE_TYPE (t2))));
+				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
+				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
+				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
       result_type = build_pointer_type (result_type);
       /* Merge the attributes.  */
       attributes = (*targetm.merge_type_attributes) (t1, t2);
@@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
 }
 
 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
-   top-level qualifiers.  */
+   top-level qualifiers, except for named address spaces.  If the pointers point
+   to different named addresses spaces, then we must determine if one address
+   space is a subset of the other.  */
 
 bool
 same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
@@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
   if (type1 == type2)
     return true;
 
+  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
+  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
+  addr_space_t as_common;
+
+  /* Fail if pointers point to incompatible address spaces.  */
+  if (!addr_space_superset (as_type1, as_type2, &as_common))
+    return false;
+
   type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
   type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
   return same_type_p (type1, type2);
@@ -6374,10 +6400,32 @@ static tree
 pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
 	      tsubst_flags_t complain, tree *instrument_expr)
 {
-  tree result, inttype;
   tree restype = ptrdiff_type_node;
+  tree result, inttype;
+
+  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
+  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
   tree target_type = TREE_TYPE (ptrtype);
 
+  /* If the operands point into different address spaces, we need to
+     explicitly convert them to pointers into the common address space
+     before we can subtract the numerical address values.  */
+  if (as0 != as1)
+    {
+      addr_space_t as_common;
+      tree common_type;
+
+      /* Determine the common superset address space.  This is guaranteed
+	 to exist because the caller verified that comp_target_types
+	 returned non-zero.  */
+      if (!addr_space_superset (as0, as1, &as_common))
+	gcc_unreachable ();
+
+      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
+      op0 = convert (common_type, op0);
+      op1 = convert (common_type, op1);
+    }
+
   if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
     return error_mark_node;
 
@@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
 	      to_more_cv_qualified = true;
 	    }
 
+      /* Warn about conversions between pointers to disjoint
+	 address spaces.  */
+      if (TREE_CODE (from) == POINTER_TYPE
+	  && TREE_CODE (to) == POINTER_TYPE)
+	{
+	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
+	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
+	  addr_space_t as_common;
+
+	  if (!addr_space_superset (as_to, as_from, &as_common))
+	    return false;
+	}
+
 	  if (constp > 0)
 	    constp &= TYPE_READONLY (to);
 	}
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index ac3db88566d..1e0d436c02c 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
 @section Named Address Spaces
 @cindex Named Address Spaces
 
-As an extension, GNU C supports named address spaces as
+As an extension, GNU C and GNU C++ support named address spaces as
 defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
 address spaces in GCC will evolve as the draft technical report
 changes.  Calling conventions for any target might also change.  At
diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
new file mode 100644
index 00000000000..c01f8d6054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do run { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-fabi-version=8 -Wabi -save-temps" }
+// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
+
+int f (int volatile __seg_fs *a)
+{
+  return *a;
+}
+
+int main () {}
diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
new file mode 100644
index 00000000000..862bbbdcdf2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
@@ -0,0 +1,9 @@
+// { dg-do run { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-fabi-version=8 -Wabi -save-temps" }
+// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
+
+template <class T>
+int f (T *p) { return *p; }
+int g (__seg_fs int *p) { return *p; }
+__seg_fs int *a;
+int main() { f(a); }
diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
new file mode 100644
index 00000000000..c04d2f497da
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
@@ -0,0 +1,5 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+__seg_fs char a, b, c;
+__seg_fs const int *p;
+static /* give internal linkage to the following anonymous struct */
+__seg_fs struct { int a; char b; } * __seg_gs q;
diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
new file mode 100644
index 00000000000..86c02d1e7f5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
@@ -0,0 +1,20 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+int __seg_fs * fs1;
+int __seg_fs * fs2;
+float __seg_gs * gs1;
+float __seg_gs * gs2;
+
+int
+main ()
+{
+  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
+  fs1 - fs2;
+  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
+  fs1 == fs2;
+  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
+  fs1 = fs2;
+  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
+  fs1 > fs2;
+  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
new file mode 100644
index 00000000000..12d7975e560
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
@@ -0,0 +1,31 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+// { dg-prune-output "does not allow .register. storage class specifier" }
+int __seg_fs * outer_b;
+
+struct s {
+  __seg_fs int * ok;
+  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
+};
+
+int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
+
+namespace ns_a
+{
+  int __seg_fs * inner_b;
+
+  template<typename T>
+  int f (T &a) { return a; }
+  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
+  int h (__seg_fs int *a) { return *a; }
+}
+
+int
+main ()
+{
+  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
+  static __seg_gs int static_gs;
+  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
+  __seg_fs int *pa = outer_b;
+  __seg_fs int& ra = *ns_a::inner_b;
+  return ns_a::f(ra) + ns_a::f(*pa);
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
new file mode 100644
index 00000000000..ebb6316054a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
new file mode 100644
index 00000000000..2e8ee32a885
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
@@ -0,0 +1,10 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+// { dg-options "-std=gnu++98" }
+
+int
+main ()
+{
+	struct foo {int a; char b[2];} structure;
+	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
new file mode 100644
index 00000000000..5b2c0f28078
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
@@ -0,0 +1,9 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
+
+int
+main ()
+{
+	return 0; 
+}
diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
new file mode 100644
index 00000000000..ae9f4de0e1f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
@@ -0,0 +1,8 @@
+// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
+
+template <class T>
+int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
+				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
+__seg_fs int *a;
+int main() { f(a); } // { dg-error "no matching" }
+// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
diff --git a/gcc/tree.h b/gcc/tree.h
index 8844471e9a5..b7da4c5141a 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
 
 /* Encode/decode the named memory support as part of the qualifier.  If more
    than 8 qualifiers are added, these macros need to be adjusted.  */
-#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
+#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
 #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
 
 /* Return all qualifiers except for the address space qualifiers.  */
  

On Thu, Oct 13, 2022 at 02:52:59AM +0200, Paul Iannetta via Gcc-patches wrote:
> +		if (type != error_mark_node
> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> +		    && current_function_decl)
> +		  {
> +		    error
> +		      ("compound literal qualified by address-space qualifier");
> +		    type = error_mark_node;

Can you please write this as:
		    error ("compound literal qualified by address-space "
			   "qualifier");
?  That is how diagnostics that don't fit on one line are usually written.

> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>  	  break;
>  	}
>  
> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&

&& should never go at the end of line.

> +	  token->keyword <= RID_LAST_ADDR_SPACE)
> +	cv_qualifier =

and similarly = (except for aggregate initializers).

> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);

So:

      if (RID_FIRST_ADDR_SPACE <= token->keyword
	  && token->keyword <= RID_LAST_ADDR_SPACE)
	cv_qualifier
	  = ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);

> +	  int unified_cv =
> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);

Similarly (but this time with ()s added to ensure correct formatting in
some editors).

	  int unified_cv
	    = (CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
	       | ENCODE_QUAL_ADDR_SPACE (as_common));

>        result_type
>  	= cp_build_qualified_type (void_type_node,
> -				   (cp_type_quals (TREE_TYPE (t1))
> -				    | cp_type_quals (TREE_TYPE (t2))));
> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))

The above 2 lines are way too long.
I'd suggest to use temporaries, say
	  int quals1 = cp_type_quals (TREE_TYPE (t1));
	  int quals2 = cp_type_quals (TREE_TYPE (t2));
and use those.

	Jakub
  

On 10/12/22 20:52, Paul Iannetta wrote:
> On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
>>
>> It surprises that this is the only place we complain about an object with an
>> address-space qualifier.  Shouldn't we also complain about e.g. automatic
>> variables/parameters or non-static data members with address-space qualified
>> type?
>>
> 
> Indeed, I was missing quite a few things here.  Thanks.
> I used the draft as basis this time and imported from the C
> implementation the relevant parts.  This time, the errors get properly
> emitted when an address space is unduly specified; and comparisons,
> assignments and comparisons are taken care of.
> 
> There are quite a few things I would like to clarify concerning some
> implementation details.
>    - A variable with automatic storage (which is neither a pointer nor
>      a reference) cannot be qualified with an address space.  I detect
>      this by the combination of `sc_none' and `! toplevel_bindings_p ()',
>      but I've also seen the use of `at_function_scope' at other places.
>      And I'm unsure which one is appropriate here.
>      This detection happens at the very end of grokdeclarator because I
>      need to know that the type is a pointer, which is not know until
>      very late in the function.

At that point you have the decl, and you can ask directly what its 
storage duration is, perhaps using decl_storage_duration.

But why do you need to know whether the type is a pointer?  The 
attribute applies to the target type of the pointer, not the pointer 
type.  I think the problem is that you're looking at declspecs when you 
ought to be looking at type_quals.

>    - I'm having some trouble deciding whether I include those three
>      stub programs as tests, they all compile fine and clang accepts
>      them as well.

Why not?

> Ex1:
> ```
> int __seg_fs * fs1;
> int __seg_gs * gs1;
> 
> template<typename T> struct strip;
> template<typename T> struct strip<__seg_fs T *> { typedef T type; };
> template<typename T> struct strip<__seg_gs T *> { typedef T type; };
> 
> int
> main ()
> {
>      *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
>      return 0;
> }
> ```
> 
> Ex2:
> ```
> int __seg_fs * fs1;
> int __seg_fs * fs2;
> 
> template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
> template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
> 
> int
> main ()
> {
>      f (fs1, gs1);
>      f (gs1, fs1);
>      return 0;
> }
> ```
> 
> Ex3:
> ```
> int __seg_fs * fs1;
> int __seg_gs * gs1;
> 
> template<typename T, typename U>
> auto f (T __seg_fs * a, U __seg_gs * b)
> {
>      return *(T *) a == *(U *) b;
> }
> 
> int
> main ()
> {
>      return f (fs1, gs1);
> }
> ```
> 
> 
> Add support for custom address spaces in C++
> 
> gcc/
>          * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> 
> gcc/c/
>          * c-decl.cc: Remove c_register_addr_space.
> 
> gcc/c-family/
>          * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>          (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>          * c-common.h: Remove the FIXME.
>          (addr_space_superset): New declaration.
> 
> gcc/cp/
>          * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>          (struct cp_decl_specifier_seq): Likewise.
>          * decl.cc (get_type_quals): Likewise.
>          (check_tag_decl): Likewise.
> 	(grokdeclarator): Likewise.
>          * parser.cc (cp_parser_type_specifier): Likewise.
>          (cp_parser_cv_qualifier_seq_opt): Likewise.
>          (cp_parser_postfix_expression): Likewise.
>          (cp_parser_type_specifier): Likewise.
>          (set_and_check_decl_spec_loc): Likewise.
>          * typeck.cc (composite_pointer_type): Likewise
>          (comp_ptr_ttypes_real): Likewise.
> 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
>          * pt.cc (check_cv_quals_for_unify): Likewise.
>          (unify): Likewise.
>          * tree.cc: Remove c_register_addr_space stub.
>          * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>            using the extended qualifier notation.
> 
> gcc/doc
>          * extend.texi (Named Address Spaces): add a mention about C++
>            support.
> 
> gcc/testsuite/
>          * g++.dg/abi/mangle-addr-space1.C: New test.
>          * g++.dg/abi/mangle-addr-space2.C: New test.
>          * g++.dg/parse/addr-space.C: New test.
>          * g++.dg/parse/addr-space1.C: New test.
>          * g++.dg/parse/addr-space2.C: New test.
>          * g++.dg/parse/template/spec-addr-space.C: New test.
>          * g++.dg/ext/addr-space-decl.C: New test.
>          * g++.dg/ext/addr-space-ref.C: New test.
>          * g++.dg/ext/addr-space-ops.C: New test.
> 
> # Please enter the commit message for your changes. Lines starting
> # with '#' will be ignored, and an empty message aborts the commit.
> #
> # Date:      Sun Oct 9 16:02:22 2022 +0200
> #
> # On branch releases/gcc-12
> # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
> #   (use "git push" to publish your local commits)
> #
> # Changes to be committed:
> #	modified:   gcc/c-family/c-common.cc
> #	modified:   gcc/c-family/c-common.h
> #	modified:   gcc/c/c-decl.cc
> #	modified:   gcc/c/c-typeck.cc
> #	modified:   gcc/cp/cp-tree.h
> #	modified:   gcc/cp/decl.cc
> #	modified:   gcc/cp/mangle.cc
> #	modified:   gcc/cp/parser.cc
> #	modified:   gcc/cp/pt.cc
> #	modified:   gcc/cp/tree.cc
> #	modified:   gcc/cp/typeck.cc
> #	modified:   gcc/doc/extend.texi
> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
> #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
> #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
> #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
> #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
> #	modified:   gcc/tree.h
> #
> # Untracked files:
> #	Makefile
> #	addr-space-decl.C
> #	addr-space-decl.s
> #	addr-space-ops.C
> #	addr-space-ref.C
> #	addr-space-template.C
> #	addr-space-template.s
> #	addr-space-template2.C
> #	addr-space-template2.C.006t.gimple
> #	addr-space-template2.s
> #	addr-space-traits.C
> #	addr-space4.C
> #	addr-space4.C.006t.gimple
> #	addr-space4.s
> #	build-x86_64-pc-linux-gnu/
> #	compare
> #	host-x86_64-pc-linux-gnu/
> #	mangle-addr-space1.s
> #	prev-x86_64-pc-linux-gnu/
> #	rename
> #	stage1-x86_64-pc-linux-gnu/
> #	stage_current
> #	stage_final
> #	stage_last
> #	x86_64-pc-linux-gnu/
> #
> # ------------------------ >8 ------------------------
> # Do not modify or remove the line above.
> # Everything below it will be ignored.
> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> index bb0544eeaea..ff1146ecc25 100644
> --- a/gcc/c-family/c-common.cc
> +++ b/gcc/c-family/c-common.cc
> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>     return IDENTIFIER_POINTER (ridpointers [rid]);
>   }
>   
> +/* Return true if between two named address spaces, whether there is a superset
> +   named address space that encompasses both address spaces.  If there is a
> +   superset, return which address space is the superset.  */
> +
> +bool
> +addr_space_superset (addr_space_t as1, addr_space_t as2,
> +		     addr_space_t * common)
> +{
> +  if (as1 == as2)
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as1, as2))
> +    {
> +      *common = as2;
> +      return true;
> +    }
> +  else if (targetm.addr_space.subset_p (as2, as1))
> +    {
> +      *common = as1;
> +      return true;
> +    }
> +  else
> +    return false;
> +}
> +
>   /* Push current bindings for the function name VAR_DECLS.  */
>   
>   void
> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>     return build_nonstandard_integer_type (width, unsignedp);
>   }
>   
> +/* Register reserved keyword WORD as qualifier for address space AS.  */
> +
> +void
> +c_register_addr_space (const char *word, addr_space_t as)
> +{
> +  int rid = RID_FIRST_ADDR_SPACE + as;
> +  tree id;
> +
> +  /* Address space qualifiers are only supported
> +     in C with GNU extensions enabled.  */
> +  if (c_dialect_objc () || flag_no_asm)
> +    return;
> +
> +  id = get_identifier (word);
> +  C_SET_RID_CODE (id, rid);
> +  TREE_LANG_FLAG_0 (id) = 1;
> +  ridpointers[rid] = id;
> +}
> +
>   /* The C version of the register_builtin_type langhook.  */
>   
>   void
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 52a85bfb783..d36f9e4975b 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>   
>   extern tree (*make_fname_decl) (location_t, tree, int);
>   
> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> -extern void c_register_addr_space (const char *str, addr_space_t as);
> -
>   /* In c-common.cc.  */
>   extern bool in_late_binary_op;
>   extern const char *c_addr_space_name (addr_space_t as);
> +extern const char *c_addr_space_name (addr_space_t as);
> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>   extern tree identifier_global_value (tree);
>   extern tree identifier_global_tag (tree);
>   extern bool names_builtin_p (const char *);
> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>   extern void c_common_parse_file (void);
>   extern FILE *get_dump_info (int, dump_flags_t *);
>   extern alias_set_type c_common_get_alias_set (tree);
> +extern void c_register_addr_space (const char *, addr_space_t);
>   extern void c_register_builtin_type (tree, const char*);
>   extern bool c_promoting_integer_type_p (const_tree);
>   extern bool self_promoting_args_p (const_tree);
> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> index c701f07befe..e1bb4f1cf37 100644
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>     ext_block = NULL;
>   }
>   
> -/* Register reserved keyword WORD as qualifier for address space AS.  */
> -
> -void
> -c_register_addr_space (const char *word, addr_space_t as)
> -{
> -  int rid = RID_FIRST_ADDR_SPACE + as;
> -  tree id;
> -
> -  /* Address space qualifiers are only supported
> -     in C with GNU extensions enabled.  */
> -  if (c_dialect_objc () || flag_no_asm)
> -    return;
> -
> -  id = get_identifier (word);
> -  C_SET_RID_CODE (id, rid);
> -  C_IS_RESERVED_WORD (id) = 1;
> -  ridpointers [rid] = id;
> -}
> -
>   /* Return identifier to look up for omp declare reduction.  */
>   
>   tree
> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> index b271af9bedb..c4b01368534 100644
> --- a/gcc/c/c-typeck.cc
> +++ b/gcc/c/c-typeck.cc
> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>     return type;
>   }
>   
> -/* Return true if between two named address spaces, whether there is a superset
> -   named address space that encompasses both address spaces.  If there is a
> -   superset, return which address space is the superset.  */
> -
> -static bool
> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> -{
> -  if (as1 == as2)
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as1, as2))
> -    {
> -      *common = as2;
> -      return true;
> -    }
> -  else if (targetm.addr_space.subset_p (as2, as1))
> -    {
> -      *common = as1;
> -      return true;
> -    }
> -  else
> -    return false;
> -}
> -
>   /* Return a variant of TYPE which has all the type qualifiers of LIKE
>      as well as those of TYPE.  */
>   
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 72f4398a8f9..82a6d72f5df 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>     ds_const,
>     ds_volatile,
>     ds_restrict,
> +  ds_addr_space,
>     ds_inline,
>     ds_virtual,
>     ds_explicit,
> @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
>     cp_storage_class storage_class;
>     /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>     int int_n_idx;
> +  /* The address space that the declaration belongs to.  */
> +  addr_space_t address_space;
>     /* True iff TYPE_SPEC defines a class or enum.  */
>     BOOL_BITFIELD type_definition_p : 1;
>     /* True iff multiple types were (erroneously) specified for this
> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> index 9f78c500a15..fa5a1ddb21d 100644
> --- a/gcc/cp/decl.cc
> +++ b/gcc/cp/decl.cc
> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>       type_quals |= TYPE_QUAL_VOLATILE;
>     if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>       type_quals |= TYPE_QUAL_RESTRICT;
> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>   
>     return type_quals;
>   }
> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>   	error_at (declspecs->locations[ds_restrict],
>   		  "%<__restrict%> can only be specified for objects and "
>   		  "functions");
> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> +	error_at (declspecs->locations[ds_addr_space],
> +		  "address space can only be specified for objects and "
> +		  "functions");
>         else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>   	error_at (declspecs->locations[ds_thread],
>   		  "%<__thread%> can only be specified for objects "
> @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
>       if (!processing_template_decl)
>         cp_apply_type_quals_to_decl (type_quals, decl);
>   
> +    addr_space_t address_space = declspecs->address_space;
> +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
> +      {
> +	if (decl_context == NORMAL)
> +	  {
> +	    switch (storage_class)
> +	      {
> +	      case sc_auto:
> +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
> +		       c_addr_space_name (address_space), name);
> +		break;
> +	      case sc_register:
> +		error ("%qs combined with %<register%> qualifier for %qs",
> +		       c_addr_space_name (address_space), name);
> +		break;
> +	      case sc_none:
> +		if (! toplevel_bindings_p ())
> +		  error ("%qs specified for auto variable %qs",
> +			 c_addr_space_name (address_space), name);
> +		break;
> +	      case sc_mutable:
> +		error ("%qs combined with %<mutable%> qualifier for %qs",
> +		       c_addr_space_name (address_space), name);
> +		break;
> +	      case sc_static:
> +	      case sc_extern:
> +		break;
> +	      default:
> +		gcc_unreachable ();
> +	      }
> +	  }
> +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
> +	  {
> +	    if (name)
> +	      error ("%qs specified for parameter %qs",
> +		     c_addr_space_name (address_space), name);
> +	    else
> +	      error ("%qs specified for unnamed parameter",
> +		     c_addr_space_name (address_space));
> +	  }
> +	else if (decl_context == FIELD)
> +	  {
> +	    if (name)
> +	      error ("%qs specified for structure field %qs",
> +		     c_addr_space_name (address_space), name);
> +	    else
> +	      error ("%qs specified for structure field",
> +		     c_addr_space_name (address_space));
> +	  }
> +      }
> +
>       return decl;
>     }
>   }
> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> index eb53e0ebeb4..16cb2ff4332 100644
> --- a/gcc/cp/mangle.cc
> +++ b/gcc/cp/mangle.cc
> @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
>        array.  */
>     cp_cv_quals quals = TYPE_QUALS (type);
>   
> +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
> +    {
> +      const char *as_name = c_addr_space_name (as);
> +      write_char ('U');
> +      write_unsigned_number (strlen (as_name));
> +      write_string (as_name);
> +      ++num_qualifiers;
> +    }
>     if (quals & TYPE_QUAL_RESTRICT)
>       {
>         write_char ('r');
> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> index 763df6f479b..f0169d83ab0 100644
> --- a/gcc/cp/parser.cc
> +++ b/gcc/cp/parser.cc
> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>   		    postfix_expression = error_mark_node;
>   		    break;
>   		  }
> +		if (type != error_mark_node
> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> +		    && current_function_decl)
> +		  {
> +		    error
> +		      ("compound literal qualified by address-space qualifier");
> +		    type = error_mark_node;
> +		  }
>   		/* Form the representation of the compound-literal.  */
>   		postfix_expression
>   		  = finish_compound_literal (type, initializer,
> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>         break;
>       }
>   
> +
> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> +    {
> +      ds = ds_addr_space;
> +      if (is_cv_qualifier)
> +	*is_cv_qualifier = true;
> +    }
> +
> +
>     /* Handle simple keywords.  */
>     if (ds != ds_last)
>       {
> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>      GNU Extension:
>   
>      cv-qualifier:
> +     address-space-qualifier
>        __restrict__
>   
>      Returns a bitmask representing the cv-qualifiers.  */
> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>   	  break;
>   	}
>   
> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> +	  token->keyword <= RID_LAST_ADDR_SPACE)
> +	cv_qualifier =
> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> +
>         if (!cv_qualifier)
>   	break;
>   
> @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>         decl_specs->locations[ds] = location;
>         if (ds == ds_thread)
>   	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> +      else if (ds == ds_addr_space)
> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>       }
>     else
>       {
> @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>   	      error_at (&richloc, "duplicate %qD", token->u.value);
>   	    }
>   	}
> +      else if (ds == ds_addr_space)
> +	{
> +	  addr_space_t as1 = decl_specs->address_space;
> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> +
> +	  gcc_rich_location richloc (location);
> +	  richloc.add_fixit_remove ();
> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> +	      && as1 != as2)
> +	    error_at (&richloc,
> +		      "conflicting named address spaces (%s vs %s)",
> +		      c_addr_space_name (as1), c_addr_space_name (as2));
> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> +	    error_at (&richloc,
> +		      "duplicate named address space %s",
> +		      c_addr_space_name (as1));
> +
> +	  decl_specs->address_space = as2;
> +	}
>         else
>   	{
>   	  static const char *const decl_spec_names[] = {
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index bef31416fb7..c9d1c01f4ce 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
>   static int
>   check_cv_quals_for_unify (int strict, tree arg, tree parm)
>   {
> -  int arg_quals = cp_type_quals (arg);
> -  int parm_quals = cp_type_quals (parm);
> +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
> +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
> +
> +  /*  Try to unify ARG's address space into PARM's address space.
> +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
> +      there are no constraints on address spaces for this type.  */
> +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
> +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
> +  addr_space_t as_common;
> +  addr_space_superset (as_arg, as_parm, &as_common);
> +
> +  if (!(as_parm == as_common || as_parm == 0))
> +    return 0;
>   
>     if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
>         && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
> @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
>   					 arg, parm))
>   	    return unify_cv_qual_mismatch (explain_p, parm, arg);
>   
> +	  int arg_cv_quals = cp_type_quals (arg);
> +	  int parm_cv_quals = cp_type_quals (parm);
> +
> +	  /* If PARM does not contain any address space constraints it can
> +	     fully match the address space of ARG.  However, if PARM contains an
> +	     address space constraint, it becomes the upper bound.  That is,
> +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
> +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
> +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
> +	     AS_PARM.  */
> +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
> +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
> +	  addr_space_t as_common = as_parm ? 0 : as_arg;
> +
>   	  /* Consider the case where ARG is `const volatile int' and
>   	     PARM is `const T'.  Then, T should be `volatile int'.  */
> -	  arg = cp_build_qualified_type_real
> -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
> +	  int unified_cv =
> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
>   	  if (arg == error_mark_node)
>   	    return unify_invalid (explain_p);
>   
> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> index 3b37567cbd7..5e14ac837fc 100644
> --- a/gcc/cp/tree.cc
> +++ b/gcc/cp/tree.cc
> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>       DECL_CHAIN (t) = NULL_TREE;
>   }
>   
> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> -   FIXME: If address space support is target specific, then this
> -   should be a C target hook.  But currently this is not possible,
> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> -void
> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> -{
> -}
> -
>   /* Return the number of operands in T that we care about for things like
>      mangling.  */
>   
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index ceb80d9744f..7d810c6a12c 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>   	  else
>   	    return error_mark_node;
>           }
> +      /* If possible merge the address space into the superset of the address
> +	  spaces of t1 and t2, or raise an error. */
> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> +      addr_space_t as_common;
> +
> +      /* If the two named address spaces are different, determine the common
> +	 superset address space.  If there isn't one, raise an error.  */
> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> +	{
> +	  as_common = as_t1;
> +	  error_at (location,
> +		    "%qT and %qT are in disjoint named address spaces",
> +		    t1, t2);
> +	}
>         result_type
>   	= cp_build_qualified_type (void_type_node,
> -				   (cp_type_quals (TREE_TYPE (t1))
> -				    | cp_type_quals (TREE_TYPE (t2))));
> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>         result_type = build_pointer_type (result_type);
>         /* Merge the attributes.  */
>         attributes = (*targetm.merge_type_attributes) (t1, t2);
> @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
>   }
>   
>   /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
> -   top-level qualifiers.  */
> +   top-level qualifiers, except for named address spaces.  If the pointers point
> +   to different named addresses spaces, then we must determine if one address
> +   space is a subset of the other.  */
>   
>   bool
>   same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>     if (type1 == type2)
>       return true;
>   
> +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
> +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
> +  addr_space_t as_common;
> +
> +  /* Fail if pointers point to incompatible address spaces.  */
> +  if (!addr_space_superset (as_type1, as_type2, &as_common))
> +    return false;
> +
>     type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
>     type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
>     return same_type_p (type1, type2);
> @@ -6374,10 +6400,32 @@ static tree
>   pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
>   	      tsubst_flags_t complain, tree *instrument_expr)
>   {
> -  tree result, inttype;
>     tree restype = ptrdiff_type_node;
> +  tree result, inttype;
> +
> +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
> +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
>     tree target_type = TREE_TYPE (ptrtype);
>   
> +  /* If the operands point into different address spaces, we need to
> +     explicitly convert them to pointers into the common address space
> +     before we can subtract the numerical address values.  */
> +  if (as0 != as1)
> +    {
> +      addr_space_t as_common;
> +      tree common_type;
> +
> +      /* Determine the common superset address space.  This is guaranteed
> +	 to exist because the caller verified that comp_target_types
> +	 returned non-zero.  */
> +      if (!addr_space_superset (as0, as1, &as_common))
> +	gcc_unreachable ();
> +
> +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
> +      op0 = convert (common_type, op0);
> +      op1 = convert (common_type, op1);
> +    }
> +
>     if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
>       return error_mark_node;
>   
> @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>   	      to_more_cv_qualified = true;
>   	    }
>   
> +      /* Warn about conversions between pointers to disjoint
> +	 address spaces.  */
> +      if (TREE_CODE (from) == POINTER_TYPE
> +	  && TREE_CODE (to) == POINTER_TYPE)
> +	{
> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> +	  addr_space_t as_common;
> +
> +	  if (!addr_space_superset (as_to, as_from, &as_common))
> +	    return false;
> +	}
> +
>   	  if (constp > 0)
>   	    constp &= TYPE_READONLY (to);
>   	}
> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> index ac3db88566d..1e0d436c02c 100644
> --- a/gcc/doc/extend.texi
> +++ b/gcc/doc/extend.texi
> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>   @section Named Address Spaces
>   @cindex Named Address Spaces
>   
> -As an extension, GNU C supports named address spaces as
> +As an extension, GNU C and GNU C++ support named address spaces as
>   defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>   address spaces in GCC will evolve as the draft technical report
>   changes.  Calling conventions for any target might also change.  At
> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> new file mode 100644
> index 00000000000..c01f8d6054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> +
> +int f (int volatile __seg_fs *a)
> +{
> +  return *a;
> +}
> +
> +int main () {}
> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> new file mode 100644
> index 00000000000..862bbbdcdf2
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> @@ -0,0 +1,9 @@
> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
> +
> +template <class T>
> +int f (T *p) { return *p; }
> +int g (__seg_fs int *p) { return *p; }
> +__seg_fs int *a;
> +int main() { f(a); }
> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> new file mode 100644
> index 00000000000..c04d2f497da
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> @@ -0,0 +1,5 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +__seg_fs char a, b, c;
> +__seg_fs const int *p;
> +static /* give internal linkage to the following anonymous struct */
> +__seg_fs struct { int a; char b; } * __seg_gs q;
> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> new file mode 100644
> index 00000000000..86c02d1e7f5
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> @@ -0,0 +1,20 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +int __seg_fs * fs1;
> +int __seg_fs * fs2;
> +float __seg_gs * gs1;
> +float __seg_gs * gs2;
> +
> +int
> +main ()
> +{
> +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
> +  fs1 - fs2;
> +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
> +  fs1 == fs2;
> +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> +  fs1 = fs2;
> +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
> +  fs1 > fs2;
> +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> +  return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> new file mode 100644
> index 00000000000..12d7975e560
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> @@ -0,0 +1,31 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +// { dg-prune-output "does not allow .register. storage class specifier" }
> +int __seg_fs * outer_b;
> +
> +struct s {
> +  __seg_fs int * ok;
> +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
> +};
> +
> +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
> +
> +namespace ns_a
> +{
> +  int __seg_fs * inner_b;
> +
> +  template<typename T>
> +  int f (T &a) { return a; }
> +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
> +  int h (__seg_fs int *a) { return *a; }
> +}
> +
> +int
> +main ()
> +{
> +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
> +  static __seg_gs int static_gs;
> +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
> +  __seg_fs int *pa = outer_b;
> +  __seg_fs int& ra = *ns_a::inner_b;
> +  return ns_a::f(ra) + ns_a::f(*pa);
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> new file mode 100644
> index 00000000000..ebb6316054a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> new file mode 100644
> index 00000000000..2e8ee32a885
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> @@ -0,0 +1,10 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +// { dg-options "-std=gnu++98" }
> +
> +int
> +main ()
> +{
> +	struct foo {int a; char b[2];} structure;
> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> new file mode 100644
> index 00000000000..5b2c0f28078
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> @@ -0,0 +1,9 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> +
> +int
> +main ()
> +{
> +	return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> new file mode 100644
> index 00000000000..ae9f4de0e1f
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> @@ -0,0 +1,8 @@
> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> +
> +template <class T>
> +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
> +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
> +__seg_fs int *a;
> +int main() { f(a); } // { dg-error "no matching" }
> +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
> diff --git a/gcc/tree.h b/gcc/tree.h
> index 8844471e9a5..b7da4c5141a 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>   
>   /* Encode/decode the named memory support as part of the qualifier.  If more
>      than 8 qualifiers are added, these macros need to be adjusted.  */
> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>   #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>   
>   /* Return all qualifiers except for the address space qualifiers.  */
> 
> 
> 
>
  

On Thu, Oct 13, 2022 at 07:46:46AM +0200, Jakub Jelinek wrote:
> On Thu, Oct 13, 2022 at 02:52:59AM +0200, Paul Iannetta via Gcc-patches wrote:
> > +		if (type != error_mark_node
> > +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> > +		    && current_function_decl)
> > +		  {
> > +		    error
> > +		      ("compound literal qualified by address-space qualifier");
> > +		    type = error_mark_node;
> 
> Can you please write this as:
> 		    error ("compound literal qualified by address-space "
> 			   "qualifier");
> ?  That is how diagnostics that don't fit on one line are usually written.
> 
> > @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
> >  	  break;
> >  	}
> >  
> > +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> 
> && should never go at the end of line.
> 
> > +	  token->keyword <= RID_LAST_ADDR_SPACE)
> > +	cv_qualifier =
> 
> and similarly = (except for aggregate initializers).
> 
> > +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> 
> So:
> 
>       if (RID_FIRST_ADDR_SPACE <= token->keyword
> 	  && token->keyword <= RID_LAST_ADDR_SPACE)
> 	cv_qualifier
> 	  = ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> 
> > +	  int unified_cv =
> > +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> > +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> 
> Similarly (but this time with ()s added to ensure correct formatting in
> some editors).
> 
> 	  int unified_cv
> 	    = (CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> 	       | ENCODE_QUAL_ADDR_SPACE (as_common));
> 
> >        result_type
> >  	= cp_build_qualified_type (void_type_node,
> > -				   (cp_type_quals (TREE_TYPE (t1))
> > -				    | cp_type_quals (TREE_TYPE (t2))));
> > +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> > +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> 
> The above 2 lines are way too long.
> I'd suggest to use temporaries, say
> 	  int quals1 = cp_type_quals (TREE_TYPE (t1));
> 	  int quals2 = cp_type_quals (TREE_TYPE (t2));
> and use those.
> 
> 	Jakub

Thank you for the style review, I'll apply them in the next iteration.

Paul
  

On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
> On 10/12/22 20:52, Paul Iannetta wrote:
> > On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
> > > 
> > > It surprises that this is the only place we complain about an object with an
> > > address-space qualifier.  Shouldn't we also complain about e.g. automatic
> > > variables/parameters or non-static data members with address-space qualified
> > > type?
> > > 
> > 
> > Indeed, I was missing quite a few things here.  Thanks.
> > I used the draft as basis this time and imported from the C
> > implementation the relevant parts.  This time, the errors get properly
> > emitted when an address space is unduly specified; and comparisons,
> > assignments and comparisons are taken care of.
> > 
> > There are quite a few things I would like to clarify concerning some
> > implementation details.
> >    - A variable with automatic storage (which is neither a pointer nor
> >      a reference) cannot be qualified with an address space.  I detect
> >      this by the combination of `sc_none' and `! toplevel_bindings_p ()',
> >      but I've also seen the use of `at_function_scope' at other places.
> >      And I'm unsure which one is appropriate here.
> >      This detection happens at the very end of grokdeclarator because I
> >      need to know that the type is a pointer, which is not know until
> >      very late in the function.
> 
> At that point you have the decl, and you can ask directly what its storage
> duration is, perhaps using decl_storage_duration.
> 
> But why do you need to know whether the type is a pointer?  The attribute
> applies to the target type of the pointer, not the pointer type.  I think
> the problem is that you're looking at declspecs when you ought to be looking
> at type_quals.
> 

I need to know that the base type is a pointer to reject invalid
declarations such as:

    int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }

because parameters and auto variables can have an address space
qualifier only if they are pointer or reference type, which I can't
tell only from type_quals.

> >    - I'm having some trouble deciding whether I include those three
> >      stub programs as tests, they all compile fine and clang accepts
> >      them as well.
> 
> Why not?

I thought they were pretty contrived, since it does not make much
sense to strip address space qualifiers, even though it does prove
that the implementation support those contrived but valid uses.

> 
> > Ex1:
> > ```
> > int __seg_fs * fs1;
> > int __seg_gs * gs1;
> > 
> > template<typename T> struct strip;
> > template<typename T> struct strip<__seg_fs T *> { typedef T type; };
> > template<typename T> struct strip<__seg_gs T *> { typedef T type; };
> > 
> > int
> > main ()
> > {
> >      *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
> >      return 0;
> > }
> > ```
> > 
> > Ex2:
> > ```
> > int __seg_fs * fs1;
> > int __seg_fs * fs2;
> > 
> > template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
> > template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
> > 
> > int
> > main ()
> > {
> >      f (fs1, gs1);
> >      f (gs1, fs1);
> >      return 0;
> > }
> > ```
> > 
> > Ex3:
> > ```
> > int __seg_fs * fs1;
> > int __seg_gs * gs1;
> > 
> > template<typename T, typename U>
> > auto f (T __seg_fs * a, U __seg_gs * b)
> > {
> >      return *(T *) a == *(U *) b;
> > }
> > 
> > int
> > main ()
> > {
> >      return f (fs1, gs1);
> > }
> > ```
> > 
> > 
> > Add support for custom address spaces in C++
> > 
> > gcc/
> >          * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> > 
> > gcc/c/
> >          * c-decl.cc: Remove c_register_addr_space.
> > 
> > gcc/c-family/
> >          * c-common.cc (c_register_addr_space): Imported from c-decl.cc
> >          (addr_space_superset): Imported from gcc/c/c-typecheck.cc
> >          * c-common.h: Remove the FIXME.
> >          (addr_space_superset): New declaration.
> > 
> > gcc/cp/
> >          * cp-tree.h (enum cp_decl_spec): Add addr_space support.
> >          (struct cp_decl_specifier_seq): Likewise.
> >          * decl.cc (get_type_quals): Likewise.
> >          (check_tag_decl): Likewise.
> > 	(grokdeclarator): Likewise.
> >          * parser.cc (cp_parser_type_specifier): Likewise.
> >          (cp_parser_cv_qualifier_seq_opt): Likewise.
> >          (cp_parser_postfix_expression): Likewise.
> >          (cp_parser_type_specifier): Likewise.
> >          (set_and_check_decl_spec_loc): Likewise.
> >          * typeck.cc (composite_pointer_type): Likewise
> >          (comp_ptr_ttypes_real): Likewise.
> > 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
> >          * pt.cc (check_cv_quals_for_unify): Likewise.
> >          (unify): Likewise.
> >          * tree.cc: Remove c_register_addr_space stub.
> >          * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
> >            using the extended qualifier notation.
> > 
> > gcc/doc
> >          * extend.texi (Named Address Spaces): add a mention about C++
> >            support.
> > 
> > gcc/testsuite/
> >          * g++.dg/abi/mangle-addr-space1.C: New test.
> >          * g++.dg/abi/mangle-addr-space2.C: New test.
> >          * g++.dg/parse/addr-space.C: New test.
> >          * g++.dg/parse/addr-space1.C: New test.
> >          * g++.dg/parse/addr-space2.C: New test.
> >          * g++.dg/parse/template/spec-addr-space.C: New test.
> >          * g++.dg/ext/addr-space-decl.C: New test.
> >          * g++.dg/ext/addr-space-ref.C: New test.
> >          * g++.dg/ext/addr-space-ops.C: New test.
> > 
> > # Please enter the commit message for your changes. Lines starting
> > # with '#' will be ignored, and an empty message aborts the commit.
> > #
> > # Date:      Sun Oct 9 16:02:22 2022 +0200
> > #
> > # On branch releases/gcc-12
> > # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
> > #   (use "git push" to publish your local commits)
> > #
> > # Changes to be committed:
> > #	modified:   gcc/c-family/c-common.cc
> > #	modified:   gcc/c-family/c-common.h
> > #	modified:   gcc/c/c-decl.cc
> > #	modified:   gcc/c/c-typeck.cc
> > #	modified:   gcc/cp/cp-tree.h
> > #	modified:   gcc/cp/decl.cc
> > #	modified:   gcc/cp/mangle.cc
> > #	modified:   gcc/cp/parser.cc
> > #	modified:   gcc/cp/pt.cc
> > #	modified:   gcc/cp/tree.cc
> > #	modified:   gcc/cp/typeck.cc
> > #	modified:   gcc/doc/extend.texi
> > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
> > #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
> > #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
> > #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
> > #	modified:   gcc/tree.h
> > #
> > # Untracked files:
> > #	Makefile
> > #	addr-space-decl.C
> > #	addr-space-decl.s
> > #	addr-space-ops.C
> > #	addr-space-ref.C
> > #	addr-space-template.C
> > #	addr-space-template.s
> > #	addr-space-template2.C
> > #	addr-space-template2.C.006t.gimple
> > #	addr-space-template2.s
> > #	addr-space-traits.C
> > #	addr-space4.C
> > #	addr-space4.C.006t.gimple
> > #	addr-space4.s
> > #	build-x86_64-pc-linux-gnu/
> > #	compare
> > #	host-x86_64-pc-linux-gnu/
> > #	mangle-addr-space1.s
> > #	prev-x86_64-pc-linux-gnu/
> > #	rename
> > #	stage1-x86_64-pc-linux-gnu/
> > #	stage_current
> > #	stage_final
> > #	stage_last
> > #	x86_64-pc-linux-gnu/
> > #
> > # ------------------------ >8 ------------------------
> > # Do not modify or remove the line above.
> > # Everything below it will be ignored.
> > diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> > index bb0544eeaea..ff1146ecc25 100644
> > --- a/gcc/c-family/c-common.cc
> > +++ b/gcc/c-family/c-common.cc
> > @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
> >     return IDENTIFIER_POINTER (ridpointers [rid]);
> >   }
> > +/* Return true if between two named address spaces, whether there is a superset
> > +   named address space that encompasses both address spaces.  If there is a
> > +   superset, return which address space is the superset.  */
> > +
> > +bool
> > +addr_space_superset (addr_space_t as1, addr_space_t as2,
> > +		     addr_space_t * common)
> > +{
> > +  if (as1 == as2)
> > +    {
> > +      *common = as1;
> > +      return true;
> > +    }
> > +  else if (targetm.addr_space.subset_p (as1, as2))
> > +    {
> > +      *common = as2;
> > +      return true;
> > +    }
> > +  else if (targetm.addr_space.subset_p (as2, as1))
> > +    {
> > +      *common = as1;
> > +      return true;
> > +    }
> > +  else
> > +    return false;
> > +}
> > +
> >   /* Push current bindings for the function name VAR_DECLS.  */
> >   void
> > @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
> >     return build_nonstandard_integer_type (width, unsignedp);
> >   }
> > +/* Register reserved keyword WORD as qualifier for address space AS.  */
> > +
> > +void
> > +c_register_addr_space (const char *word, addr_space_t as)
> > +{
> > +  int rid = RID_FIRST_ADDR_SPACE + as;
> > +  tree id;
> > +
> > +  /* Address space qualifiers are only supported
> > +     in C with GNU extensions enabled.  */
> > +  if (c_dialect_objc () || flag_no_asm)
> > +    return;
> > +
> > +  id = get_identifier (word);
> > +  C_SET_RID_CODE (id, rid);
> > +  TREE_LANG_FLAG_0 (id) = 1;
> > +  ridpointers[rid] = id;
> > +}
> > +
> >   /* The C version of the register_builtin_type langhook.  */
> >   void
> > diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> > index 52a85bfb783..d36f9e4975b 100644
> > --- a/gcc/c-family/c-common.h
> > +++ b/gcc/c-family/c-common.h
> > @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
> >   extern tree (*make_fname_decl) (location_t, tree, int);
> > -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> > -extern void c_register_addr_space (const char *str, addr_space_t as);
> > -
> >   /* In c-common.cc.  */
> >   extern bool in_late_binary_op;
> >   extern const char *c_addr_space_name (addr_space_t as);
> > +extern const char *c_addr_space_name (addr_space_t as);
> > +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
> >   extern tree identifier_global_value (tree);
> >   extern tree identifier_global_tag (tree);
> >   extern bool names_builtin_p (const char *);
> > @@ -952,6 +951,7 @@ extern void c_common_finish (void);
> >   extern void c_common_parse_file (void);
> >   extern FILE *get_dump_info (int, dump_flags_t *);
> >   extern alias_set_type c_common_get_alias_set (tree);
> > +extern void c_register_addr_space (const char *, addr_space_t);
> >   extern void c_register_builtin_type (tree, const char*);
> >   extern bool c_promoting_integer_type_p (const_tree);
> >   extern bool self_promoting_args_p (const_tree);
> > diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> > index c701f07befe..e1bb4f1cf37 100644
> > --- a/gcc/c/c-decl.cc
> > +++ b/gcc/c/c-decl.cc
> > @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
> >     ext_block = NULL;
> >   }
> > -/* Register reserved keyword WORD as qualifier for address space AS.  */
> > -
> > -void
> > -c_register_addr_space (const char *word, addr_space_t as)
> > -{
> > -  int rid = RID_FIRST_ADDR_SPACE + as;
> > -  tree id;
> > -
> > -  /* Address space qualifiers are only supported
> > -     in C with GNU extensions enabled.  */
> > -  if (c_dialect_objc () || flag_no_asm)
> > -    return;
> > -
> > -  id = get_identifier (word);
> > -  C_SET_RID_CODE (id, rid);
> > -  C_IS_RESERVED_WORD (id) = 1;
> > -  ridpointers [rid] = id;
> > -}
> > -
> >   /* Return identifier to look up for omp declare reduction.  */
> >   tree
> > diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> > index b271af9bedb..c4b01368534 100644
> > --- a/gcc/c/c-typeck.cc
> > +++ b/gcc/c/c-typeck.cc
> > @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
> >     return type;
> >   }
> > -/* Return true if between two named address spaces, whether there is a superset
> > -   named address space that encompasses both address spaces.  If there is a
> > -   superset, return which address space is the superset.  */
> > -
> > -static bool
> > -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> > -{
> > -  if (as1 == as2)
> > -    {
> > -      *common = as1;
> > -      return true;
> > -    }
> > -  else if (targetm.addr_space.subset_p (as1, as2))
> > -    {
> > -      *common = as2;
> > -      return true;
> > -    }
> > -  else if (targetm.addr_space.subset_p (as2, as1))
> > -    {
> > -      *common = as1;
> > -      return true;
> > -    }
> > -  else
> > -    return false;
> > -}
> > -
> >   /* Return a variant of TYPE which has all the type qualifiers of LIKE
> >      as well as those of TYPE.  */
> > diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> > index 72f4398a8f9..82a6d72f5df 100644
> > --- a/gcc/cp/cp-tree.h
> > +++ b/gcc/cp/cp-tree.h
> > @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
> >     ds_const,
> >     ds_volatile,
> >     ds_restrict,
> > +  ds_addr_space,
> >     ds_inline,
> >     ds_virtual,
> >     ds_explicit,
> > @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
> >     cp_storage_class storage_class;
> >     /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
> >     int int_n_idx;
> > +  /* The address space that the declaration belongs to.  */
> > +  addr_space_t address_space;
> >     /* True iff TYPE_SPEC defines a class or enum.  */
> >     BOOL_BITFIELD type_definition_p : 1;
> >     /* True iff multiple types were (erroneously) specified for this
> > diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> > index 9f78c500a15..fa5a1ddb21d 100644
> > --- a/gcc/cp/decl.cc
> > +++ b/gcc/cp/decl.cc
> > @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
> >       type_quals |= TYPE_QUAL_VOLATILE;
> >     if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
> >       type_quals |= TYPE_QUAL_RESTRICT;
> > +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
> >     return type_quals;
> >   }
> > @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
> >   	error_at (declspecs->locations[ds_restrict],
> >   		  "%<__restrict%> can only be specified for objects and "
> >   		  "functions");
> > +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > +	error_at (declspecs->locations[ds_addr_space],
> > +		  "address space can only be specified for objects and "
> > +		  "functions");
> >         else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
> >   	error_at (declspecs->locations[ds_thread],
> >   		  "%<__thread%> can only be specified for objects "
> > @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
> >       if (!processing_template_decl)
> >         cp_apply_type_quals_to_decl (type_quals, decl);
> > +    addr_space_t address_space = declspecs->address_space;
> > +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
> > +      {
> > +	if (decl_context == NORMAL)
> > +	  {
> > +	    switch (storage_class)
> > +	      {
> > +	      case sc_auto:
> > +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
> > +		       c_addr_space_name (address_space), name);
> > +		break;
> > +	      case sc_register:
> > +		error ("%qs combined with %<register%> qualifier for %qs",
> > +		       c_addr_space_name (address_space), name);
> > +		break;
> > +	      case sc_none:
> > +		if (! toplevel_bindings_p ())
> > +		  error ("%qs specified for auto variable %qs",
> > +			 c_addr_space_name (address_space), name);
> > +		break;
> > +	      case sc_mutable:
> > +		error ("%qs combined with %<mutable%> qualifier for %qs",
> > +		       c_addr_space_name (address_space), name);
> > +		break;
> > +	      case sc_static:
> > +	      case sc_extern:
> > +		break;
> > +	      default:
> > +		gcc_unreachable ();
> > +	      }
> > +	  }
> > +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
> > +	  {
> > +	    if (name)
> > +	      error ("%qs specified for parameter %qs",
> > +		     c_addr_space_name (address_space), name);
> > +	    else
> > +	      error ("%qs specified for unnamed parameter",
> > +		     c_addr_space_name (address_space));
> > +	  }
> > +	else if (decl_context == FIELD)
> > +	  {
> > +	    if (name)
> > +	      error ("%qs specified for structure field %qs",
> > +		     c_addr_space_name (address_space), name);
> > +	    else
> > +	      error ("%qs specified for structure field",
> > +		     c_addr_space_name (address_space));
> > +	  }
> > +      }
> > +
> >       return decl;
> >     }
> >   }
> > diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> > index eb53e0ebeb4..16cb2ff4332 100644
> > --- a/gcc/cp/mangle.cc
> > +++ b/gcc/cp/mangle.cc
> > @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
> >        array.  */
> >     cp_cv_quals quals = TYPE_QUALS (type);
> > +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
> > +    {
> > +      const char *as_name = c_addr_space_name (as);
> > +      write_char ('U');
> > +      write_unsigned_number (strlen (as_name));
> > +      write_string (as_name);
> > +      ++num_qualifiers;
> > +    }
> >     if (quals & TYPE_QUAL_RESTRICT)
> >       {
> >         write_char ('r');
> > diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> > index 763df6f479b..f0169d83ab0 100644
> > --- a/gcc/cp/parser.cc
> > +++ b/gcc/cp/parser.cc
> > @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
> >   		    postfix_expression = error_mark_node;
> >   		    break;
> >   		  }
> > +		if (type != error_mark_node
> > +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> > +		    && current_function_decl)
> > +		  {
> > +		    error
> > +		      ("compound literal qualified by address-space qualifier");
> > +		    type = error_mark_node;
> > +		  }
> >   		/* Form the representation of the compound-literal.  */
> >   		postfix_expression
> >   		  = finish_compound_literal (type, initializer,
> > @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
> >         break;
> >       }
> > +
> > +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> > +    {
> > +      ds = ds_addr_space;
> > +      if (is_cv_qualifier)
> > +	*is_cv_qualifier = true;
> > +    }
> > +
> > +
> >     /* Handle simple keywords.  */
> >     if (ds != ds_last)
> >       {
> > @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
> >      GNU Extension:
> >      cv-qualifier:
> > +     address-space-qualifier
> >        __restrict__
> >      Returns a bitmask representing the cv-qualifiers.  */
> > @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
> >   	  break;
> >   	}
> > +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> > +	  token->keyword <= RID_LAST_ADDR_SPACE)
> > +	cv_qualifier =
> > +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> > +
> >         if (!cv_qualifier)
> >   	break;
> > @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> >         decl_specs->locations[ds] = location;
> >         if (ds == ds_thread)
> >   	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> > +      else if (ds == ds_addr_space)
> > +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
> >       }
> >     else
> >       {
> > @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> >   	      error_at (&richloc, "duplicate %qD", token->u.value);
> >   	    }
> >   	}
> > +      else if (ds == ds_addr_space)
> > +	{
> > +	  addr_space_t as1 = decl_specs->address_space;
> > +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> > +
> > +	  gcc_rich_location richloc (location);
> > +	  richloc.add_fixit_remove ();
> > +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> > +	      && as1 != as2)
> > +	    error_at (&richloc,
> > +		      "conflicting named address spaces (%s vs %s)",
> > +		      c_addr_space_name (as1), c_addr_space_name (as2));
> > +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> > +	    error_at (&richloc,
> > +		      "duplicate named address space %s",
> > +		      c_addr_space_name (as1));
> > +
> > +	  decl_specs->address_space = as2;
> > +	}
> >         else
> >   	{
> >   	  static const char *const decl_spec_names[] = {
> > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> > index bef31416fb7..c9d1c01f4ce 100644
> > --- a/gcc/cp/pt.cc
> > +++ b/gcc/cp/pt.cc
> > @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
> >   static int
> >   check_cv_quals_for_unify (int strict, tree arg, tree parm)
> >   {
> > -  int arg_quals = cp_type_quals (arg);
> > -  int parm_quals = cp_type_quals (parm);
> > +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > +
> > +  /*  Try to unify ARG's address space into PARM's address space.
> > +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
> > +      there are no constraints on address spaces for this type.  */
> > +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > +  addr_space_t as_common;
> > +  addr_space_superset (as_arg, as_parm, &as_common);
> > +
> > +  if (!(as_parm == as_common || as_parm == 0))
> > +    return 0;
> >     if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
> >         && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
> > @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
> >   					 arg, parm))
> >   	    return unify_cv_qual_mismatch (explain_p, parm, arg);
> > +	  int arg_cv_quals = cp_type_quals (arg);
> > +	  int parm_cv_quals = cp_type_quals (parm);
> > +
> > +	  /* If PARM does not contain any address space constraints it can
> > +	     fully match the address space of ARG.  However, if PARM contains an
> > +	     address space constraint, it becomes the upper bound.  That is,
> > +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
> > +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
> > +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
> > +	     AS_PARM.  */
> > +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
> > +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
> > +	  addr_space_t as_common = as_parm ? 0 : as_arg;
> > +
> >   	  /* Consider the case where ARG is `const volatile int' and
> >   	     PARM is `const T'.  Then, T should be `volatile int'.  */
> > -	  arg = cp_build_qualified_type_real
> > -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
> > +	  int unified_cv =
> > +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> > +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> > +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
> >   	  if (arg == error_mark_node)
> >   	    return unify_invalid (explain_p);
> > diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> > index 3b37567cbd7..5e14ac837fc 100644
> > --- a/gcc/cp/tree.cc
> > +++ b/gcc/cp/tree.cc
> > @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
> >       DECL_CHAIN (t) = NULL_TREE;
> >   }
> > -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> > -   FIXME: If address space support is target specific, then this
> > -   should be a C target hook.  But currently this is not possible,
> > -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> > -void
> > -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> > -{
> > -}
> > -
> >   /* Return the number of operands in T that we care about for things like
> >      mangling.  */
> > diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> > index ceb80d9744f..7d810c6a12c 100644
> > --- a/gcc/cp/typeck.cc
> > +++ b/gcc/cp/typeck.cc
> > @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
> >   	  else
> >   	    return error_mark_node;
> >           }
> > +      /* If possible merge the address space into the superset of the address
> > +	  spaces of t1 and t2, or raise an error. */
> > +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> > +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> > +      addr_space_t as_common;
> > +
> > +      /* If the two named address spaces are different, determine the common
> > +	 superset address space.  If there isn't one, raise an error.  */
> > +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> > +	{
> > +	  as_common = as_t1;
> > +	  error_at (location,
> > +		    "%qT and %qT are in disjoint named address spaces",
> > +		    t1, t2);
> > +	}
> >         result_type
> >   	= cp_build_qualified_type (void_type_node,
> > -				   (cp_type_quals (TREE_TYPE (t1))
> > -				    | cp_type_quals (TREE_TYPE (t2))));
> > +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> > +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> > +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
> >         result_type = build_pointer_type (result_type);
> >         /* Merge the attributes.  */
> >         attributes = (*targetm.merge_type_attributes) (t1, t2);
> > @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
> >   }
> >   /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
> > -   top-level qualifiers.  */
> > +   top-level qualifiers, except for named address spaces.  If the pointers point
> > +   to different named addresses spaces, then we must determine if one address
> > +   space is a subset of the other.  */
> >   bool
> >   same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> > @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> >     if (type1 == type2)
> >       return true;
> > +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
> > +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
> > +  addr_space_t as_common;
> > +
> > +  /* Fail if pointers point to incompatible address spaces.  */
> > +  if (!addr_space_superset (as_type1, as_type2, &as_common))
> > +    return false;
> > +
> >     type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
> >     type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
> >     return same_type_p (type1, type2);
> > @@ -6374,10 +6400,32 @@ static tree
> >   pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
> >   	      tsubst_flags_t complain, tree *instrument_expr)
> >   {
> > -  tree result, inttype;
> >     tree restype = ptrdiff_type_node;
> > +  tree result, inttype;
> > +
> > +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
> > +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
> >     tree target_type = TREE_TYPE (ptrtype);
> > +  /* If the operands point into different address spaces, we need to
> > +     explicitly convert them to pointers into the common address space
> > +     before we can subtract the numerical address values.  */
> > +  if (as0 != as1)
> > +    {
> > +      addr_space_t as_common;
> > +      tree common_type;
> > +
> > +      /* Determine the common superset address space.  This is guaranteed
> > +	 to exist because the caller verified that comp_target_types
> > +	 returned non-zero.  */
> > +      if (!addr_space_superset (as0, as1, &as_common))
> > +	gcc_unreachable ();
> > +
> > +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
> > +      op0 = convert (common_type, op0);
> > +      op1 = convert (common_type, op1);
> > +    }
> > +
> >     if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
> >       return error_mark_node;
> > @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
> >   	      to_more_cv_qualified = true;
> >   	    }
> > +      /* Warn about conversions between pointers to disjoint
> > +	 address spaces.  */
> > +      if (TREE_CODE (from) == POINTER_TYPE
> > +	  && TREE_CODE (to) == POINTER_TYPE)
> > +	{
> > +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> > +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> > +	  addr_space_t as_common;
> > +
> > +	  if (!addr_space_superset (as_to, as_from, &as_common))
> > +	    return false;
> > +	}
> > +
> >   	  if (constp > 0)
> >   	    constp &= TYPE_READONLY (to);
> >   	}
> > diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> > index ac3db88566d..1e0d436c02c 100644
> > --- a/gcc/doc/extend.texi
> > +++ b/gcc/doc/extend.texi
> > @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
> >   @section Named Address Spaces
> >   @cindex Named Address Spaces
> > -As an extension, GNU C supports named address spaces as
> > +As an extension, GNU C and GNU C++ support named address spaces as
> >   defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
> >   address spaces in GCC will evolve as the draft technical report
> >   changes.  Calling conventions for any target might also change.  At
> > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > new file mode 100644
> > index 00000000000..c01f8d6054a
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > @@ -0,0 +1,10 @@
> > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> > +
> > +int f (int volatile __seg_fs *a)
> > +{
> > +  return *a;
> > +}
> > +
> > +int main () {}
> > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > new file mode 100644
> > index 00000000000..862bbbdcdf2
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > @@ -0,0 +1,9 @@
> > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
> > +
> > +template <class T>
> > +int f (T *p) { return *p; }
> > +int g (__seg_fs int *p) { return *p; }
> > +__seg_fs int *a;
> > +int main() { f(a); }
> > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > new file mode 100644
> > index 00000000000..c04d2f497da
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > @@ -0,0 +1,5 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +__seg_fs char a, b, c;
> > +__seg_fs const int *p;
> > +static /* give internal linkage to the following anonymous struct */
> > +__seg_fs struct { int a; char b; } * __seg_gs q;
> > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > new file mode 100644
> > index 00000000000..86c02d1e7f5
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > @@ -0,0 +1,20 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +int __seg_fs * fs1;
> > +int __seg_fs * fs2;
> > +float __seg_gs * gs1;
> > +float __seg_gs * gs2;
> > +
> > +int
> > +main ()
> > +{
> > +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
> > +  fs1 - fs2;
> > +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
> > +  fs1 == fs2;
> > +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > +  fs1 = fs2;
> > +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
> > +  fs1 > fs2;
> > +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > +  return 0;
> > +}
> > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > new file mode 100644
> > index 00000000000..12d7975e560
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > @@ -0,0 +1,31 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +// { dg-prune-output "does not allow .register. storage class specifier" }
> > +int __seg_fs * outer_b;
> > +
> > +struct s {
> > +  __seg_fs int * ok;
> > +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
> > +};
> > +
> > +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
> > +
> > +namespace ns_a
> > +{
> > +  int __seg_fs * inner_b;
> > +
> > +  template<typename T>
> > +  int f (T &a) { return a; }
> > +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
> > +  int h (__seg_fs int *a) { return *a; }
> > +}
> > +
> > +int
> > +main ()
> > +{
> > +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
> > +  static __seg_gs int static_gs;
> > +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
> > +  __seg_fs int *pa = outer_b;
> > +  __seg_fs int& ra = *ns_a::inner_b;
> > +  return ns_a::f(ra) + ns_a::f(*pa);
> > +}
> > diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> > new file mode 100644
> > index 00000000000..ebb6316054a
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> > @@ -0,0 +1,9 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +
> > +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> > +
> > +int
> > +main ()
> > +{
> > +	return 0;
> > +}
> > diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > new file mode 100644
> > index 00000000000..2e8ee32a885
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > @@ -0,0 +1,10 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +// { dg-options "-std=gnu++98" }
> > +
> > +int
> > +main ()
> > +{
> > +	struct foo {int a; char b[2];} structure;
> > +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> > +	return 0;
> > +}
> > diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > new file mode 100644
> > index 00000000000..5b2c0f28078
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > @@ -0,0 +1,9 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +
> > +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> > +
> > +int
> > +main ()
> > +{
> > +	return 0;
> > +}
> > diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > new file mode 100644
> > index 00000000000..ae9f4de0e1f
> > --- /dev/null
> > +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > @@ -0,0 +1,8 @@
> > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > +
> > +template <class T>
> > +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
> > +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
> > +__seg_fs int *a;
> > +int main() { f(a); } // { dg-error "no matching" }
> > +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
> > diff --git a/gcc/tree.h b/gcc/tree.h
> > index 8844471e9a5..b7da4c5141a 100644
> > --- a/gcc/tree.h
> > +++ b/gcc/tree.h
> > @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
> >   /* Encode/decode the named memory support as part of the qualifier.  If more
> >      than 8 qualifiers are added, these macros need to be adjusted.  */
> > -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> > +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
> >   #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
> >   /* Return all qualifiers except for the address space qualifiers.  */
> > 
> > 
> > 
> > 
> 
> 
> 
> 
> 
> 
>
  

On 10/13/22 11:23, Paul Iannetta wrote:
> On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
>> On 10/12/22 20:52, Paul Iannetta wrote:
>>> On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
>>>>
>>>> It surprises that this is the only place we complain about an object with an
>>>> address-space qualifier.  Shouldn't we also complain about e.g. automatic
>>>> variables/parameters or non-static data members with address-space qualified
>>>> type?
>>>>
>>>
>>> Indeed, I was missing quite a few things here.  Thanks.
>>> I used the draft as basis this time and imported from the C
>>> implementation the relevant parts.  This time, the errors get properly
>>> emitted when an address space is unduly specified; and comparisons,
>>> assignments and comparisons are taken care of.
>>>
>>> There are quite a few things I would like to clarify concerning some
>>> implementation details.
>>>     - A variable with automatic storage (which is neither a pointer nor
>>>       a reference) cannot be qualified with an address space.  I detect
>>>       this by the combination of `sc_none' and `! toplevel_bindings_p ()',
>>>       but I've also seen the use of `at_function_scope' at other places.
>>>       And I'm unsure which one is appropriate here.
>>>       This detection happens at the very end of grokdeclarator because I
>>>       need to know that the type is a pointer, which is not know until
>>>       very late in the function.
>>
>> At that point you have the decl, and you can ask directly what its storage
>> duration is, perhaps using decl_storage_duration.
>>
>> But why do you need to know whether the type is a pointer?  The attribute
>> applies to the target type of the pointer, not the pointer type.  I think
>> the problem is that you're looking at declspecs when you ought to be looking
>> at type_quals.
> 
> I need to know that the base type is a pointer to reject invalid
> declarations such as:
> 
>      int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }
> 
> because parameters and auto variables can have an address space
> qualifier only if they are pointer or reference type, which I can't
> tell only from type_quals.

But "int *__seg_fs a" is just as invalid as the above; the difference is 
not whether a is a pointer, but whether the address-space-qualified is 
the type of a itself or some sub-type.

You need to look at the qualifiers on type (which should also be the 
ones in type_quals), not the qualifiers in the declspecs.

>>>     - I'm having some trouble deciding whether I include those three
>>>       stub programs as tests, they all compile fine and clang accepts
>>>       them as well.
>>
>> Why not?
> 
> I thought they were pretty contrived, since it does not make much
> sense to strip address space qualifiers, even though it does prove
> that the implementation support those contrived but valid uses.

Testcases are full of contrived examples testing corner cases.  :)

>>
>>> Ex1:
>>> ```
>>> int __seg_fs * fs1;
>>> int __seg_gs * gs1;
>>>
>>> template<typename T> struct strip;
>>> template<typename T> struct strip<__seg_fs T *> { typedef T type; };
>>> template<typename T> struct strip<__seg_gs T *> { typedef T type; };
>>>
>>> int
>>> main ()
>>> {
>>>       *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
>>>       return 0;
>>> }
>>> ```
>>>
>>> Ex2:
>>> ```
>>> int __seg_fs * fs1;
>>> int __seg_fs * fs2;
>>>
>>> template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
>>> template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
>>>
>>> int
>>> main ()
>>> {
>>>       f (fs1, gs1);
>>>       f (gs1, fs1);
>>>       return 0;
>>> }
>>> ```
>>>
>>> Ex3:
>>> ```
>>> int __seg_fs * fs1;
>>> int __seg_gs * gs1;
>>>
>>> template<typename T, typename U>
>>> auto f (T __seg_fs * a, U __seg_gs * b)
>>> {
>>>       return *(T *) a == *(U *) b;
>>> }
>>>
>>> int
>>> main ()
>>> {
>>>       return f (fs1, gs1);
>>> }
>>> ```
>>>
>>>
>>> Add support for custom address spaces in C++
>>>
>>> gcc/
>>>           * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
>>>
>>> gcc/c/
>>>           * c-decl.cc: Remove c_register_addr_space.
>>>
>>> gcc/c-family/
>>>           * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>>>           (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>>>           * c-common.h: Remove the FIXME.
>>>           (addr_space_superset): New declaration.
>>>
>>> gcc/cp/
>>>           * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>>>           (struct cp_decl_specifier_seq): Likewise.
>>>           * decl.cc (get_type_quals): Likewise.
>>>           (check_tag_decl): Likewise.
>>> 	(grokdeclarator): Likewise.
>>>           * parser.cc (cp_parser_type_specifier): Likewise.
>>>           (cp_parser_cv_qualifier_seq_opt): Likewise.
>>>           (cp_parser_postfix_expression): Likewise.
>>>           (cp_parser_type_specifier): Likewise.
>>>           (set_and_check_decl_spec_loc): Likewise.
>>>           * typeck.cc (composite_pointer_type): Likewise
>>>           (comp_ptr_ttypes_real): Likewise.
>>> 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
>>>           * pt.cc (check_cv_quals_for_unify): Likewise.
>>>           (unify): Likewise.
>>>           * tree.cc: Remove c_register_addr_space stub.
>>>           * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>>>             using the extended qualifier notation.
>>>
>>> gcc/doc
>>>           * extend.texi (Named Address Spaces): add a mention about C++
>>>             support.
>>>
>>> gcc/testsuite/
>>>           * g++.dg/abi/mangle-addr-space1.C: New test.
>>>           * g++.dg/abi/mangle-addr-space2.C: New test.
>>>           * g++.dg/parse/addr-space.C: New test.
>>>           * g++.dg/parse/addr-space1.C: New test.
>>>           * g++.dg/parse/addr-space2.C: New test.
>>>           * g++.dg/parse/template/spec-addr-space.C: New test.
>>>           * g++.dg/ext/addr-space-decl.C: New test.
>>>           * g++.dg/ext/addr-space-ref.C: New test.
>>>           * g++.dg/ext/addr-space-ops.C: New test.
>>>
>>> # Please enter the commit message for your changes. Lines starting
>>> # with '#' will be ignored, and an empty message aborts the commit.
>>> #
>>> # Date:      Sun Oct 9 16:02:22 2022 +0200
>>> #
>>> # On branch releases/gcc-12
>>> # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
>>> #   (use "git push" to publish your local commits)
>>> #
>>> # Changes to be committed:
>>> #	modified:   gcc/c-family/c-common.cc
>>> #	modified:   gcc/c-family/c-common.h
>>> #	modified:   gcc/c/c-decl.cc
>>> #	modified:   gcc/c/c-typeck.cc
>>> #	modified:   gcc/cp/cp-tree.h
>>> #	modified:   gcc/cp/decl.cc
>>> #	modified:   gcc/cp/mangle.cc
>>> #	modified:   gcc/cp/parser.cc
>>> #	modified:   gcc/cp/pt.cc
>>> #	modified:   gcc/cp/tree.cc
>>> #	modified:   gcc/cp/typeck.cc
>>> #	modified:   gcc/doc/extend.texi
>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
>>> #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
>>> #	modified:   gcc/tree.h
>>> #
>>> # Untracked files:
>>> #	Makefile
>>> #	addr-space-decl.C
>>> #	addr-space-decl.s
>>> #	addr-space-ops.C
>>> #	addr-space-ref.C
>>> #	addr-space-template.C
>>> #	addr-space-template.s
>>> #	addr-space-template2.C
>>> #	addr-space-template2.C.006t.gimple
>>> #	addr-space-template2.s
>>> #	addr-space-traits.C
>>> #	addr-space4.C
>>> #	addr-space4.C.006t.gimple
>>> #	addr-space4.s
>>> #	build-x86_64-pc-linux-gnu/
>>> #	compare
>>> #	host-x86_64-pc-linux-gnu/
>>> #	mangle-addr-space1.s
>>> #	prev-x86_64-pc-linux-gnu/
>>> #	rename
>>> #	stage1-x86_64-pc-linux-gnu/
>>> #	stage_current
>>> #	stage_final
>>> #	stage_last
>>> #	x86_64-pc-linux-gnu/
>>> #
>>> # ------------------------ >8 ------------------------
>>> # Do not modify or remove the line above.
>>> # Everything below it will be ignored.
>>> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
>>> index bb0544eeaea..ff1146ecc25 100644
>>> --- a/gcc/c-family/c-common.cc
>>> +++ b/gcc/c-family/c-common.cc
>>> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>>>      return IDENTIFIER_POINTER (ridpointers [rid]);
>>>    }
>>> +/* Return true if between two named address spaces, whether there is a superset
>>> +   named address space that encompasses both address spaces.  If there is a
>>> +   superset, return which address space is the superset.  */
>>> +
>>> +bool
>>> +addr_space_superset (addr_space_t as1, addr_space_t as2,
>>> +		     addr_space_t * common)
>>> +{
>>> +  if (as1 == as2)
>>> +    {
>>> +      *common = as1;
>>> +      return true;
>>> +    }
>>> +  else if (targetm.addr_space.subset_p (as1, as2))
>>> +    {
>>> +      *common = as2;
>>> +      return true;
>>> +    }
>>> +  else if (targetm.addr_space.subset_p (as2, as1))
>>> +    {
>>> +      *common = as1;
>>> +      return true;
>>> +    }
>>> +  else
>>> +    return false;
>>> +}
>>> +
>>>    /* Push current bindings for the function name VAR_DECLS.  */
>>>    void
>>> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>>>      return build_nonstandard_integer_type (width, unsignedp);
>>>    }
>>> +/* Register reserved keyword WORD as qualifier for address space AS.  */
>>> +
>>> +void
>>> +c_register_addr_space (const char *word, addr_space_t as)
>>> +{
>>> +  int rid = RID_FIRST_ADDR_SPACE + as;
>>> +  tree id;
>>> +
>>> +  /* Address space qualifiers are only supported
>>> +     in C with GNU extensions enabled.  */
>>> +  if (c_dialect_objc () || flag_no_asm)
>>> +    return;
>>> +
>>> +  id = get_identifier (word);
>>> +  C_SET_RID_CODE (id, rid);
>>> +  TREE_LANG_FLAG_0 (id) = 1;
>>> +  ridpointers[rid] = id;
>>> +}
>>> +
>>>    /* The C version of the register_builtin_type langhook.  */
>>>    void
>>> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
>>> index 52a85bfb783..d36f9e4975b 100644
>>> --- a/gcc/c-family/c-common.h
>>> +++ b/gcc/c-family/c-common.h
>>> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>>>    extern tree (*make_fname_decl) (location_t, tree, int);
>>> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
>>> -extern void c_register_addr_space (const char *str, addr_space_t as);
>>> -
>>>    /* In c-common.cc.  */
>>>    extern bool in_late_binary_op;
>>>    extern const char *c_addr_space_name (addr_space_t as);
>>> +extern const char *c_addr_space_name (addr_space_t as);
>>> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>>>    extern tree identifier_global_value (tree);
>>>    extern tree identifier_global_tag (tree);
>>>    extern bool names_builtin_p (const char *);
>>> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>>>    extern void c_common_parse_file (void);
>>>    extern FILE *get_dump_info (int, dump_flags_t *);
>>>    extern alias_set_type c_common_get_alias_set (tree);
>>> +extern void c_register_addr_space (const char *, addr_space_t);
>>>    extern void c_register_builtin_type (tree, const char*);
>>>    extern bool c_promoting_integer_type_p (const_tree);
>>>    extern bool self_promoting_args_p (const_tree);
>>> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
>>> index c701f07befe..e1bb4f1cf37 100644
>>> --- a/gcc/c/c-decl.cc
>>> +++ b/gcc/c/c-decl.cc
>>> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>>>      ext_block = NULL;
>>>    }
>>> -/* Register reserved keyword WORD as qualifier for address space AS.  */
>>> -
>>> -void
>>> -c_register_addr_space (const char *word, addr_space_t as)
>>> -{
>>> -  int rid = RID_FIRST_ADDR_SPACE + as;
>>> -  tree id;
>>> -
>>> -  /* Address space qualifiers are only supported
>>> -     in C with GNU extensions enabled.  */
>>> -  if (c_dialect_objc () || flag_no_asm)
>>> -    return;
>>> -
>>> -  id = get_identifier (word);
>>> -  C_SET_RID_CODE (id, rid);
>>> -  C_IS_RESERVED_WORD (id) = 1;
>>> -  ridpointers [rid] = id;
>>> -}
>>> -
>>>    /* Return identifier to look up for omp declare reduction.  */
>>>    tree
>>> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
>>> index b271af9bedb..c4b01368534 100644
>>> --- a/gcc/c/c-typeck.cc
>>> +++ b/gcc/c/c-typeck.cc
>>> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>>>      return type;
>>>    }
>>> -/* Return true if between two named address spaces, whether there is a superset
>>> -   named address space that encompasses both address spaces.  If there is a
>>> -   superset, return which address space is the superset.  */
>>> -
>>> -static bool
>>> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
>>> -{
>>> -  if (as1 == as2)
>>> -    {
>>> -      *common = as1;
>>> -      return true;
>>> -    }
>>> -  else if (targetm.addr_space.subset_p (as1, as2))
>>> -    {
>>> -      *common = as2;
>>> -      return true;
>>> -    }
>>> -  else if (targetm.addr_space.subset_p (as2, as1))
>>> -    {
>>> -      *common = as1;
>>> -      return true;
>>> -    }
>>> -  else
>>> -    return false;
>>> -}
>>> -
>>>    /* Return a variant of TYPE which has all the type qualifiers of LIKE
>>>       as well as those of TYPE.  */
>>> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
>>> index 72f4398a8f9..82a6d72f5df 100644
>>> --- a/gcc/cp/cp-tree.h
>>> +++ b/gcc/cp/cp-tree.h
>>> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>>>      ds_const,
>>>      ds_volatile,
>>>      ds_restrict,
>>> +  ds_addr_space,
>>>      ds_inline,
>>>      ds_virtual,
>>>      ds_explicit,
>>> @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
>>>      cp_storage_class storage_class;
>>>      /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>>>      int int_n_idx;
>>> +  /* The address space that the declaration belongs to.  */
>>> +  addr_space_t address_space;
>>>      /* True iff TYPE_SPEC defines a class or enum.  */
>>>      BOOL_BITFIELD type_definition_p : 1;
>>>      /* True iff multiple types were (erroneously) specified for this
>>> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
>>> index 9f78c500a15..fa5a1ddb21d 100644
>>> --- a/gcc/cp/decl.cc
>>> +++ b/gcc/cp/decl.cc
>>> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>>>        type_quals |= TYPE_QUAL_VOLATILE;
>>>      if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>>>        type_quals |= TYPE_QUAL_RESTRICT;
>>> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>>>      return type_quals;
>>>    }
>>> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>>>    	error_at (declspecs->locations[ds_restrict],
>>>    		  "%<__restrict%> can only be specified for objects and "
>>>    		  "functions");
>>> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>> +	error_at (declspecs->locations[ds_addr_space],
>>> +		  "address space can only be specified for objects and "
>>> +		  "functions");
>>>          else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>>>    	error_at (declspecs->locations[ds_thread],
>>>    		  "%<__thread%> can only be specified for objects "
>>> @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
>>>        if (!processing_template_decl)
>>>          cp_apply_type_quals_to_decl (type_quals, decl);
>>> +    addr_space_t address_space = declspecs->address_space;
>>> +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
>>> +      {
>>> +	if (decl_context == NORMAL)
>>> +	  {
>>> +	    switch (storage_class)
>>> +	      {
>>> +	      case sc_auto:
>>> +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
>>> +		       c_addr_space_name (address_space), name);
>>> +		break;
>>> +	      case sc_register:
>>> +		error ("%qs combined with %<register%> qualifier for %qs",
>>> +		       c_addr_space_name (address_space), name);
>>> +		break;
>>> +	      case sc_none:
>>> +		if (! toplevel_bindings_p ())
>>> +		  error ("%qs specified for auto variable %qs",
>>> +			 c_addr_space_name (address_space), name);
>>> +		break;
>>> +	      case sc_mutable:
>>> +		error ("%qs combined with %<mutable%> qualifier for %qs",
>>> +		       c_addr_space_name (address_space), name);
>>> +		break;
>>> +	      case sc_static:
>>> +	      case sc_extern:
>>> +		break;
>>> +	      default:
>>> +		gcc_unreachable ();
>>> +	      }
>>> +	  }
>>> +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
>>> +	  {
>>> +	    if (name)
>>> +	      error ("%qs specified for parameter %qs",
>>> +		     c_addr_space_name (address_space), name);
>>> +	    else
>>> +	      error ("%qs specified for unnamed parameter",
>>> +		     c_addr_space_name (address_space));
>>> +	  }
>>> +	else if (decl_context == FIELD)
>>> +	  {
>>> +	    if (name)
>>> +	      error ("%qs specified for structure field %qs",
>>> +		     c_addr_space_name (address_space), name);
>>> +	    else
>>> +	      error ("%qs specified for structure field",
>>> +		     c_addr_space_name (address_space));
>>> +	  }
>>> +      }
>>> +
>>>        return decl;
>>>      }
>>>    }
>>> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
>>> index eb53e0ebeb4..16cb2ff4332 100644
>>> --- a/gcc/cp/mangle.cc
>>> +++ b/gcc/cp/mangle.cc
>>> @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
>>>         array.  */
>>>      cp_cv_quals quals = TYPE_QUALS (type);
>>> +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
>>> +    {
>>> +      const char *as_name = c_addr_space_name (as);
>>> +      write_char ('U');
>>> +      write_unsigned_number (strlen (as_name));
>>> +      write_string (as_name);
>>> +      ++num_qualifiers;
>>> +    }
>>>      if (quals & TYPE_QUAL_RESTRICT)
>>>        {
>>>          write_char ('r');
>>> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
>>> index 763df6f479b..f0169d83ab0 100644
>>> --- a/gcc/cp/parser.cc
>>> +++ b/gcc/cp/parser.cc
>>> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>>>    		    postfix_expression = error_mark_node;
>>>    		    break;
>>>    		  }
>>> +		if (type != error_mark_node
>>> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
>>> +		    && current_function_decl)
>>> +		  {
>>> +		    error
>>> +		      ("compound literal qualified by address-space qualifier");
>>> +		    type = error_mark_node;
>>> +		  }
>>>    		/* Form the representation of the compound-literal.  */
>>>    		postfix_expression
>>>    		  = finish_compound_literal (type, initializer,
>>> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>>>          break;
>>>        }
>>> +
>>> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
>>> +    {
>>> +      ds = ds_addr_space;
>>> +      if (is_cv_qualifier)
>>> +	*is_cv_qualifier = true;
>>> +    }
>>> +
>>> +
>>>      /* Handle simple keywords.  */
>>>      if (ds != ds_last)
>>>        {
>>> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>>>       GNU Extension:
>>>       cv-qualifier:
>>> +     address-space-qualifier
>>>         __restrict__
>>>       Returns a bitmask representing the cv-qualifiers.  */
>>> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>>>    	  break;
>>>    	}
>>> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
>>> +	  token->keyword <= RID_LAST_ADDR_SPACE)
>>> +	cv_qualifier =
>>> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
>>> +
>>>          if (!cv_qualifier)
>>>    	break;
>>> @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>          decl_specs->locations[ds] = location;
>>>          if (ds == ds_thread)
>>>    	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
>>> +      else if (ds == ds_addr_space)
>>> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>>>        }
>>>      else
>>>        {
>>> @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>    	      error_at (&richloc, "duplicate %qD", token->u.value);
>>>    	    }
>>>    	}
>>> +      else if (ds == ds_addr_space)
>>> +	{
>>> +	  addr_space_t as1 = decl_specs->address_space;
>>> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
>>> +
>>> +	  gcc_rich_location richloc (location);
>>> +	  richloc.add_fixit_remove ();
>>> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
>>> +	      && as1 != as2)
>>> +	    error_at (&richloc,
>>> +		      "conflicting named address spaces (%s vs %s)",
>>> +		      c_addr_space_name (as1), c_addr_space_name (as2));
>>> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
>>> +	    error_at (&richloc,
>>> +		      "duplicate named address space %s",
>>> +		      c_addr_space_name (as1));
>>> +
>>> +	  decl_specs->address_space = as2;
>>> +	}
>>>          else
>>>    	{
>>>    	  static const char *const decl_spec_names[] = {
>>> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
>>> index bef31416fb7..c9d1c01f4ce 100644
>>> --- a/gcc/cp/pt.cc
>>> +++ b/gcc/cp/pt.cc
>>> @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
>>>    static int
>>>    check_cv_quals_for_unify (int strict, tree arg, tree parm)
>>>    {
>>> -  int arg_quals = cp_type_quals (arg);
>>> -  int parm_quals = cp_type_quals (parm);
>>> +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>> +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>> +
>>> +  /*  Try to unify ARG's address space into PARM's address space.
>>> +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
>>> +      there are no constraints on address spaces for this type.  */
>>> +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>> +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>> +  addr_space_t as_common;
>>> +  addr_space_superset (as_arg, as_parm, &as_common);
>>> +
>>> +  if (!(as_parm == as_common || as_parm == 0))
>>> +    return 0;
>>>      if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
>>>          && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
>>> @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
>>>    					 arg, parm))
>>>    	    return unify_cv_qual_mismatch (explain_p, parm, arg);
>>> +	  int arg_cv_quals = cp_type_quals (arg);
>>> +	  int parm_cv_quals = cp_type_quals (parm);
>>> +
>>> +	  /* If PARM does not contain any address space constraints it can
>>> +	     fully match the address space of ARG.  However, if PARM contains an
>>> +	     address space constraint, it becomes the upper bound.  That is,
>>> +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
>>> +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
>>> +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
>>> +	     AS_PARM.  */
>>> +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
>>> +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
>>> +	  addr_space_t as_common = as_parm ? 0 : as_arg;
>>> +
>>>    	  /* Consider the case where ARG is `const volatile int' and
>>>    	     PARM is `const T'.  Then, T should be `volatile int'.  */
>>> -	  arg = cp_build_qualified_type_real
>>> -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
>>> +	  int unified_cv =
>>> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
>>> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
>>> +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
>>>    	  if (arg == error_mark_node)
>>>    	    return unify_invalid (explain_p);
>>> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
>>> index 3b37567cbd7..5e14ac837fc 100644
>>> --- a/gcc/cp/tree.cc
>>> +++ b/gcc/cp/tree.cc
>>> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>>>        DECL_CHAIN (t) = NULL_TREE;
>>>    }
>>> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
>>> -   FIXME: If address space support is target specific, then this
>>> -   should be a C target hook.  But currently this is not possible,
>>> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
>>> -void
>>> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
>>> -{
>>> -}
>>> -
>>>    /* Return the number of operands in T that we care about for things like
>>>       mangling.  */
>>> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
>>> index ceb80d9744f..7d810c6a12c 100644
>>> --- a/gcc/cp/typeck.cc
>>> +++ b/gcc/cp/typeck.cc
>>> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>>>    	  else
>>>    	    return error_mark_node;
>>>            }
>>> +      /* If possible merge the address space into the superset of the address
>>> +	  spaces of t1 and t2, or raise an error. */
>>> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
>>> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
>>> +      addr_space_t as_common;
>>> +
>>> +      /* If the two named address spaces are different, determine the common
>>> +	 superset address space.  If there isn't one, raise an error.  */
>>> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
>>> +	{
>>> +	  as_common = as_t1;
>>> +	  error_at (location,
>>> +		    "%qT and %qT are in disjoint named address spaces",
>>> +		    t1, t2);
>>> +	}
>>>          result_type
>>>    	= cp_build_qualified_type (void_type_node,
>>> -				   (cp_type_quals (TREE_TYPE (t1))
>>> -				    | cp_type_quals (TREE_TYPE (t2))));
>>> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
>>> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
>>> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>>>          result_type = build_pointer_type (result_type);
>>>          /* Merge the attributes.  */
>>>          attributes = (*targetm.merge_type_attributes) (t1, t2);
>>> @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
>>>    }
>>>    /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
>>> -   top-level qualifiers.  */
>>> +   top-level qualifiers, except for named address spaces.  If the pointers point
>>> +   to different named addresses spaces, then we must determine if one address
>>> +   space is a subset of the other.  */
>>>    bool
>>>    same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>> @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>>      if (type1 == type2)
>>>        return true;
>>> +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
>>> +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
>>> +  addr_space_t as_common;
>>> +
>>> +  /* Fail if pointers point to incompatible address spaces.  */
>>> +  if (!addr_space_superset (as_type1, as_type2, &as_common))
>>> +    return false;
>>> +
>>>      type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
>>>      type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
>>>      return same_type_p (type1, type2);
>>> @@ -6374,10 +6400,32 @@ static tree
>>>    pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
>>>    	      tsubst_flags_t complain, tree *instrument_expr)
>>>    {
>>> -  tree result, inttype;
>>>      tree restype = ptrdiff_type_node;
>>> +  tree result, inttype;
>>> +
>>> +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
>>> +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
>>>      tree target_type = TREE_TYPE (ptrtype);
>>> +  /* If the operands point into different address spaces, we need to
>>> +     explicitly convert them to pointers into the common address space
>>> +     before we can subtract the numerical address values.  */
>>> +  if (as0 != as1)
>>> +    {
>>> +      addr_space_t as_common;
>>> +      tree common_type;
>>> +
>>> +      /* Determine the common superset address space.  This is guaranteed
>>> +	 to exist because the caller verified that comp_target_types
>>> +	 returned non-zero.  */
>>> +      if (!addr_space_superset (as0, as1, &as_common))
>>> +	gcc_unreachable ();
>>> +
>>> +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
>>> +      op0 = convert (common_type, op0);
>>> +      op1 = convert (common_type, op1);
>>> +    }
>>> +
>>>      if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
>>>        return error_mark_node;
>>> @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>>>    	      to_more_cv_qualified = true;
>>>    	    }
>>> +      /* Warn about conversions between pointers to disjoint
>>> +	 address spaces.  */
>>> +      if (TREE_CODE (from) == POINTER_TYPE
>>> +	  && TREE_CODE (to) == POINTER_TYPE)
>>> +	{
>>> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
>>> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
>>> +	  addr_space_t as_common;
>>> +
>>> +	  if (!addr_space_superset (as_to, as_from, &as_common))
>>> +	    return false;
>>> +	}
>>> +
>>>    	  if (constp > 0)
>>>    	    constp &= TYPE_READONLY (to);
>>>    	}
>>> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
>>> index ac3db88566d..1e0d436c02c 100644
>>> --- a/gcc/doc/extend.texi
>>> +++ b/gcc/doc/extend.texi
>>> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>>>    @section Named Address Spaces
>>>    @cindex Named Address Spaces
>>> -As an extension, GNU C supports named address spaces as
>>> +As an extension, GNU C and GNU C++ support named address spaces as
>>>    defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>>>    address spaces in GCC will evolve as the draft technical report
>>>    changes.  Calling conventions for any target might also change.  At
>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>> new file mode 100644
>>> index 00000000000..c01f8d6054a
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>> @@ -0,0 +1,10 @@
>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
>>> +
>>> +int f (int volatile __seg_fs *a)
>>> +{
>>> +  return *a;
>>> +}
>>> +
>>> +int main () {}
>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>> new file mode 100644
>>> index 00000000000..862bbbdcdf2
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>> @@ -0,0 +1,9 @@
>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>> +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
>>> +
>>> +template <class T>
>>> +int f (T *p) { return *p; }
>>> +int g (__seg_fs int *p) { return *p; }
>>> +__seg_fs int *a;
>>> +int main() { f(a); }
>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>> new file mode 100644
>>> index 00000000000..c04d2f497da
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>> @@ -0,0 +1,5 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +__seg_fs char a, b, c;
>>> +__seg_fs const int *p;
>>> +static /* give internal linkage to the following anonymous struct */
>>> +__seg_fs struct { int a; char b; } * __seg_gs q;
>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>> new file mode 100644
>>> index 00000000000..86c02d1e7f5
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>> @@ -0,0 +1,20 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +int __seg_fs * fs1;
>>> +int __seg_fs * fs2;
>>> +float __seg_gs * gs1;
>>> +float __seg_gs * gs2;
>>> +
>>> +int
>>> +main ()
>>> +{
>>> +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
>>> +  fs1 - fs2;
>>> +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
>>> +  fs1 == fs2;
>>> +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>> +  fs1 = fs2;
>>> +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
>>> +  fs1 > fs2;
>>> +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>> +  return 0;
>>> +}
>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>> new file mode 100644
>>> index 00000000000..12d7975e560
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>> @@ -0,0 +1,31 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +// { dg-prune-output "does not allow .register. storage class specifier" }
>>> +int __seg_fs * outer_b;
>>> +
>>> +struct s {
>>> +  __seg_fs int * ok;
>>> +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
>>> +};
>>> +
>>> +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
>>> +
>>> +namespace ns_a
>>> +{
>>> +  int __seg_fs * inner_b;
>>> +
>>> +  template<typename T>
>>> +  int f (T &a) { return a; }
>>> +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
>>> +  int h (__seg_fs int *a) { return *a; }
>>> +}
>>> +
>>> +int
>>> +main ()
>>> +{
>>> +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
>>> +  static __seg_gs int static_gs;
>>> +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
>>> +  __seg_fs int *pa = outer_b;
>>> +  __seg_fs int& ra = *ns_a::inner_b;
>>> +  return ns_a::f(ra) + ns_a::f(*pa);
>>> +}
>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
>>> new file mode 100644
>>> index 00000000000..ebb6316054a
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
>>> @@ -0,0 +1,9 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +
>>> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
>>> +
>>> +int
>>> +main ()
>>> +{
>>> +	return 0;
>>> +}
>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>> new file mode 100644
>>> index 00000000000..2e8ee32a885
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>> @@ -0,0 +1,10 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +// { dg-options "-std=gnu++98" }
>>> +
>>> +int
>>> +main ()
>>> +{
>>> +	struct foo {int a; char b[2];} structure;
>>> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
>>> +	return 0;
>>> +}
>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>> new file mode 100644
>>> index 00000000000..5b2c0f28078
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>> @@ -0,0 +1,9 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +
>>> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
>>> +
>>> +int
>>> +main ()
>>> +{
>>> +	return 0;
>>> +}
>>> diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>> new file mode 100644
>>> index 00000000000..ae9f4de0e1f
>>> --- /dev/null
>>> +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>> @@ -0,0 +1,8 @@
>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>> +
>>> +template <class T>
>>> +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
>>> +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
>>> +__seg_fs int *a;
>>> +int main() { f(a); } // { dg-error "no matching" }
>>> +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
>>> diff --git a/gcc/tree.h b/gcc/tree.h
>>> index 8844471e9a5..b7da4c5141a 100644
>>> --- a/gcc/tree.h
>>> +++ b/gcc/tree.h
>>> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>>>    /* Encode/decode the named memory support as part of the qualifier.  If more
>>>       than 8 qualifiers are added, these macros need to be adjusted.  */
>>> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
>>> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>>>    #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>>>    /* Return all qualifiers except for the address space qualifiers.  */
>>>
>>>
>>>
>>>
>>
>>
>>
>>
>>
>>
>>
> 
> 
> 
> 
>
  

On Thu, Oct 13, 2022 at 11:47:42AM -0400, Jason Merrill wrote:
> On 10/13/22 11:23, Paul Iannetta wrote:
> > On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
> > > On 10/12/22 20:52, Paul Iannetta wrote:
> > > > On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
> > > > > 
> > > > > It surprises that this is the only place we complain about an object with an
> > > > > address-space qualifier.  Shouldn't we also complain about e.g. automatic
> > > > > variables/parameters or non-static data members with address-space qualified
> > > > > type?
> > > > > 
> > > > 
> > > > Indeed, I was missing quite a few things here.  Thanks.
> > > > I used the draft as basis this time and imported from the C
> > > > implementation the relevant parts.  This time, the errors get properly
> > > > emitted when an address space is unduly specified; and comparisons,
> > > > assignments and comparisons are taken care of.
> > > > 
> > > > There are quite a few things I would like to clarify concerning some
> > > > implementation details.
> > > >     - A variable with automatic storage (which is neither a pointer nor
> > > >       a reference) cannot be qualified with an address space.  I detect
> > > >       this by the combination of `sc_none' and `! toplevel_bindings_p ()',
> > > >       but I've also seen the use of `at_function_scope' at other places.
> > > >       And I'm unsure which one is appropriate here.
> > > >       This detection happens at the very end of grokdeclarator because I
> > > >       need to know that the type is a pointer, which is not know until
> > > >       very late in the function.
> > > 
> > > At that point you have the decl, and you can ask directly what its storage
> > > duration is, perhaps using decl_storage_duration.
> > > 
> > > But why do you need to know whether the type is a pointer?  The attribute
> > > applies to the target type of the pointer, not the pointer type.  I think
> > > the problem is that you're looking at declspecs when you ought to be looking
> > > at type_quals.
> > 
> > I need to know that the base type is a pointer to reject invalid
> > declarations such as:
> > 
> >      int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }
> > 
> > because parameters and auto variables can have an address space
> > qualifier only if they are pointer or reference type, which I can't
> > tell only from type_quals.
> 
> But "int *__seg_fs a" is just as invalid as the above; the difference is not
> whether a is a pointer, but whether the address-space-qualified is the type
> of a itself or some sub-type.

I agree that "int * __seg_fs a" is invalid but it is accepted by the C
front-end, and by clang (both C and C++), the behavior is that the
address-name is silently ignored.

> You need to look at the qualifiers on type (which should also be the ones in
> type_quals), not the qualifiers in the declspecs.

I'll have another look, thanks.

> > > >     - I'm having some trouble deciding whether I include those three
> > > >       stub programs as tests, they all compile fine and clang accepts
> > > >       them as well.
> > > 
> > > Why not?
> > 
> > I thought they were pretty contrived, since it does not make much
> > sense to strip address space qualifiers, even though it does prove
> > that the implementation support those contrived but valid uses.
> 
> Testcases are full of contrived examples testing corner cases.  :)
> 
> > > 
> > > > Ex1:
> > > > ```
> > > > int __seg_fs * fs1;
> > > > int __seg_gs * gs1;
> > > > 
> > > > template<typename T> struct strip;
> > > > template<typename T> struct strip<__seg_fs T *> { typedef T type; };
> > > > template<typename T> struct strip<__seg_gs T *> { typedef T type; };
> > > > 
> > > > int
> > > > main ()
> > > > {
> > > >       *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
> > > >       return 0;
> > > > }
> > > > ```
> > > > 
> > > > Ex2:
> > > > ```
> > > > int __seg_fs * fs1;
> > > > int __seg_fs * fs2;
> > > > 
> > > > template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
> > > > template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
> > > > 
> > > > int
> > > > main ()
> > > > {
> > > >       f (fs1, gs1);
> > > >       f (gs1, fs1);
> > > >       return 0;
> > > > }
> > > > ```
> > > > 
> > > > Ex3:
> > > > ```
> > > > int __seg_fs * fs1;
> > > > int __seg_gs * gs1;
> > > > 
> > > > template<typename T, typename U>
> > > > auto f (T __seg_fs * a, U __seg_gs * b)
> > > > {
> > > >       return *(T *) a == *(U *) b;
> > > > }
> > > > 
> > > > int
> > > > main ()
> > > > {
> > > >       return f (fs1, gs1);
> > > > }
> > > > ```
> > > > 
> > > > 
> > > > Add support for custom address spaces in C++
> > > > 
> > > > gcc/
> > > >           * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> > > > 
> > > > gcc/c/
> > > >           * c-decl.cc: Remove c_register_addr_space.
> > > > 
> > > > gcc/c-family/
> > > >           * c-common.cc (c_register_addr_space): Imported from c-decl.cc
> > > >           (addr_space_superset): Imported from gcc/c/c-typecheck.cc
> > > >           * c-common.h: Remove the FIXME.
> > > >           (addr_space_superset): New declaration.
> > > > 
> > > > gcc/cp/
> > > >           * cp-tree.h (enum cp_decl_spec): Add addr_space support.
> > > >           (struct cp_decl_specifier_seq): Likewise.
> > > >           * decl.cc (get_type_quals): Likewise.
> > > >           (check_tag_decl): Likewise.
> > > > 	(grokdeclarator): Likewise.
> > > >           * parser.cc (cp_parser_type_specifier): Likewise.
> > > >           (cp_parser_cv_qualifier_seq_opt): Likewise.
> > > >           (cp_parser_postfix_expression): Likewise.
> > > >           (cp_parser_type_specifier): Likewise.
> > > >           (set_and_check_decl_spec_loc): Likewise.
> > > >           * typeck.cc (composite_pointer_type): Likewise
> > > >           (comp_ptr_ttypes_real): Likewise.
> > > > 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
> > > >           * pt.cc (check_cv_quals_for_unify): Likewise.
> > > >           (unify): Likewise.
> > > >           * tree.cc: Remove c_register_addr_space stub.
> > > >           * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
> > > >             using the extended qualifier notation.
> > > > 
> > > > gcc/doc
> > > >           * extend.texi (Named Address Spaces): add a mention about C++
> > > >             support.
> > > > 
> > > > gcc/testsuite/
> > > >           * g++.dg/abi/mangle-addr-space1.C: New test.
> > > >           * g++.dg/abi/mangle-addr-space2.C: New test.
> > > >           * g++.dg/parse/addr-space.C: New test.
> > > >           * g++.dg/parse/addr-space1.C: New test.
> > > >           * g++.dg/parse/addr-space2.C: New test.
> > > >           * g++.dg/parse/template/spec-addr-space.C: New test.
> > > >           * g++.dg/ext/addr-space-decl.C: New test.
> > > >           * g++.dg/ext/addr-space-ref.C: New test.
> > > >           * g++.dg/ext/addr-space-ops.C: New test.
> > > > 
> > > > # Please enter the commit message for your changes. Lines starting
> > > > # with '#' will be ignored, and an empty message aborts the commit.
> > > > #
> > > > # Date:      Sun Oct 9 16:02:22 2022 +0200
> > > > #
> > > > # On branch releases/gcc-12
> > > > # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
> > > > #   (use "git push" to publish your local commits)
> > > > #
> > > > # Changes to be committed:
> > > > #	modified:   gcc/c-family/c-common.cc
> > > > #	modified:   gcc/c-family/c-common.h
> > > > #	modified:   gcc/c/c-decl.cc
> > > > #	modified:   gcc/c/c-typeck.cc
> > > > #	modified:   gcc/cp/cp-tree.h
> > > > #	modified:   gcc/cp/decl.cc
> > > > #	modified:   gcc/cp/mangle.cc
> > > > #	modified:   gcc/cp/parser.cc
> > > > #	modified:   gcc/cp/pt.cc
> > > > #	modified:   gcc/cp/tree.cc
> > > > #	modified:   gcc/cp/typeck.cc
> > > > #	modified:   gcc/doc/extend.texi
> > > > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
> > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > #	modified:   gcc/tree.h
> > > > #
> > > > # Untracked files:
> > > > #	Makefile
> > > > #	addr-space-decl.C
> > > > #	addr-space-decl.s
> > > > #	addr-space-ops.C
> > > > #	addr-space-ref.C
> > > > #	addr-space-template.C
> > > > #	addr-space-template.s
> > > > #	addr-space-template2.C
> > > > #	addr-space-template2.C.006t.gimple
> > > > #	addr-space-template2.s
> > > > #	addr-space-traits.C
> > > > #	addr-space4.C
> > > > #	addr-space4.C.006t.gimple
> > > > #	addr-space4.s
> > > > #	build-x86_64-pc-linux-gnu/
> > > > #	compare
> > > > #	host-x86_64-pc-linux-gnu/
> > > > #	mangle-addr-space1.s
> > > > #	prev-x86_64-pc-linux-gnu/
> > > > #	rename
> > > > #	stage1-x86_64-pc-linux-gnu/
> > > > #	stage_current
> > > > #	stage_final
> > > > #	stage_last
> > > > #	x86_64-pc-linux-gnu/
> > > > #
> > > > # ------------------------ >8 ------------------------
> > > > # Do not modify or remove the line above.
> > > > # Everything below it will be ignored.
> > > > diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> > > > index bb0544eeaea..ff1146ecc25 100644
> > > > --- a/gcc/c-family/c-common.cc
> > > > +++ b/gcc/c-family/c-common.cc
> > > > @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
> > > >      return IDENTIFIER_POINTER (ridpointers [rid]);
> > > >    }
> > > > +/* Return true if between two named address spaces, whether there is a superset
> > > > +   named address space that encompasses both address spaces.  If there is a
> > > > +   superset, return which address space is the superset.  */
> > > > +
> > > > +bool
> > > > +addr_space_superset (addr_space_t as1, addr_space_t as2,
> > > > +		     addr_space_t * common)
> > > > +{
> > > > +  if (as1 == as2)
> > > > +    {
> > > > +      *common = as1;
> > > > +      return true;
> > > > +    }
> > > > +  else if (targetm.addr_space.subset_p (as1, as2))
> > > > +    {
> > > > +      *common = as2;
> > > > +      return true;
> > > > +    }
> > > > +  else if (targetm.addr_space.subset_p (as2, as1))
> > > > +    {
> > > > +      *common = as1;
> > > > +      return true;
> > > > +    }
> > > > +  else
> > > > +    return false;
> > > > +}
> > > > +
> > > >    /* Push current bindings for the function name VAR_DECLS.  */
> > > >    void
> > > > @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
> > > >      return build_nonstandard_integer_type (width, unsignedp);
> > > >    }
> > > > +/* Register reserved keyword WORD as qualifier for address space AS.  */
> > > > +
> > > > +void
> > > > +c_register_addr_space (const char *word, addr_space_t as)
> > > > +{
> > > > +  int rid = RID_FIRST_ADDR_SPACE + as;
> > > > +  tree id;
> > > > +
> > > > +  /* Address space qualifiers are only supported
> > > > +     in C with GNU extensions enabled.  */
> > > > +  if (c_dialect_objc () || flag_no_asm)
> > > > +    return;
> > > > +
> > > > +  id = get_identifier (word);
> > > > +  C_SET_RID_CODE (id, rid);
> > > > +  TREE_LANG_FLAG_0 (id) = 1;
> > > > +  ridpointers[rid] = id;
> > > > +}
> > > > +
> > > >    /* The C version of the register_builtin_type langhook.  */
> > > >    void
> > > > diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> > > > index 52a85bfb783..d36f9e4975b 100644
> > > > --- a/gcc/c-family/c-common.h
> > > > +++ b/gcc/c-family/c-common.h
> > > > @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
> > > >    extern tree (*make_fname_decl) (location_t, tree, int);
> > > > -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> > > > -extern void c_register_addr_space (const char *str, addr_space_t as);
> > > > -
> > > >    /* In c-common.cc.  */
> > > >    extern bool in_late_binary_op;
> > > >    extern const char *c_addr_space_name (addr_space_t as);
> > > > +extern const char *c_addr_space_name (addr_space_t as);
> > > > +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
> > > >    extern tree identifier_global_value (tree);
> > > >    extern tree identifier_global_tag (tree);
> > > >    extern bool names_builtin_p (const char *);
> > > > @@ -952,6 +951,7 @@ extern void c_common_finish (void);
> > > >    extern void c_common_parse_file (void);
> > > >    extern FILE *get_dump_info (int, dump_flags_t *);
> > > >    extern alias_set_type c_common_get_alias_set (tree);
> > > > +extern void c_register_addr_space (const char *, addr_space_t);
> > > >    extern void c_register_builtin_type (tree, const char*);
> > > >    extern bool c_promoting_integer_type_p (const_tree);
> > > >    extern bool self_promoting_args_p (const_tree);
> > > > diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> > > > index c701f07befe..e1bb4f1cf37 100644
> > > > --- a/gcc/c/c-decl.cc
> > > > +++ b/gcc/c/c-decl.cc
> > > > @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
> > > >      ext_block = NULL;
> > > >    }
> > > > -/* Register reserved keyword WORD as qualifier for address space AS.  */
> > > > -
> > > > -void
> > > > -c_register_addr_space (const char *word, addr_space_t as)
> > > > -{
> > > > -  int rid = RID_FIRST_ADDR_SPACE + as;
> > > > -  tree id;
> > > > -
> > > > -  /* Address space qualifiers are only supported
> > > > -     in C with GNU extensions enabled.  */
> > > > -  if (c_dialect_objc () || flag_no_asm)
> > > > -    return;
> > > > -
> > > > -  id = get_identifier (word);
> > > > -  C_SET_RID_CODE (id, rid);
> > > > -  C_IS_RESERVED_WORD (id) = 1;
> > > > -  ridpointers [rid] = id;
> > > > -}
> > > > -
> > > >    /* Return identifier to look up for omp declare reduction.  */
> > > >    tree
> > > > diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> > > > index b271af9bedb..c4b01368534 100644
> > > > --- a/gcc/c/c-typeck.cc
> > > > +++ b/gcc/c/c-typeck.cc
> > > > @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
> > > >      return type;
> > > >    }
> > > > -/* Return true if between two named address spaces, whether there is a superset
> > > > -   named address space that encompasses both address spaces.  If there is a
> > > > -   superset, return which address space is the superset.  */
> > > > -
> > > > -static bool
> > > > -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> > > > -{
> > > > -  if (as1 == as2)
> > > > -    {
> > > > -      *common = as1;
> > > > -      return true;
> > > > -    }
> > > > -  else if (targetm.addr_space.subset_p (as1, as2))
> > > > -    {
> > > > -      *common = as2;
> > > > -      return true;
> > > > -    }
> > > > -  else if (targetm.addr_space.subset_p (as2, as1))
> > > > -    {
> > > > -      *common = as1;
> > > > -      return true;
> > > > -    }
> > > > -  else
> > > > -    return false;
> > > > -}
> > > > -
> > > >    /* Return a variant of TYPE which has all the type qualifiers of LIKE
> > > >       as well as those of TYPE.  */
> > > > diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> > > > index 72f4398a8f9..82a6d72f5df 100644
> > > > --- a/gcc/cp/cp-tree.h
> > > > +++ b/gcc/cp/cp-tree.h
> > > > @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
> > > >      ds_const,
> > > >      ds_volatile,
> > > >      ds_restrict,
> > > > +  ds_addr_space,
> > > >      ds_inline,
> > > >      ds_virtual,
> > > >      ds_explicit,
> > > > @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
> > > >      cp_storage_class storage_class;
> > > >      /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
> > > >      int int_n_idx;
> > > > +  /* The address space that the declaration belongs to.  */
> > > > +  addr_space_t address_space;
> > > >      /* True iff TYPE_SPEC defines a class or enum.  */
> > > >      BOOL_BITFIELD type_definition_p : 1;
> > > >      /* True iff multiple types were (erroneously) specified for this
> > > > diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> > > > index 9f78c500a15..fa5a1ddb21d 100644
> > > > --- a/gcc/cp/decl.cc
> > > > +++ b/gcc/cp/decl.cc
> > > > @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
> > > >        type_quals |= TYPE_QUAL_VOLATILE;
> > > >      if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
> > > >        type_quals |= TYPE_QUAL_RESTRICT;
> > > > +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > > > +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
> > > >      return type_quals;
> > > >    }
> > > > @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
> > > >    	error_at (declspecs->locations[ds_restrict],
> > > >    		  "%<__restrict%> can only be specified for objects and "
> > > >    		  "functions");
> > > > +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > > > +	error_at (declspecs->locations[ds_addr_space],
> > > > +		  "address space can only be specified for objects and "
> > > > +		  "functions");
> > > >          else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
> > > >    	error_at (declspecs->locations[ds_thread],
> > > >    		  "%<__thread%> can only be specified for objects "
> > > > @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
> > > >        if (!processing_template_decl)
> > > >          cp_apply_type_quals_to_decl (type_quals, decl);
> > > > +    addr_space_t address_space = declspecs->address_space;
> > > > +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
> > > > +      {
> > > > +	if (decl_context == NORMAL)
> > > > +	  {
> > > > +	    switch (storage_class)
> > > > +	      {
> > > > +	      case sc_auto:
> > > > +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
> > > > +		       c_addr_space_name (address_space), name);
> > > > +		break;
> > > > +	      case sc_register:
> > > > +		error ("%qs combined with %<register%> qualifier for %qs",
> > > > +		       c_addr_space_name (address_space), name);
> > > > +		break;
> > > > +	      case sc_none:
> > > > +		if (! toplevel_bindings_p ())
> > > > +		  error ("%qs specified for auto variable %qs",
> > > > +			 c_addr_space_name (address_space), name);
> > > > +		break;
> > > > +	      case sc_mutable:
> > > > +		error ("%qs combined with %<mutable%> qualifier for %qs",
> > > > +		       c_addr_space_name (address_space), name);
> > > > +		break;
> > > > +	      case sc_static:
> > > > +	      case sc_extern:
> > > > +		break;
> > > > +	      default:
> > > > +		gcc_unreachable ();
> > > > +	      }
> > > > +	  }
> > > > +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
> > > > +	  {
> > > > +	    if (name)
> > > > +	      error ("%qs specified for parameter %qs",
> > > > +		     c_addr_space_name (address_space), name);
> > > > +	    else
> > > > +	      error ("%qs specified for unnamed parameter",
> > > > +		     c_addr_space_name (address_space));
> > > > +	  }
> > > > +	else if (decl_context == FIELD)
> > > > +	  {
> > > > +	    if (name)
> > > > +	      error ("%qs specified for structure field %qs",
> > > > +		     c_addr_space_name (address_space), name);
> > > > +	    else
> > > > +	      error ("%qs specified for structure field",
> > > > +		     c_addr_space_name (address_space));
> > > > +	  }
> > > > +      }
> > > > +
> > > >        return decl;
> > > >      }
> > > >    }
> > > > diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> > > > index eb53e0ebeb4..16cb2ff4332 100644
> > > > --- a/gcc/cp/mangle.cc
> > > > +++ b/gcc/cp/mangle.cc
> > > > @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
> > > >         array.  */
> > > >      cp_cv_quals quals = TYPE_QUALS (type);
> > > > +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
> > > > +    {
> > > > +      const char *as_name = c_addr_space_name (as);
> > > > +      write_char ('U');
> > > > +      write_unsigned_number (strlen (as_name));
> > > > +      write_string (as_name);
> > > > +      ++num_qualifiers;
> > > > +    }
> > > >      if (quals & TYPE_QUAL_RESTRICT)
> > > >        {
> > > >          write_char ('r');
> > > > diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> > > > index 763df6f479b..f0169d83ab0 100644
> > > > --- a/gcc/cp/parser.cc
> > > > +++ b/gcc/cp/parser.cc
> > > > @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
> > > >    		    postfix_expression = error_mark_node;
> > > >    		    break;
> > > >    		  }
> > > > +		if (type != error_mark_node
> > > > +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> > > > +		    && current_function_decl)
> > > > +		  {
> > > > +		    error
> > > > +		      ("compound literal qualified by address-space qualifier");
> > > > +		    type = error_mark_node;
> > > > +		  }
> > > >    		/* Form the representation of the compound-literal.  */
> > > >    		postfix_expression
> > > >    		  = finish_compound_literal (type, initializer,
> > > > @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
> > > >          break;
> > > >        }
> > > > +
> > > > +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> > > > +    {
> > > > +      ds = ds_addr_space;
> > > > +      if (is_cv_qualifier)
> > > > +	*is_cv_qualifier = true;
> > > > +    }
> > > > +
> > > > +
> > > >      /* Handle simple keywords.  */
> > > >      if (ds != ds_last)
> > > >        {
> > > > @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
> > > >       GNU Extension:
> > > >       cv-qualifier:
> > > > +     address-space-qualifier
> > > >         __restrict__
> > > >       Returns a bitmask representing the cv-qualifiers.  */
> > > > @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
> > > >    	  break;
> > > >    	}
> > > > +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> > > > +	  token->keyword <= RID_LAST_ADDR_SPACE)
> > > > +	cv_qualifier =
> > > > +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> > > > +
> > > >          if (!cv_qualifier)
> > > >    	break;
> > > > @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> > > >          decl_specs->locations[ds] = location;
> > > >          if (ds == ds_thread)
> > > >    	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> > > > +      else if (ds == ds_addr_space)
> > > > +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
> > > >        }
> > > >      else
> > > >        {
> > > > @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> > > >    	      error_at (&richloc, "duplicate %qD", token->u.value);
> > > >    	    }
> > > >    	}
> > > > +      else if (ds == ds_addr_space)
> > > > +	{
> > > > +	  addr_space_t as1 = decl_specs->address_space;
> > > > +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> > > > +
> > > > +	  gcc_rich_location richloc (location);
> > > > +	  richloc.add_fixit_remove ();
> > > > +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> > > > +	      && as1 != as2)
> > > > +	    error_at (&richloc,
> > > > +		      "conflicting named address spaces (%s vs %s)",
> > > > +		      c_addr_space_name (as1), c_addr_space_name (as2));
> > > > +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> > > > +	    error_at (&richloc,
> > > > +		      "duplicate named address space %s",
> > > > +		      c_addr_space_name (as1));
> > > > +
> > > > +	  decl_specs->address_space = as2;
> > > > +	}
> > > >          else
> > > >    	{
> > > >    	  static const char *const decl_spec_names[] = {
> > > > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> > > > index bef31416fb7..c9d1c01f4ce 100644
> > > > --- a/gcc/cp/pt.cc
> > > > +++ b/gcc/cp/pt.cc
> > > > @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
> > > >    static int
> > > >    check_cv_quals_for_unify (int strict, tree arg, tree parm)
> > > >    {
> > > > -  int arg_quals = cp_type_quals (arg);
> > > > -  int parm_quals = cp_type_quals (parm);
> > > > +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > > > +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > > > +
> > > > +  /*  Try to unify ARG's address space into PARM's address space.
> > > > +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
> > > > +      there are no constraints on address spaces for this type.  */
> > > > +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > > > +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > > > +  addr_space_t as_common;
> > > > +  addr_space_superset (as_arg, as_parm, &as_common);
> > > > +
> > > > +  if (!(as_parm == as_common || as_parm == 0))
> > > > +    return 0;
> > > >      if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
> > > >          && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
> > > > @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
> > > >    					 arg, parm))
> > > >    	    return unify_cv_qual_mismatch (explain_p, parm, arg);
> > > > +	  int arg_cv_quals = cp_type_quals (arg);
> > > > +	  int parm_cv_quals = cp_type_quals (parm);
> > > > +
> > > > +	  /* If PARM does not contain any address space constraints it can
> > > > +	     fully match the address space of ARG.  However, if PARM contains an
> > > > +	     address space constraint, it becomes the upper bound.  That is,
> > > > +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
> > > > +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
> > > > +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
> > > > +	     AS_PARM.  */
> > > > +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
> > > > +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
> > > > +	  addr_space_t as_common = as_parm ? 0 : as_arg;
> > > > +
> > > >    	  /* Consider the case where ARG is `const volatile int' and
> > > >    	     PARM is `const T'.  Then, T should be `volatile int'.  */
> > > > -	  arg = cp_build_qualified_type_real
> > > > -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
> > > > +	  int unified_cv =
> > > > +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> > > > +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> > > > +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
> > > >    	  if (arg == error_mark_node)
> > > >    	    return unify_invalid (explain_p);
> > > > diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> > > > index 3b37567cbd7..5e14ac837fc 100644
> > > > --- a/gcc/cp/tree.cc
> > > > +++ b/gcc/cp/tree.cc
> > > > @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
> > > >        DECL_CHAIN (t) = NULL_TREE;
> > > >    }
> > > > -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> > > > -   FIXME: If address space support is target specific, then this
> > > > -   should be a C target hook.  But currently this is not possible,
> > > > -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> > > > -void
> > > > -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> > > > -{
> > > > -}
> > > > -
> > > >    /* Return the number of operands in T that we care about for things like
> > > >       mangling.  */
> > > > diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> > > > index ceb80d9744f..7d810c6a12c 100644
> > > > --- a/gcc/cp/typeck.cc
> > > > +++ b/gcc/cp/typeck.cc
> > > > @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
> > > >    	  else
> > > >    	    return error_mark_node;
> > > >            }
> > > > +      /* If possible merge the address space into the superset of the address
> > > > +	  spaces of t1 and t2, or raise an error. */
> > > > +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> > > > +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> > > > +      addr_space_t as_common;
> > > > +
> > > > +      /* If the two named address spaces are different, determine the common
> > > > +	 superset address space.  If there isn't one, raise an error.  */
> > > > +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> > > > +	{
> > > > +	  as_common = as_t1;
> > > > +	  error_at (location,
> > > > +		    "%qT and %qT are in disjoint named address spaces",
> > > > +		    t1, t2);
> > > > +	}
> > > >          result_type
> > > >    	= cp_build_qualified_type (void_type_node,
> > > > -				   (cp_type_quals (TREE_TYPE (t1))
> > > > -				    | cp_type_quals (TREE_TYPE (t2))));
> > > > +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> > > > +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> > > > +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
> > > >          result_type = build_pointer_type (result_type);
> > > >          /* Merge the attributes.  */
> > > >          attributes = (*targetm.merge_type_attributes) (t1, t2);
> > > > @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
> > > >    }
> > > >    /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
> > > > -   top-level qualifiers.  */
> > > > +   top-level qualifiers, except for named address spaces.  If the pointers point
> > > > +   to different named addresses spaces, then we must determine if one address
> > > > +   space is a subset of the other.  */
> > > >    bool
> > > >    same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> > > > @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> > > >      if (type1 == type2)
> > > >        return true;
> > > > +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
> > > > +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
> > > > +  addr_space_t as_common;
> > > > +
> > > > +  /* Fail if pointers point to incompatible address spaces.  */
> > > > +  if (!addr_space_superset (as_type1, as_type2, &as_common))
> > > > +    return false;
> > > > +
> > > >      type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
> > > >      type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
> > > >      return same_type_p (type1, type2);
> > > > @@ -6374,10 +6400,32 @@ static tree
> > > >    pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
> > > >    	      tsubst_flags_t complain, tree *instrument_expr)
> > > >    {
> > > > -  tree result, inttype;
> > > >      tree restype = ptrdiff_type_node;
> > > > +  tree result, inttype;
> > > > +
> > > > +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
> > > > +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
> > > >      tree target_type = TREE_TYPE (ptrtype);
> > > > +  /* If the operands point into different address spaces, we need to
> > > > +     explicitly convert them to pointers into the common address space
> > > > +     before we can subtract the numerical address values.  */
> > > > +  if (as0 != as1)
> > > > +    {
> > > > +      addr_space_t as_common;
> > > > +      tree common_type;
> > > > +
> > > > +      /* Determine the common superset address space.  This is guaranteed
> > > > +	 to exist because the caller verified that comp_target_types
> > > > +	 returned non-zero.  */
> > > > +      if (!addr_space_superset (as0, as1, &as_common))
> > > > +	gcc_unreachable ();
> > > > +
> > > > +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
> > > > +      op0 = convert (common_type, op0);
> > > > +      op1 = convert (common_type, op1);
> > > > +    }
> > > > +
> > > >      if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
> > > >        return error_mark_node;
> > > > @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
> > > >    	      to_more_cv_qualified = true;
> > > >    	    }
> > > > +      /* Warn about conversions between pointers to disjoint
> > > > +	 address spaces.  */
> > > > +      if (TREE_CODE (from) == POINTER_TYPE
> > > > +	  && TREE_CODE (to) == POINTER_TYPE)
> > > > +	{
> > > > +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> > > > +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> > > > +	  addr_space_t as_common;
> > > > +
> > > > +	  if (!addr_space_superset (as_to, as_from, &as_common))
> > > > +	    return false;
> > > > +	}
> > > > +
> > > >    	  if (constp > 0)
> > > >    	    constp &= TYPE_READONLY (to);
> > > >    	}
> > > > diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> > > > index ac3db88566d..1e0d436c02c 100644
> > > > --- a/gcc/doc/extend.texi
> > > > +++ b/gcc/doc/extend.texi
> > > > @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
> > > >    @section Named Address Spaces
> > > >    @cindex Named Address Spaces
> > > > -As an extension, GNU C supports named address spaces as
> > > > +As an extension, GNU C and GNU C++ support named address spaces as
> > > >    defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
> > > >    address spaces in GCC will evolve as the draft technical report
> > > >    changes.  Calling conventions for any target might also change.  At
> > > > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > new file mode 100644
> > > > index 00000000000..c01f8d6054a
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > @@ -0,0 +1,10 @@
> > > > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > > > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > > > +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> > > > +
> > > > +int f (int volatile __seg_fs *a)
> > > > +{
> > > > +  return *a;
> > > > +}
> > > > +
> > > > +int main () {}
> > > > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > new file mode 100644
> > > > index 00000000000..862bbbdcdf2
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > @@ -0,0 +1,9 @@
> > > > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > > > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > > > +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
> > > > +
> > > > +template <class T>
> > > > +int f (T *p) { return *p; }
> > > > +int g (__seg_fs int *p) { return *p; }
> > > > +__seg_fs int *a;
> > > > +int main() { f(a); }
> > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > new file mode 100644
> > > > index 00000000000..c04d2f497da
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > @@ -0,0 +1,5 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +__seg_fs char a, b, c;
> > > > +__seg_fs const int *p;
> > > > +static /* give internal linkage to the following anonymous struct */
> > > > +__seg_fs struct { int a; char b; } * __seg_gs q;
> > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > new file mode 100644
> > > > index 00000000000..86c02d1e7f5
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > @@ -0,0 +1,20 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +int __seg_fs * fs1;
> > > > +int __seg_fs * fs2;
> > > > +float __seg_gs * gs1;
> > > > +float __seg_gs * gs2;
> > > > +
> > > > +int
> > > > +main ()
> > > > +{
> > > > +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
> > > > +  fs1 - fs2;
> > > > +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
> > > > +  fs1 == fs2;
> > > > +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > > > +  fs1 = fs2;
> > > > +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
> > > > +  fs1 > fs2;
> > > > +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > > > +  return 0;
> > > > +}
> > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > new file mode 100644
> > > > index 00000000000..12d7975e560
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > @@ -0,0 +1,31 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +// { dg-prune-output "does not allow .register. storage class specifier" }
> > > > +int __seg_fs * outer_b;
> > > > +
> > > > +struct s {
> > > > +  __seg_fs int * ok;
> > > > +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
> > > > +};
> > > > +
> > > > +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
> > > > +
> > > > +namespace ns_a
> > > > +{
> > > > +  int __seg_fs * inner_b;
> > > > +
> > > > +  template<typename T>
> > > > +  int f (T &a) { return a; }
> > > > +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
> > > > +  int h (__seg_fs int *a) { return *a; }
> > > > +}
> > > > +
> > > > +int
> > > > +main ()
> > > > +{
> > > > +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
> > > > +  static __seg_gs int static_gs;
> > > > +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
> > > > +  __seg_fs int *pa = outer_b;
> > > > +  __seg_fs int& ra = *ns_a::inner_b;
> > > > +  return ns_a::f(ra) + ns_a::f(*pa);
> > > > +}
> > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> > > > new file mode 100644
> > > > index 00000000000..ebb6316054a
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> > > > @@ -0,0 +1,9 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +
> > > > +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> > > > +
> > > > +int
> > > > +main ()
> > > > +{
> > > > +	return 0;
> > > > +}
> > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > new file mode 100644
> > > > index 00000000000..2e8ee32a885
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > @@ -0,0 +1,10 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +// { dg-options "-std=gnu++98" }
> > > > +
> > > > +int
> > > > +main ()
> > > > +{
> > > > +	struct foo {int a; char b[2];} structure;
> > > > +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> > > > +	return 0;
> > > > +}
> > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > new file mode 100644
> > > > index 00000000000..5b2c0f28078
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > @@ -0,0 +1,9 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +
> > > > +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> > > > +
> > > > +int
> > > > +main ()
> > > > +{
> > > > +	return 0;
> > > > +}
> > > > diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > new file mode 100644
> > > > index 00000000000..ae9f4de0e1f
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > @@ -0,0 +1,8 @@
> > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > +
> > > > +template <class T>
> > > > +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
> > > > +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
> > > > +__seg_fs int *a;
> > > > +int main() { f(a); } // { dg-error "no matching" }
> > > > +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
> > > > diff --git a/gcc/tree.h b/gcc/tree.h
> > > > index 8844471e9a5..b7da4c5141a 100644
> > > > --- a/gcc/tree.h
> > > > +++ b/gcc/tree.h
> > > > @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
> > > >    /* Encode/decode the named memory support as part of the qualifier.  If more
> > > >       than 8 qualifiers are added, these macros need to be adjusted.  */
> > > > -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> > > > +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
> > > >    #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
> > > >    /* Return all qualifiers except for the address space qualifiers.  */
> > > > 
> > > > 
> > > > 
> > > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > 
> > 
> > 
> > 
> > 
> 
> 
> 
> 
> 
> 
>
  

On 10/13/22 12:02, Paul Iannetta wrote:
> On Thu, Oct 13, 2022 at 11:47:42AM -0400, Jason Merrill wrote:
>> On 10/13/22 11:23, Paul Iannetta wrote:
>>> On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
>>>> On 10/12/22 20:52, Paul Iannetta wrote:
>>>>> On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
>>>>>>
>>>>>> It surprises that this is the only place we complain about an object with an
>>>>>> address-space qualifier.  Shouldn't we also complain about e.g. automatic
>>>>>> variables/parameters or non-static data members with address-space qualified
>>>>>> type?
>>>>>>
>>>>>
>>>>> Indeed, I was missing quite a few things here.  Thanks.
>>>>> I used the draft as basis this time and imported from the C
>>>>> implementation the relevant parts.  This time, the errors get properly
>>>>> emitted when an address space is unduly specified; and comparisons,
>>>>> assignments and comparisons are taken care of.
>>>>>
>>>>> There are quite a few things I would like to clarify concerning some
>>>>> implementation details.
>>>>>      - A variable with automatic storage (which is neither a pointer nor
>>>>>        a reference) cannot be qualified with an address space.  I detect
>>>>>        this by the combination of `sc_none' and `! toplevel_bindings_p ()',
>>>>>        but I've also seen the use of `at_function_scope' at other places.
>>>>>        And I'm unsure which one is appropriate here.
>>>>>        This detection happens at the very end of grokdeclarator because I
>>>>>        need to know that the type is a pointer, which is not know until
>>>>>        very late in the function.
>>>>
>>>> At that point you have the decl, and you can ask directly what its storage
>>>> duration is, perhaps using decl_storage_duration.
>>>>
>>>> But why do you need to know whether the type is a pointer?  The attribute
>>>> applies to the target type of the pointer, not the pointer type.  I think
>>>> the problem is that you're looking at declspecs when you ought to be looking
>>>> at type_quals.
>>>
>>> I need to know that the base type is a pointer to reject invalid
>>> declarations such as:
>>>
>>>       int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }
>>>
>>> because parameters and auto variables can have an address space
>>> qualifier only if they are pointer or reference type, which I can't
>>> tell only from type_quals.
>>
>> But "int *__seg_fs a" is just as invalid as the above; the difference is not
>> whether a is a pointer, but whether the address-space-qualified is the type
>> of a itself or some sub-type.
> 
> I agree that "int * __seg_fs a" is invalid but it is accepted by the C
> front-end, and by clang (both C and C++), the behavior is that the
> address-name is silently ignored.

Hmm, that sounds like a bug; in that case, presumably the user meant to 
qualify the pointed-to type, and silently ignoring seems unlikely to 
give the effect they want.

>> You need to look at the qualifiers on type (which should also be the ones in
>> type_quals), not the qualifiers in the declspecs.
> 
> I'll have another look, thanks.
> 
>>>>>      - I'm having some trouble deciding whether I include those three
>>>>>        stub programs as tests, they all compile fine and clang accepts
>>>>>        them as well.
>>>>
>>>> Why not?
>>>
>>> I thought they were pretty contrived, since it does not make much
>>> sense to strip address space qualifiers, even though it does prove
>>> that the implementation support those contrived but valid uses.
>>
>> Testcases are full of contrived examples testing corner cases.  :)
>>
>>>>
>>>>> Ex1:
>>>>> ```
>>>>> int __seg_fs * fs1;
>>>>> int __seg_gs * gs1;
>>>>>
>>>>> template<typename T> struct strip;
>>>>> template<typename T> struct strip<__seg_fs T *> { typedef T type; };
>>>>> template<typename T> struct strip<__seg_gs T *> { typedef T type; };
>>>>>
>>>>> int
>>>>> main ()
>>>>> {
>>>>>        *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
>>>>>        return 0;
>>>>> }
>>>>> ```
>>>>>
>>>>> Ex2:
>>>>> ```
>>>>> int __seg_fs * fs1;
>>>>> int __seg_fs * fs2;
>>>>>
>>>>> template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
>>>>> template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
>>>>>
>>>>> int
>>>>> main ()
>>>>> {
>>>>>        f (fs1, gs1);
>>>>>        f (gs1, fs1);
>>>>>        return 0;
>>>>> }
>>>>> ```
>>>>>
>>>>> Ex3:
>>>>> ```
>>>>> int __seg_fs * fs1;
>>>>> int __seg_gs * gs1;
>>>>>
>>>>> template<typename T, typename U>
>>>>> auto f (T __seg_fs * a, U __seg_gs * b)
>>>>> {
>>>>>        return *(T *) a == *(U *) b;
>>>>> }
>>>>>
>>>>> int
>>>>> main ()
>>>>> {
>>>>>        return f (fs1, gs1);
>>>>> }
>>>>> ```
>>>>>
>>>>>
>>>>> Add support for custom address spaces in C++
>>>>>
>>>>> gcc/
>>>>>            * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
>>>>>
>>>>> gcc/c/
>>>>>            * c-decl.cc: Remove c_register_addr_space.
>>>>>
>>>>> gcc/c-family/
>>>>>            * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>>>>>            (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>>>>>            * c-common.h: Remove the FIXME.
>>>>>            (addr_space_superset): New declaration.
>>>>>
>>>>> gcc/cp/
>>>>>            * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>>>>>            (struct cp_decl_specifier_seq): Likewise.
>>>>>            * decl.cc (get_type_quals): Likewise.
>>>>>            (check_tag_decl): Likewise.
>>>>> 	(grokdeclarator): Likewise.
>>>>>            * parser.cc (cp_parser_type_specifier): Likewise.
>>>>>            (cp_parser_cv_qualifier_seq_opt): Likewise.
>>>>>            (cp_parser_postfix_expression): Likewise.
>>>>>            (cp_parser_type_specifier): Likewise.
>>>>>            (set_and_check_decl_spec_loc): Likewise.
>>>>>            * typeck.cc (composite_pointer_type): Likewise
>>>>>            (comp_ptr_ttypes_real): Likewise.
>>>>> 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
>>>>>            * pt.cc (check_cv_quals_for_unify): Likewise.
>>>>>            (unify): Likewise.
>>>>>            * tree.cc: Remove c_register_addr_space stub.
>>>>>            * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>>>>>              using the extended qualifier notation.
>>>>>
>>>>> gcc/doc
>>>>>            * extend.texi (Named Address Spaces): add a mention about C++
>>>>>              support.
>>>>>
>>>>> gcc/testsuite/
>>>>>            * g++.dg/abi/mangle-addr-space1.C: New test.
>>>>>            * g++.dg/abi/mangle-addr-space2.C: New test.
>>>>>            * g++.dg/parse/addr-space.C: New test.
>>>>>            * g++.dg/parse/addr-space1.C: New test.
>>>>>            * g++.dg/parse/addr-space2.C: New test.
>>>>>            * g++.dg/parse/template/spec-addr-space.C: New test.
>>>>>            * g++.dg/ext/addr-space-decl.C: New test.
>>>>>            * g++.dg/ext/addr-space-ref.C: New test.
>>>>>            * g++.dg/ext/addr-space-ops.C: New test.
>>>>>
>>>>> # Please enter the commit message for your changes. Lines starting
>>>>> # with '#' will be ignored, and an empty message aborts the commit.
>>>>> #
>>>>> # Date:      Sun Oct 9 16:02:22 2022 +0200
>>>>> #
>>>>> # On branch releases/gcc-12
>>>>> # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
>>>>> #   (use "git push" to publish your local commits)
>>>>> #
>>>>> # Changes to be committed:
>>>>> #	modified:   gcc/c-family/c-common.cc
>>>>> #	modified:   gcc/c-family/c-common.h
>>>>> #	modified:   gcc/c/c-decl.cc
>>>>> #	modified:   gcc/c/c-typeck.cc
>>>>> #	modified:   gcc/cp/cp-tree.h
>>>>> #	modified:   gcc/cp/decl.cc
>>>>> #	modified:   gcc/cp/mangle.cc
>>>>> #	modified:   gcc/cp/parser.cc
>>>>> #	modified:   gcc/cp/pt.cc
>>>>> #	modified:   gcc/cp/tree.cc
>>>>> #	modified:   gcc/cp/typeck.cc
>>>>> #	modified:   gcc/doc/extend.texi
>>>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>> #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>> #	modified:   gcc/tree.h
>>>>> #
>>>>> # Untracked files:
>>>>> #	Makefile
>>>>> #	addr-space-decl.C
>>>>> #	addr-space-decl.s
>>>>> #	addr-space-ops.C
>>>>> #	addr-space-ref.C
>>>>> #	addr-space-template.C
>>>>> #	addr-space-template.s
>>>>> #	addr-space-template2.C
>>>>> #	addr-space-template2.C.006t.gimple
>>>>> #	addr-space-template2.s
>>>>> #	addr-space-traits.C
>>>>> #	addr-space4.C
>>>>> #	addr-space4.C.006t.gimple
>>>>> #	addr-space4.s
>>>>> #	build-x86_64-pc-linux-gnu/
>>>>> #	compare
>>>>> #	host-x86_64-pc-linux-gnu/
>>>>> #	mangle-addr-space1.s
>>>>> #	prev-x86_64-pc-linux-gnu/
>>>>> #	rename
>>>>> #	stage1-x86_64-pc-linux-gnu/
>>>>> #	stage_current
>>>>> #	stage_final
>>>>> #	stage_last
>>>>> #	x86_64-pc-linux-gnu/
>>>>> #
>>>>> # ------------------------ >8 ------------------------
>>>>> # Do not modify or remove the line above.
>>>>> # Everything below it will be ignored.
>>>>> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
>>>>> index bb0544eeaea..ff1146ecc25 100644
>>>>> --- a/gcc/c-family/c-common.cc
>>>>> +++ b/gcc/c-family/c-common.cc
>>>>> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>>>>>       return IDENTIFIER_POINTER (ridpointers [rid]);
>>>>>     }
>>>>> +/* Return true if between two named address spaces, whether there is a superset
>>>>> +   named address space that encompasses both address spaces.  If there is a
>>>>> +   superset, return which address space is the superset.  */
>>>>> +
>>>>> +bool
>>>>> +addr_space_superset (addr_space_t as1, addr_space_t as2,
>>>>> +		     addr_space_t * common)
>>>>> +{
>>>>> +  if (as1 == as2)
>>>>> +    {
>>>>> +      *common = as1;
>>>>> +      return true;
>>>>> +    }
>>>>> +  else if (targetm.addr_space.subset_p (as1, as2))
>>>>> +    {
>>>>> +      *common = as2;
>>>>> +      return true;
>>>>> +    }
>>>>> +  else if (targetm.addr_space.subset_p (as2, as1))
>>>>> +    {
>>>>> +      *common = as1;
>>>>> +      return true;
>>>>> +    }
>>>>> +  else
>>>>> +    return false;
>>>>> +}
>>>>> +
>>>>>     /* Push current bindings for the function name VAR_DECLS.  */
>>>>>     void
>>>>> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>>>>>       return build_nonstandard_integer_type (width, unsignedp);
>>>>>     }
>>>>> +/* Register reserved keyword WORD as qualifier for address space AS.  */
>>>>> +
>>>>> +void
>>>>> +c_register_addr_space (const char *word, addr_space_t as)
>>>>> +{
>>>>> +  int rid = RID_FIRST_ADDR_SPACE + as;
>>>>> +  tree id;
>>>>> +
>>>>> +  /* Address space qualifiers are only supported
>>>>> +     in C with GNU extensions enabled.  */
>>>>> +  if (c_dialect_objc () || flag_no_asm)
>>>>> +    return;
>>>>> +
>>>>> +  id = get_identifier (word);
>>>>> +  C_SET_RID_CODE (id, rid);
>>>>> +  TREE_LANG_FLAG_0 (id) = 1;
>>>>> +  ridpointers[rid] = id;
>>>>> +}
>>>>> +
>>>>>     /* The C version of the register_builtin_type langhook.  */
>>>>>     void
>>>>> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
>>>>> index 52a85bfb783..d36f9e4975b 100644
>>>>> --- a/gcc/c-family/c-common.h
>>>>> +++ b/gcc/c-family/c-common.h
>>>>> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>>>>>     extern tree (*make_fname_decl) (location_t, tree, int);
>>>>> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
>>>>> -extern void c_register_addr_space (const char *str, addr_space_t as);
>>>>> -
>>>>>     /* In c-common.cc.  */
>>>>>     extern bool in_late_binary_op;
>>>>>     extern const char *c_addr_space_name (addr_space_t as);
>>>>> +extern const char *c_addr_space_name (addr_space_t as);
>>>>> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>>>>>     extern tree identifier_global_value (tree);
>>>>>     extern tree identifier_global_tag (tree);
>>>>>     extern bool names_builtin_p (const char *);
>>>>> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>>>>>     extern void c_common_parse_file (void);
>>>>>     extern FILE *get_dump_info (int, dump_flags_t *);
>>>>>     extern alias_set_type c_common_get_alias_set (tree);
>>>>> +extern void c_register_addr_space (const char *, addr_space_t);
>>>>>     extern void c_register_builtin_type (tree, const char*);
>>>>>     extern bool c_promoting_integer_type_p (const_tree);
>>>>>     extern bool self_promoting_args_p (const_tree);
>>>>> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
>>>>> index c701f07befe..e1bb4f1cf37 100644
>>>>> --- a/gcc/c/c-decl.cc
>>>>> +++ b/gcc/c/c-decl.cc
>>>>> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>>>>>       ext_block = NULL;
>>>>>     }
>>>>> -/* Register reserved keyword WORD as qualifier for address space AS.  */
>>>>> -
>>>>> -void
>>>>> -c_register_addr_space (const char *word, addr_space_t as)
>>>>> -{
>>>>> -  int rid = RID_FIRST_ADDR_SPACE + as;
>>>>> -  tree id;
>>>>> -
>>>>> -  /* Address space qualifiers are only supported
>>>>> -     in C with GNU extensions enabled.  */
>>>>> -  if (c_dialect_objc () || flag_no_asm)
>>>>> -    return;
>>>>> -
>>>>> -  id = get_identifier (word);
>>>>> -  C_SET_RID_CODE (id, rid);
>>>>> -  C_IS_RESERVED_WORD (id) = 1;
>>>>> -  ridpointers [rid] = id;
>>>>> -}
>>>>> -
>>>>>     /* Return identifier to look up for omp declare reduction.  */
>>>>>     tree
>>>>> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
>>>>> index b271af9bedb..c4b01368534 100644
>>>>> --- a/gcc/c/c-typeck.cc
>>>>> +++ b/gcc/c/c-typeck.cc
>>>>> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>>>>>       return type;
>>>>>     }
>>>>> -/* Return true if between two named address spaces, whether there is a superset
>>>>> -   named address space that encompasses both address spaces.  If there is a
>>>>> -   superset, return which address space is the superset.  */
>>>>> -
>>>>> -static bool
>>>>> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
>>>>> -{
>>>>> -  if (as1 == as2)
>>>>> -    {
>>>>> -      *common = as1;
>>>>> -      return true;
>>>>> -    }
>>>>> -  else if (targetm.addr_space.subset_p (as1, as2))
>>>>> -    {
>>>>> -      *common = as2;
>>>>> -      return true;
>>>>> -    }
>>>>> -  else if (targetm.addr_space.subset_p (as2, as1))
>>>>> -    {
>>>>> -      *common = as1;
>>>>> -      return true;
>>>>> -    }
>>>>> -  else
>>>>> -    return false;
>>>>> -}
>>>>> -
>>>>>     /* Return a variant of TYPE which has all the type qualifiers of LIKE
>>>>>        as well as those of TYPE.  */
>>>>> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
>>>>> index 72f4398a8f9..82a6d72f5df 100644
>>>>> --- a/gcc/cp/cp-tree.h
>>>>> +++ b/gcc/cp/cp-tree.h
>>>>> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>>>>>       ds_const,
>>>>>       ds_volatile,
>>>>>       ds_restrict,
>>>>> +  ds_addr_space,
>>>>>       ds_inline,
>>>>>       ds_virtual,
>>>>>       ds_explicit,
>>>>> @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
>>>>>       cp_storage_class storage_class;
>>>>>       /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>>>>>       int int_n_idx;
>>>>> +  /* The address space that the declaration belongs to.  */
>>>>> +  addr_space_t address_space;
>>>>>       /* True iff TYPE_SPEC defines a class or enum.  */
>>>>>       BOOL_BITFIELD type_definition_p : 1;
>>>>>       /* True iff multiple types were (erroneously) specified for this
>>>>> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
>>>>> index 9f78c500a15..fa5a1ddb21d 100644
>>>>> --- a/gcc/cp/decl.cc
>>>>> +++ b/gcc/cp/decl.cc
>>>>> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>>>>>         type_quals |= TYPE_QUAL_VOLATILE;
>>>>>       if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>>>>>         type_quals |= TYPE_QUAL_RESTRICT;
>>>>> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>>>> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>>>>>       return type_quals;
>>>>>     }
>>>>> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>>>>>     	error_at (declspecs->locations[ds_restrict],
>>>>>     		  "%<__restrict%> can only be specified for objects and "
>>>>>     		  "functions");
>>>>> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>>>> +	error_at (declspecs->locations[ds_addr_space],
>>>>> +		  "address space can only be specified for objects and "
>>>>> +		  "functions");
>>>>>           else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>>>>>     	error_at (declspecs->locations[ds_thread],
>>>>>     		  "%<__thread%> can only be specified for objects "
>>>>> @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
>>>>>         if (!processing_template_decl)
>>>>>           cp_apply_type_quals_to_decl (type_quals, decl);
>>>>> +    addr_space_t address_space = declspecs->address_space;
>>>>> +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
>>>>> +      {
>>>>> +	if (decl_context == NORMAL)
>>>>> +	  {
>>>>> +	    switch (storage_class)
>>>>> +	      {
>>>>> +	      case sc_auto:
>>>>> +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
>>>>> +		       c_addr_space_name (address_space), name);
>>>>> +		break;
>>>>> +	      case sc_register:
>>>>> +		error ("%qs combined with %<register%> qualifier for %qs",
>>>>> +		       c_addr_space_name (address_space), name);
>>>>> +		break;
>>>>> +	      case sc_none:
>>>>> +		if (! toplevel_bindings_p ())
>>>>> +		  error ("%qs specified for auto variable %qs",
>>>>> +			 c_addr_space_name (address_space), name);
>>>>> +		break;
>>>>> +	      case sc_mutable:
>>>>> +		error ("%qs combined with %<mutable%> qualifier for %qs",
>>>>> +		       c_addr_space_name (address_space), name);
>>>>> +		break;
>>>>> +	      case sc_static:
>>>>> +	      case sc_extern:
>>>>> +		break;
>>>>> +	      default:
>>>>> +		gcc_unreachable ();
>>>>> +	      }
>>>>> +	  }
>>>>> +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
>>>>> +	  {
>>>>> +	    if (name)
>>>>> +	      error ("%qs specified for parameter %qs",
>>>>> +		     c_addr_space_name (address_space), name);
>>>>> +	    else
>>>>> +	      error ("%qs specified for unnamed parameter",
>>>>> +		     c_addr_space_name (address_space));
>>>>> +	  }
>>>>> +	else if (decl_context == FIELD)
>>>>> +	  {
>>>>> +	    if (name)
>>>>> +	      error ("%qs specified for structure field %qs",
>>>>> +		     c_addr_space_name (address_space), name);
>>>>> +	    else
>>>>> +	      error ("%qs specified for structure field",
>>>>> +		     c_addr_space_name (address_space));
>>>>> +	  }
>>>>> +      }
>>>>> +
>>>>>         return decl;
>>>>>       }
>>>>>     }
>>>>> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
>>>>> index eb53e0ebeb4..16cb2ff4332 100644
>>>>> --- a/gcc/cp/mangle.cc
>>>>> +++ b/gcc/cp/mangle.cc
>>>>> @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
>>>>>          array.  */
>>>>>       cp_cv_quals quals = TYPE_QUALS (type);
>>>>> +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
>>>>> +    {
>>>>> +      const char *as_name = c_addr_space_name (as);
>>>>> +      write_char ('U');
>>>>> +      write_unsigned_number (strlen (as_name));
>>>>> +      write_string (as_name);
>>>>> +      ++num_qualifiers;
>>>>> +    }
>>>>>       if (quals & TYPE_QUAL_RESTRICT)
>>>>>         {
>>>>>           write_char ('r');
>>>>> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
>>>>> index 763df6f479b..f0169d83ab0 100644
>>>>> --- a/gcc/cp/parser.cc
>>>>> +++ b/gcc/cp/parser.cc
>>>>> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>>>>>     		    postfix_expression = error_mark_node;
>>>>>     		    break;
>>>>>     		  }
>>>>> +		if (type != error_mark_node
>>>>> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
>>>>> +		    && current_function_decl)
>>>>> +		  {
>>>>> +		    error
>>>>> +		      ("compound literal qualified by address-space qualifier");
>>>>> +		    type = error_mark_node;
>>>>> +		  }
>>>>>     		/* Form the representation of the compound-literal.  */
>>>>>     		postfix_expression
>>>>>     		  = finish_compound_literal (type, initializer,
>>>>> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>>>>>           break;
>>>>>         }
>>>>> +
>>>>> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
>>>>> +    {
>>>>> +      ds = ds_addr_space;
>>>>> +      if (is_cv_qualifier)
>>>>> +	*is_cv_qualifier = true;
>>>>> +    }
>>>>> +
>>>>> +
>>>>>       /* Handle simple keywords.  */
>>>>>       if (ds != ds_last)
>>>>>         {
>>>>> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>>>>>        GNU Extension:
>>>>>        cv-qualifier:
>>>>> +     address-space-qualifier
>>>>>          __restrict__
>>>>>        Returns a bitmask representing the cv-qualifiers.  */
>>>>> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>>>>>     	  break;
>>>>>     	}
>>>>> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
>>>>> +	  token->keyword <= RID_LAST_ADDR_SPACE)
>>>>> +	cv_qualifier =
>>>>> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
>>>>> +
>>>>>           if (!cv_qualifier)
>>>>>     	break;
>>>>> @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>>>           decl_specs->locations[ds] = location;
>>>>>           if (ds == ds_thread)
>>>>>     	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
>>>>> +      else if (ds == ds_addr_space)
>>>>> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>>>>>         }
>>>>>       else
>>>>>         {
>>>>> @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>>>     	      error_at (&richloc, "duplicate %qD", token->u.value);
>>>>>     	    }
>>>>>     	}
>>>>> +      else if (ds == ds_addr_space)
>>>>> +	{
>>>>> +	  addr_space_t as1 = decl_specs->address_space;
>>>>> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
>>>>> +
>>>>> +	  gcc_rich_location richloc (location);
>>>>> +	  richloc.add_fixit_remove ();
>>>>> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
>>>>> +	      && as1 != as2)
>>>>> +	    error_at (&richloc,
>>>>> +		      "conflicting named address spaces (%s vs %s)",
>>>>> +		      c_addr_space_name (as1), c_addr_space_name (as2));
>>>>> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
>>>>> +	    error_at (&richloc,
>>>>> +		      "duplicate named address space %s",
>>>>> +		      c_addr_space_name (as1));
>>>>> +
>>>>> +	  decl_specs->address_space = as2;
>>>>> +	}
>>>>>           else
>>>>>     	{
>>>>>     	  static const char *const decl_spec_names[] = {
>>>>> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
>>>>> index bef31416fb7..c9d1c01f4ce 100644
>>>>> --- a/gcc/cp/pt.cc
>>>>> +++ b/gcc/cp/pt.cc
>>>>> @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
>>>>>     static int
>>>>>     check_cv_quals_for_unify (int strict, tree arg, tree parm)
>>>>>     {
>>>>> -  int arg_quals = cp_type_quals (arg);
>>>>> -  int parm_quals = cp_type_quals (parm);
>>>>> +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>>>> +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>>>> +
>>>>> +  /*  Try to unify ARG's address space into PARM's address space.
>>>>> +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
>>>>> +      there are no constraints on address spaces for this type.  */
>>>>> +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>>>> +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>>>> +  addr_space_t as_common;
>>>>> +  addr_space_superset (as_arg, as_parm, &as_common);
>>>>> +
>>>>> +  if (!(as_parm == as_common || as_parm == 0))
>>>>> +    return 0;
>>>>>       if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
>>>>>           && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
>>>>> @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
>>>>>     					 arg, parm))
>>>>>     	    return unify_cv_qual_mismatch (explain_p, parm, arg);
>>>>> +	  int arg_cv_quals = cp_type_quals (arg);
>>>>> +	  int parm_cv_quals = cp_type_quals (parm);
>>>>> +
>>>>> +	  /* If PARM does not contain any address space constraints it can
>>>>> +	     fully match the address space of ARG.  However, if PARM contains an
>>>>> +	     address space constraint, it becomes the upper bound.  That is,
>>>>> +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
>>>>> +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
>>>>> +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
>>>>> +	     AS_PARM.  */
>>>>> +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
>>>>> +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
>>>>> +	  addr_space_t as_common = as_parm ? 0 : as_arg;
>>>>> +
>>>>>     	  /* Consider the case where ARG is `const volatile int' and
>>>>>     	     PARM is `const T'.  Then, T should be `volatile int'.  */
>>>>> -	  arg = cp_build_qualified_type_real
>>>>> -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
>>>>> +	  int unified_cv =
>>>>> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
>>>>> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
>>>>> +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
>>>>>     	  if (arg == error_mark_node)
>>>>>     	    return unify_invalid (explain_p);
>>>>> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
>>>>> index 3b37567cbd7..5e14ac837fc 100644
>>>>> --- a/gcc/cp/tree.cc
>>>>> +++ b/gcc/cp/tree.cc
>>>>> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>>>>>         DECL_CHAIN (t) = NULL_TREE;
>>>>>     }
>>>>> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
>>>>> -   FIXME: If address space support is target specific, then this
>>>>> -   should be a C target hook.  But currently this is not possible,
>>>>> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
>>>>> -void
>>>>> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
>>>>> -{
>>>>> -}
>>>>> -
>>>>>     /* Return the number of operands in T that we care about for things like
>>>>>        mangling.  */
>>>>> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
>>>>> index ceb80d9744f..7d810c6a12c 100644
>>>>> --- a/gcc/cp/typeck.cc
>>>>> +++ b/gcc/cp/typeck.cc
>>>>> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>>>>>     	  else
>>>>>     	    return error_mark_node;
>>>>>             }
>>>>> +      /* If possible merge the address space into the superset of the address
>>>>> +	  spaces of t1 and t2, or raise an error. */
>>>>> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
>>>>> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
>>>>> +      addr_space_t as_common;
>>>>> +
>>>>> +      /* If the two named address spaces are different, determine the common
>>>>> +	 superset address space.  If there isn't one, raise an error.  */
>>>>> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
>>>>> +	{
>>>>> +	  as_common = as_t1;
>>>>> +	  error_at (location,
>>>>> +		    "%qT and %qT are in disjoint named address spaces",
>>>>> +		    t1, t2);
>>>>> +	}
>>>>>           result_type
>>>>>     	= cp_build_qualified_type (void_type_node,
>>>>> -				   (cp_type_quals (TREE_TYPE (t1))
>>>>> -				    | cp_type_quals (TREE_TYPE (t2))));
>>>>> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
>>>>> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
>>>>> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>>>>>           result_type = build_pointer_type (result_type);
>>>>>           /* Merge the attributes.  */
>>>>>           attributes = (*targetm.merge_type_attributes) (t1, t2);
>>>>> @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
>>>>>     }
>>>>>     /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
>>>>> -   top-level qualifiers.  */
>>>>> +   top-level qualifiers, except for named address spaces.  If the pointers point
>>>>> +   to different named addresses spaces, then we must determine if one address
>>>>> +   space is a subset of the other.  */
>>>>>     bool
>>>>>     same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>>>> @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>>>>       if (type1 == type2)
>>>>>         return true;
>>>>> +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
>>>>> +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
>>>>> +  addr_space_t as_common;
>>>>> +
>>>>> +  /* Fail if pointers point to incompatible address spaces.  */
>>>>> +  if (!addr_space_superset (as_type1, as_type2, &as_common))
>>>>> +    return false;
>>>>> +
>>>>>       type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
>>>>>       type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
>>>>>       return same_type_p (type1, type2);
>>>>> @@ -6374,10 +6400,32 @@ static tree
>>>>>     pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
>>>>>     	      tsubst_flags_t complain, tree *instrument_expr)
>>>>>     {
>>>>> -  tree result, inttype;
>>>>>       tree restype = ptrdiff_type_node;
>>>>> +  tree result, inttype;
>>>>> +
>>>>> +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
>>>>> +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
>>>>>       tree target_type = TREE_TYPE (ptrtype);
>>>>> +  /* If the operands point into different address spaces, we need to
>>>>> +     explicitly convert them to pointers into the common address space
>>>>> +     before we can subtract the numerical address values.  */
>>>>> +  if (as0 != as1)
>>>>> +    {
>>>>> +      addr_space_t as_common;
>>>>> +      tree common_type;
>>>>> +
>>>>> +      /* Determine the common superset address space.  This is guaranteed
>>>>> +	 to exist because the caller verified that comp_target_types
>>>>> +	 returned non-zero.  */
>>>>> +      if (!addr_space_superset (as0, as1, &as_common))
>>>>> +	gcc_unreachable ();
>>>>> +
>>>>> +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
>>>>> +      op0 = convert (common_type, op0);
>>>>> +      op1 = convert (common_type, op1);
>>>>> +    }
>>>>> +
>>>>>       if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
>>>>>         return error_mark_node;
>>>>> @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>>>>>     	      to_more_cv_qualified = true;
>>>>>     	    }
>>>>> +      /* Warn about conversions between pointers to disjoint
>>>>> +	 address spaces.  */
>>>>> +      if (TREE_CODE (from) == POINTER_TYPE
>>>>> +	  && TREE_CODE (to) == POINTER_TYPE)
>>>>> +	{
>>>>> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
>>>>> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
>>>>> +	  addr_space_t as_common;
>>>>> +
>>>>> +	  if (!addr_space_superset (as_to, as_from, &as_common))
>>>>> +	    return false;
>>>>> +	}
>>>>> +
>>>>>     	  if (constp > 0)
>>>>>     	    constp &= TYPE_READONLY (to);
>>>>>     	}
>>>>> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
>>>>> index ac3db88566d..1e0d436c02c 100644
>>>>> --- a/gcc/doc/extend.texi
>>>>> +++ b/gcc/doc/extend.texi
>>>>> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>>>>>     @section Named Address Spaces
>>>>>     @cindex Named Address Spaces
>>>>> -As an extension, GNU C supports named address spaces as
>>>>> +As an extension, GNU C and GNU C++ support named address spaces as
>>>>>     defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>>>>>     address spaces in GCC will evolve as the draft technical report
>>>>>     changes.  Calling conventions for any target might also change.  At
>>>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>> new file mode 100644
>>>>> index 00000000000..c01f8d6054a
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>> @@ -0,0 +1,10 @@
>>>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>>>> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
>>>>> +
>>>>> +int f (int volatile __seg_fs *a)
>>>>> +{
>>>>> +  return *a;
>>>>> +}
>>>>> +
>>>>> +int main () {}
>>>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>> new file mode 100644
>>>>> index 00000000000..862bbbdcdf2
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>> @@ -0,0 +1,9 @@
>>>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>>>> +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
>>>>> +
>>>>> +template <class T>
>>>>> +int f (T *p) { return *p; }
>>>>> +int g (__seg_fs int *p) { return *p; }
>>>>> +__seg_fs int *a;
>>>>> +int main() { f(a); }
>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>> new file mode 100644
>>>>> index 00000000000..c04d2f497da
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>> @@ -0,0 +1,5 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +__seg_fs char a, b, c;
>>>>> +__seg_fs const int *p;
>>>>> +static /* give internal linkage to the following anonymous struct */
>>>>> +__seg_fs struct { int a; char b; } * __seg_gs q;
>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>> new file mode 100644
>>>>> index 00000000000..86c02d1e7f5
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>> @@ -0,0 +1,20 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +int __seg_fs * fs1;
>>>>> +int __seg_fs * fs2;
>>>>> +float __seg_gs * gs1;
>>>>> +float __seg_gs * gs2;
>>>>> +
>>>>> +int
>>>>> +main ()
>>>>> +{
>>>>> +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
>>>>> +  fs1 - fs2;
>>>>> +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
>>>>> +  fs1 == fs2;
>>>>> +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>>>> +  fs1 = fs2;
>>>>> +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
>>>>> +  fs1 > fs2;
>>>>> +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>>>> +  return 0;
>>>>> +}
>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>> new file mode 100644
>>>>> index 00000000000..12d7975e560
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>> @@ -0,0 +1,31 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +// { dg-prune-output "does not allow .register. storage class specifier" }
>>>>> +int __seg_fs * outer_b;
>>>>> +
>>>>> +struct s {
>>>>> +  __seg_fs int * ok;
>>>>> +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
>>>>> +};
>>>>> +
>>>>> +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
>>>>> +
>>>>> +namespace ns_a
>>>>> +{
>>>>> +  int __seg_fs * inner_b;
>>>>> +
>>>>> +  template<typename T>
>>>>> +  int f (T &a) { return a; }
>>>>> +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
>>>>> +  int h (__seg_fs int *a) { return *a; }
>>>>> +}
>>>>> +
>>>>> +int
>>>>> +main ()
>>>>> +{
>>>>> +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
>>>>> +  static __seg_gs int static_gs;
>>>>> +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
>>>>> +  __seg_fs int *pa = outer_b;
>>>>> +  __seg_fs int& ra = *ns_a::inner_b;
>>>>> +  return ns_a::f(ra) + ns_a::f(*pa);
>>>>> +}
>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
>>>>> new file mode 100644
>>>>> index 00000000000..ebb6316054a
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
>>>>> @@ -0,0 +1,9 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +
>>>>> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
>>>>> +
>>>>> +int
>>>>> +main ()
>>>>> +{
>>>>> +	return 0;
>>>>> +}
>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>> new file mode 100644
>>>>> index 00000000000..2e8ee32a885
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>> @@ -0,0 +1,10 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +// { dg-options "-std=gnu++98" }
>>>>> +
>>>>> +int
>>>>> +main ()
>>>>> +{
>>>>> +	struct foo {int a; char b[2];} structure;
>>>>> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
>>>>> +	return 0;
>>>>> +}
>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>> new file mode 100644
>>>>> index 00000000000..5b2c0f28078
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>> @@ -0,0 +1,9 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +
>>>>> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
>>>>> +
>>>>> +int
>>>>> +main ()
>>>>> +{
>>>>> +	return 0;
>>>>> +}
>>>>> diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>> new file mode 100644
>>>>> index 00000000000..ae9f4de0e1f
>>>>> --- /dev/null
>>>>> +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>> @@ -0,0 +1,8 @@
>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>> +
>>>>> +template <class T>
>>>>> +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
>>>>> +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
>>>>> +__seg_fs int *a;
>>>>> +int main() { f(a); } // { dg-error "no matching" }
>>>>> +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
>>>>> diff --git a/gcc/tree.h b/gcc/tree.h
>>>>> index 8844471e9a5..b7da4c5141a 100644
>>>>> --- a/gcc/tree.h
>>>>> +++ b/gcc/tree.h
>>>>> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>>>>>     /* Encode/decode the named memory support as part of the qualifier.  If more
>>>>>        than 8 qualifiers are added, these macros need to be adjusted.  */
>>>>> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
>>>>> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>>>>>     #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>>>>>     /* Return all qualifiers except for the address space qualifiers.  */
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>>
>>
>>
>>
>>
> 
> 
> 
> 
> 
>
  

On Thu, Oct 13, 2022 at 03:41:16PM -0400, Jason Merrill wrote:
> On 10/13/22 12:02, Paul Iannetta wrote:
> > On Thu, Oct 13, 2022 at 11:47:42AM -0400, Jason Merrill wrote:
> > > On 10/13/22 11:23, Paul Iannetta wrote:
> > > > On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
> > > > > On 10/12/22 20:52, Paul Iannetta wrote:
> > > > > > On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
> > > > > > > 
> > > > > > > It surprises that this is the only place we complain about an object with an
> > > > > > > address-space qualifier.  Shouldn't we also complain about e.g. automatic
> > > > > > > variables/parameters or non-static data members with address-space qualified
> > > > > > > type?
> > > > > > > 
> > > > > > 
> > > > > > Indeed, I was missing quite a few things here.  Thanks.
> > > > > > I used the draft as basis this time and imported from the C
> > > > > > implementation the relevant parts.  This time, the errors get properly
> > > > > > emitted when an address space is unduly specified; and comparisons,
> > > > > > assignments and comparisons are taken care of.
> > > > > > 
> > > > > > There are quite a few things I would like to clarify concerning some
> > > > > > implementation details.
> > > > > >      - A variable with automatic storage (which is neither a pointer nor
> > > > > >        a reference) cannot be qualified with an address space.  I detect
> > > > > >        this by the combination of `sc_none' and `! toplevel_bindings_p ()',
> > > > > >        but I've also seen the use of `at_function_scope' at other places.
> > > > > >        And I'm unsure which one is appropriate here.
> > > > > >        This detection happens at the very end of grokdeclarator because I
> > > > > >        need to know that the type is a pointer, which is not know until
> > > > > >        very late in the function.
> > > > > 
> > > > > At that point you have the decl, and you can ask directly what its storage
> > > > > duration is, perhaps using decl_storage_duration.
> > > > > 
> > > > > But why do you need to know whether the type is a pointer?  The attribute
> > > > > applies to the target type of the pointer, not the pointer type.  I think
> > > > > the problem is that you're looking at declspecs when you ought to be looking
> > > > > at type_quals.
> > > > 
> > > > I need to know that the base type is a pointer to reject invalid
> > > > declarations such as:
> > > > 
> > > >       int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }
> > > > 
> > > > because parameters and auto variables can have an address space
> > > > qualifier only if they are pointer or reference type, which I can't
> > > > tell only from type_quals.
> > > 
> > > But "int *__seg_fs a" is just as invalid as the above; the difference is not
> > > whether a is a pointer, but whether the address-space-qualified is the type
> > > of a itself or some sub-type.
> > 
> > I agree that "int * __seg_fs a" is invalid but it is accepted by the C
> > front-end, and by clang (both C and C++), the behavior is that the
> > address-name is silently ignored.
> 
> Hmm, that sounds like a bug; in that case, presumably the user meant to
> qualify the pointed-to type, and silently ignoring seems unlikely to give
> the effect they want.
> 

Well, actually, I'm re-reading the draft and "int * __seg_fs a" is
valid.  It means "pointer in address space __seg_fs pointing to an
object in the generic address space", whereas "__seg_fs int * a" means
"pointer in the generic address space pointing to an object in the
__seg_fs address-space".

Oddities such as, "__seg_fs int * __seg_gs a" are also perfectly
valid.

The reason why I wrongly assumed that the address space was silently
ignored is that I made a simple test which only relied on the mangled
function name...

```
int * __seg_fs a;
template <typename T> int f (T *a) { return *a; }
int main () { return f (a); } // f<int>(int*), since a is in __seg_fs
                              // but the pointer is to the generic
                              // address-space.
```

Implementation-wise, I think I handle that correctly but I'll do a recheck.

> > > You need to look at the qualifiers on type (which should also be the ones in
> > > type_quals), not the qualifiers in the declspecs.
> > 
> > I'll have another look, thanks.
> > 
> > > > > >      - I'm having some trouble deciding whether I include those three
> > > > > >        stub programs as tests, they all compile fine and clang accepts
> > > > > >        them as well.
> > > > > 
> > > > > Why not?
> > > > 
> > > > I thought they were pretty contrived, since it does not make much
> > > > sense to strip address space qualifiers, even though it does prove
> > > > that the implementation support those contrived but valid uses.
> > > 
> > > Testcases are full of contrived examples testing corner cases.  :)
> > > 
> > > > > 
> > > > > > Ex1:
> > > > > > ```
> > > > > > int __seg_fs * fs1;
> > > > > > int __seg_gs * gs1;
> > > > > > 
> > > > > > template<typename T> struct strip;
> > > > > > template<typename T> struct strip<__seg_fs T *> { typedef T type; };
> > > > > > template<typename T> struct strip<__seg_gs T *> { typedef T type; };
> > > > > > 
> > > > > > int
> > > > > > main ()
> > > > > > {
> > > > > >        *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
> > > > > >        return 0;
> > > > > > }
> > > > > > ```
> > > > > > 
> > > > > > Ex2:
> > > > > > ```
> > > > > > int __seg_fs * fs1;
> > > > > > int __seg_fs * fs2;
> > > > > > 
> > > > > > template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
> > > > > > template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
> > > > > > 
> > > > > > int
> > > > > > main ()
> > > > > > {
> > > > > >        f (fs1, gs1);
> > > > > >        f (gs1, fs1);
> > > > > >        return 0;
> > > > > > }
> > > > > > ```
> > > > > > 
> > > > > > Ex3:
> > > > > > ```
> > > > > > int __seg_fs * fs1;
> > > > > > int __seg_gs * gs1;
> > > > > > 
> > > > > > template<typename T, typename U>
> > > > > > auto f (T __seg_fs * a, U __seg_gs * b)
> > > > > > {
> > > > > >        return *(T *) a == *(U *) b;
> > > > > > }
> > > > > > 
> > > > > > int
> > > > > > main ()
> > > > > > {
> > > > > >        return f (fs1, gs1);
> > > > > > }
> > > > > > ```
> > > > > > 
> > > > > > 
> > > > > > Add support for custom address spaces in C++
> > > > > > 
> > > > > > gcc/
> > > > > >            * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
> > > > > > 
> > > > > > gcc/c/
> > > > > >            * c-decl.cc: Remove c_register_addr_space.
> > > > > > 
> > > > > > gcc/c-family/
> > > > > >            * c-common.cc (c_register_addr_space): Imported from c-decl.cc
> > > > > >            (addr_space_superset): Imported from gcc/c/c-typecheck.cc
> > > > > >            * c-common.h: Remove the FIXME.
> > > > > >            (addr_space_superset): New declaration.
> > > > > > 
> > > > > > gcc/cp/
> > > > > >            * cp-tree.h (enum cp_decl_spec): Add addr_space support.
> > > > > >            (struct cp_decl_specifier_seq): Likewise.
> > > > > >            * decl.cc (get_type_quals): Likewise.
> > > > > >            (check_tag_decl): Likewise.
> > > > > > 	(grokdeclarator): Likewise.
> > > > > >            * parser.cc (cp_parser_type_specifier): Likewise.
> > > > > >            (cp_parser_cv_qualifier_seq_opt): Likewise.
> > > > > >            (cp_parser_postfix_expression): Likewise.
> > > > > >            (cp_parser_type_specifier): Likewise.
> > > > > >            (set_and_check_decl_spec_loc): Likewise.
> > > > > >            * typeck.cc (composite_pointer_type): Likewise
> > > > > >            (comp_ptr_ttypes_real): Likewise.
> > > > > > 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
> > > > > >            * pt.cc (check_cv_quals_for_unify): Likewise.
> > > > > >            (unify): Likewise.
> > > > > >            * tree.cc: Remove c_register_addr_space stub.
> > > > > >            * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
> > > > > >              using the extended qualifier notation.
> > > > > > 
> > > > > > gcc/doc
> > > > > >            * extend.texi (Named Address Spaces): add a mention about C++
> > > > > >              support.
> > > > > > 
> > > > > > gcc/testsuite/
> > > > > >            * g++.dg/abi/mangle-addr-space1.C: New test.
> > > > > >            * g++.dg/abi/mangle-addr-space2.C: New test.
> > > > > >            * g++.dg/parse/addr-space.C: New test.
> > > > > >            * g++.dg/parse/addr-space1.C: New test.
> > > > > >            * g++.dg/parse/addr-space2.C: New test.
> > > > > >            * g++.dg/parse/template/spec-addr-space.C: New test.
> > > > > >            * g++.dg/ext/addr-space-decl.C: New test.
> > > > > >            * g++.dg/ext/addr-space-ref.C: New test.
> > > > > >            * g++.dg/ext/addr-space-ops.C: New test.
> > > > > > 
> > > > > > # Please enter the commit message for your changes. Lines starting
> > > > > > # with '#' will be ignored, and an empty message aborts the commit.
> > > > > > #
> > > > > > # Date:      Sun Oct 9 16:02:22 2022 +0200
> > > > > > #
> > > > > > # On branch releases/gcc-12
> > > > > > # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
> > > > > > #   (use "git push" to publish your local commits)
> > > > > > #
> > > > > > # Changes to be committed:
> > > > > > #	modified:   gcc/c-family/c-common.cc
> > > > > > #	modified:   gcc/c-family/c-common.h
> > > > > > #	modified:   gcc/c/c-decl.cc
> > > > > > #	modified:   gcc/c/c-typeck.cc
> > > > > > #	modified:   gcc/cp/cp-tree.h
> > > > > > #	modified:   gcc/cp/decl.cc
> > > > > > #	modified:   gcc/cp/mangle.cc
> > > > > > #	modified:   gcc/cp/parser.cc
> > > > > > #	modified:   gcc/cp/pt.cc
> > > > > > #	modified:   gcc/cp/tree.cc
> > > > > > #	modified:   gcc/cp/typeck.cc
> > > > > > #	modified:   gcc/doc/extend.texi
> > > > > > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > > > #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > > > #	modified:   gcc/tree.h
> > > > > > #
> > > > > > # Untracked files:
> > > > > > #	Makefile
> > > > > > #	addr-space-decl.C
> > > > > > #	addr-space-decl.s
> > > > > > #	addr-space-ops.C
> > > > > > #	addr-space-ref.C
> > > > > > #	addr-space-template.C
> > > > > > #	addr-space-template.s
> > > > > > #	addr-space-template2.C
> > > > > > #	addr-space-template2.C.006t.gimple
> > > > > > #	addr-space-template2.s
> > > > > > #	addr-space-traits.C
> > > > > > #	addr-space4.C
> > > > > > #	addr-space4.C.006t.gimple
> > > > > > #	addr-space4.s
> > > > > > #	build-x86_64-pc-linux-gnu/
> > > > > > #	compare
> > > > > > #	host-x86_64-pc-linux-gnu/
> > > > > > #	mangle-addr-space1.s
> > > > > > #	prev-x86_64-pc-linux-gnu/
> > > > > > #	rename
> > > > > > #	stage1-x86_64-pc-linux-gnu/
> > > > > > #	stage_current
> > > > > > #	stage_final
> > > > > > #	stage_last
> > > > > > #	x86_64-pc-linux-gnu/
> > > > > > #
> > > > > > # ------------------------ >8 ------------------------
> > > > > > # Do not modify or remove the line above.
> > > > > > # Everything below it will be ignored.
> > > > > > diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> > > > > > index bb0544eeaea..ff1146ecc25 100644
> > > > > > --- a/gcc/c-family/c-common.cc
> > > > > > +++ b/gcc/c-family/c-common.cc
> > > > > > @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
> > > > > >       return IDENTIFIER_POINTER (ridpointers [rid]);
> > > > > >     }
> > > > > > +/* Return true if between two named address spaces, whether there is a superset
> > > > > > +   named address space that encompasses both address spaces.  If there is a
> > > > > > +   superset, return which address space is the superset.  */
> > > > > > +
> > > > > > +bool
> > > > > > +addr_space_superset (addr_space_t as1, addr_space_t as2,
> > > > > > +		     addr_space_t * common)
> > > > > > +{
> > > > > > +  if (as1 == as2)
> > > > > > +    {
> > > > > > +      *common = as1;
> > > > > > +      return true;
> > > > > > +    }
> > > > > > +  else if (targetm.addr_space.subset_p (as1, as2))
> > > > > > +    {
> > > > > > +      *common = as2;
> > > > > > +      return true;
> > > > > > +    }
> > > > > > +  else if (targetm.addr_space.subset_p (as2, as1))
> > > > > > +    {
> > > > > > +      *common = as1;
> > > > > > +      return true;
> > > > > > +    }
> > > > > > +  else
> > > > > > +    return false;
> > > > > > +}
> > > > > > +
> > > > > >     /* Push current bindings for the function name VAR_DECLS.  */
> > > > > >     void
> > > > > > @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
> > > > > >       return build_nonstandard_integer_type (width, unsignedp);
> > > > > >     }
> > > > > > +/* Register reserved keyword WORD as qualifier for address space AS.  */
> > > > > > +
> > > > > > +void
> > > > > > +c_register_addr_space (const char *word, addr_space_t as)
> > > > > > +{
> > > > > > +  int rid = RID_FIRST_ADDR_SPACE + as;
> > > > > > +  tree id;
> > > > > > +
> > > > > > +  /* Address space qualifiers are only supported
> > > > > > +     in C with GNU extensions enabled.  */
> > > > > > +  if (c_dialect_objc () || flag_no_asm)
> > > > > > +    return;
> > > > > > +
> > > > > > +  id = get_identifier (word);
> > > > > > +  C_SET_RID_CODE (id, rid);
> > > > > > +  TREE_LANG_FLAG_0 (id) = 1;
> > > > > > +  ridpointers[rid] = id;
> > > > > > +}
> > > > > > +
> > > > > >     /* The C version of the register_builtin_type langhook.  */
> > > > > >     void
> > > > > > diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> > > > > > index 52a85bfb783..d36f9e4975b 100644
> > > > > > --- a/gcc/c-family/c-common.h
> > > > > > +++ b/gcc/c-family/c-common.h
> > > > > > @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
> > > > > >     extern tree (*make_fname_decl) (location_t, tree, int);
> > > > > > -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
> > > > > > -extern void c_register_addr_space (const char *str, addr_space_t as);
> > > > > > -
> > > > > >     /* In c-common.cc.  */
> > > > > >     extern bool in_late_binary_op;
> > > > > >     extern const char *c_addr_space_name (addr_space_t as);
> > > > > > +extern const char *c_addr_space_name (addr_space_t as);
> > > > > > +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
> > > > > >     extern tree identifier_global_value (tree);
> > > > > >     extern tree identifier_global_tag (tree);
> > > > > >     extern bool names_builtin_p (const char *);
> > > > > > @@ -952,6 +951,7 @@ extern void c_common_finish (void);
> > > > > >     extern void c_common_parse_file (void);
> > > > > >     extern FILE *get_dump_info (int, dump_flags_t *);
> > > > > >     extern alias_set_type c_common_get_alias_set (tree);
> > > > > > +extern void c_register_addr_space (const char *, addr_space_t);
> > > > > >     extern void c_register_builtin_type (tree, const char*);
> > > > > >     extern bool c_promoting_integer_type_p (const_tree);
> > > > > >     extern bool self_promoting_args_p (const_tree);
> > > > > > diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> > > > > > index c701f07befe..e1bb4f1cf37 100644
> > > > > > --- a/gcc/c/c-decl.cc
> > > > > > +++ b/gcc/c/c-decl.cc
> > > > > > @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
> > > > > >       ext_block = NULL;
> > > > > >     }
> > > > > > -/* Register reserved keyword WORD as qualifier for address space AS.  */
> > > > > > -
> > > > > > -void
> > > > > > -c_register_addr_space (const char *word, addr_space_t as)
> > > > > > -{
> > > > > > -  int rid = RID_FIRST_ADDR_SPACE + as;
> > > > > > -  tree id;
> > > > > > -
> > > > > > -  /* Address space qualifiers are only supported
> > > > > > -     in C with GNU extensions enabled.  */
> > > > > > -  if (c_dialect_objc () || flag_no_asm)
> > > > > > -    return;
> > > > > > -
> > > > > > -  id = get_identifier (word);
> > > > > > -  C_SET_RID_CODE (id, rid);
> > > > > > -  C_IS_RESERVED_WORD (id) = 1;
> > > > > > -  ridpointers [rid] = id;
> > > > > > -}
> > > > > > -
> > > > > >     /* Return identifier to look up for omp declare reduction.  */
> > > > > >     tree
> > > > > > diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
> > > > > > index b271af9bedb..c4b01368534 100644
> > > > > > --- a/gcc/c/c-typeck.cc
> > > > > > +++ b/gcc/c/c-typeck.cc
> > > > > > @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
> > > > > >       return type;
> > > > > >     }
> > > > > > -/* Return true if between two named address spaces, whether there is a superset
> > > > > > -   named address space that encompasses both address spaces.  If there is a
> > > > > > -   superset, return which address space is the superset.  */
> > > > > > -
> > > > > > -static bool
> > > > > > -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
> > > > > > -{
> > > > > > -  if (as1 == as2)
> > > > > > -    {
> > > > > > -      *common = as1;
> > > > > > -      return true;
> > > > > > -    }
> > > > > > -  else if (targetm.addr_space.subset_p (as1, as2))
> > > > > > -    {
> > > > > > -      *common = as2;
> > > > > > -      return true;
> > > > > > -    }
> > > > > > -  else if (targetm.addr_space.subset_p (as2, as1))
> > > > > > -    {
> > > > > > -      *common = as1;
> > > > > > -      return true;
> > > > > > -    }
> > > > > > -  else
> > > > > > -    return false;
> > > > > > -}
> > > > > > -
> > > > > >     /* Return a variant of TYPE which has all the type qualifiers of LIKE
> > > > > >        as well as those of TYPE.  */
> > > > > > diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> > > > > > index 72f4398a8f9..82a6d72f5df 100644
> > > > > > --- a/gcc/cp/cp-tree.h
> > > > > > +++ b/gcc/cp/cp-tree.h
> > > > > > @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
> > > > > >       ds_const,
> > > > > >       ds_volatile,
> > > > > >       ds_restrict,
> > > > > > +  ds_addr_space,
> > > > > >       ds_inline,
> > > > > >       ds_virtual,
> > > > > >       ds_explicit,
> > > > > > @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
> > > > > >       cp_storage_class storage_class;
> > > > > >       /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
> > > > > >       int int_n_idx;
> > > > > > +  /* The address space that the declaration belongs to.  */
> > > > > > +  addr_space_t address_space;
> > > > > >       /* True iff TYPE_SPEC defines a class or enum.  */
> > > > > >       BOOL_BITFIELD type_definition_p : 1;
> > > > > >       /* True iff multiple types were (erroneously) specified for this
> > > > > > diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> > > > > > index 9f78c500a15..fa5a1ddb21d 100644
> > > > > > --- a/gcc/cp/decl.cc
> > > > > > +++ b/gcc/cp/decl.cc
> > > > > > @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
> > > > > >         type_quals |= TYPE_QUAL_VOLATILE;
> > > > > >       if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
> > > > > >         type_quals |= TYPE_QUAL_RESTRICT;
> > > > > > +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > > > > > +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
> > > > > >       return type_quals;
> > > > > >     }
> > > > > > @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
> > > > > >     	error_at (declspecs->locations[ds_restrict],
> > > > > >     		  "%<__restrict%> can only be specified for objects and "
> > > > > >     		  "functions");
> > > > > > +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
> > > > > > +	error_at (declspecs->locations[ds_addr_space],
> > > > > > +		  "address space can only be specified for objects and "
> > > > > > +		  "functions");
> > > > > >           else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
> > > > > >     	error_at (declspecs->locations[ds_thread],
> > > > > >     		  "%<__thread%> can only be specified for objects "
> > > > > > @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
> > > > > >         if (!processing_template_decl)
> > > > > >           cp_apply_type_quals_to_decl (type_quals, decl);
> > > > > > +    addr_space_t address_space = declspecs->address_space;
> > > > > > +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
> > > > > > +      {
> > > > > > +	if (decl_context == NORMAL)
> > > > > > +	  {
> > > > > > +	    switch (storage_class)
> > > > > > +	      {
> > > > > > +	      case sc_auto:
> > > > > > +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
> > > > > > +		       c_addr_space_name (address_space), name);
> > > > > > +		break;
> > > > > > +	      case sc_register:
> > > > > > +		error ("%qs combined with %<register%> qualifier for %qs",
> > > > > > +		       c_addr_space_name (address_space), name);
> > > > > > +		break;
> > > > > > +	      case sc_none:
> > > > > > +		if (! toplevel_bindings_p ())
> > > > > > +		  error ("%qs specified for auto variable %qs",
> > > > > > +			 c_addr_space_name (address_space), name);
> > > > > > +		break;
> > > > > > +	      case sc_mutable:
> > > > > > +		error ("%qs combined with %<mutable%> qualifier for %qs",
> > > > > > +		       c_addr_space_name (address_space), name);
> > > > > > +		break;
> > > > > > +	      case sc_static:
> > > > > > +	      case sc_extern:
> > > > > > +		break;
> > > > > > +	      default:
> > > > > > +		gcc_unreachable ();
> > > > > > +	      }
> > > > > > +	  }
> > > > > > +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
> > > > > > +	  {
> > > > > > +	    if (name)
> > > > > > +	      error ("%qs specified for parameter %qs",
> > > > > > +		     c_addr_space_name (address_space), name);
> > > > > > +	    else
> > > > > > +	      error ("%qs specified for unnamed parameter",
> > > > > > +		     c_addr_space_name (address_space));
> > > > > > +	  }
> > > > > > +	else if (decl_context == FIELD)
> > > > > > +	  {
> > > > > > +	    if (name)
> > > > > > +	      error ("%qs specified for structure field %qs",
> > > > > > +		     c_addr_space_name (address_space), name);
> > > > > > +	    else
> > > > > > +	      error ("%qs specified for structure field",
> > > > > > +		     c_addr_space_name (address_space));
> > > > > > +	  }
> > > > > > +      }
> > > > > > +
> > > > > >         return decl;
> > > > > >       }
> > > > > >     }
> > > > > > diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> > > > > > index eb53e0ebeb4..16cb2ff4332 100644
> > > > > > --- a/gcc/cp/mangle.cc
> > > > > > +++ b/gcc/cp/mangle.cc
> > > > > > @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
> > > > > >          array.  */
> > > > > >       cp_cv_quals quals = TYPE_QUALS (type);
> > > > > > +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
> > > > > > +    {
> > > > > > +      const char *as_name = c_addr_space_name (as);
> > > > > > +      write_char ('U');
> > > > > > +      write_unsigned_number (strlen (as_name));
> > > > > > +      write_string (as_name);
> > > > > > +      ++num_qualifiers;
> > > > > > +    }
> > > > > >       if (quals & TYPE_QUAL_RESTRICT)
> > > > > >         {
> > > > > >           write_char ('r');
> > > > > > diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> > > > > > index 763df6f479b..f0169d83ab0 100644
> > > > > > --- a/gcc/cp/parser.cc
> > > > > > +++ b/gcc/cp/parser.cc
> > > > > > @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
> > > > > >     		    postfix_expression = error_mark_node;
> > > > > >     		    break;
> > > > > >     		  }
> > > > > > +		if (type != error_mark_node
> > > > > > +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
> > > > > > +		    && current_function_decl)
> > > > > > +		  {
> > > > > > +		    error
> > > > > > +		      ("compound literal qualified by address-space qualifier");
> > > > > > +		    type = error_mark_node;
> > > > > > +		  }
> > > > > >     		/* Form the representation of the compound-literal.  */
> > > > > >     		postfix_expression
> > > > > >     		  = finish_compound_literal (type, initializer,
> > > > > > @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
> > > > > >           break;
> > > > > >         }
> > > > > > +
> > > > > > +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
> > > > > > +    {
> > > > > > +      ds = ds_addr_space;
> > > > > > +      if (is_cv_qualifier)
> > > > > > +	*is_cv_qualifier = true;
> > > > > > +    }
> > > > > > +
> > > > > > +
> > > > > >       /* Handle simple keywords.  */
> > > > > >       if (ds != ds_last)
> > > > > >         {
> > > > > > @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
> > > > > >        GNU Extension:
> > > > > >        cv-qualifier:
> > > > > > +     address-space-qualifier
> > > > > >          __restrict__
> > > > > >        Returns a bitmask representing the cv-qualifiers.  */
> > > > > > @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
> > > > > >     	  break;
> > > > > >     	}
> > > > > > +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
> > > > > > +	  token->keyword <= RID_LAST_ADDR_SPACE)
> > > > > > +	cv_qualifier =
> > > > > > +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
> > > > > > +
> > > > > >           if (!cv_qualifier)
> > > > > >     	break;
> > > > > > @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> > > > > >           decl_specs->locations[ds] = location;
> > > > > >           if (ds == ds_thread)
> > > > > >     	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
> > > > > > +      else if (ds == ds_addr_space)
> > > > > > +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
> > > > > >         }
> > > > > >       else
> > > > > >         {
> > > > > > @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
> > > > > >     	      error_at (&richloc, "duplicate %qD", token->u.value);
> > > > > >     	    }
> > > > > >     	}
> > > > > > +      else if (ds == ds_addr_space)
> > > > > > +	{
> > > > > > +	  addr_space_t as1 = decl_specs->address_space;
> > > > > > +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
> > > > > > +
> > > > > > +	  gcc_rich_location richloc (location);
> > > > > > +	  richloc.add_fixit_remove ();
> > > > > > +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
> > > > > > +	      && as1 != as2)
> > > > > > +	    error_at (&richloc,
> > > > > > +		      "conflicting named address spaces (%s vs %s)",
> > > > > > +		      c_addr_space_name (as1), c_addr_space_name (as2));
> > > > > > +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
> > > > > > +	    error_at (&richloc,
> > > > > > +		      "duplicate named address space %s",
> > > > > > +		      c_addr_space_name (as1));
> > > > > > +
> > > > > > +	  decl_specs->address_space = as2;
> > > > > > +	}
> > > > > >           else
> > > > > >     	{
> > > > > >     	  static const char *const decl_spec_names[] = {
> > > > > > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> > > > > > index bef31416fb7..c9d1c01f4ce 100644
> > > > > > --- a/gcc/cp/pt.cc
> > > > > > +++ b/gcc/cp/pt.cc
> > > > > > @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
> > > > > >     static int
> > > > > >     check_cv_quals_for_unify (int strict, tree arg, tree parm)
> > > > > >     {
> > > > > > -  int arg_quals = cp_type_quals (arg);
> > > > > > -  int parm_quals = cp_type_quals (parm);
> > > > > > +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > > > > > +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > > > > > +
> > > > > > +  /*  Try to unify ARG's address space into PARM's address space.
> > > > > > +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
> > > > > > +      there are no constraints on address spaces for this type.  */
> > > > > > +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
> > > > > > +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
> > > > > > +  addr_space_t as_common;
> > > > > > +  addr_space_superset (as_arg, as_parm, &as_common);
> > > > > > +
> > > > > > +  if (!(as_parm == as_common || as_parm == 0))
> > > > > > +    return 0;
> > > > > >       if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
> > > > > >           && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
> > > > > > @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
> > > > > >     					 arg, parm))
> > > > > >     	    return unify_cv_qual_mismatch (explain_p, parm, arg);
> > > > > > +	  int arg_cv_quals = cp_type_quals (arg);
> > > > > > +	  int parm_cv_quals = cp_type_quals (parm);
> > > > > > +
> > > > > > +	  /* If PARM does not contain any address space constraints it can
> > > > > > +	     fully match the address space of ARG.  However, if PARM contains an
> > > > > > +	     address space constraint, it becomes the upper bound.  That is,
> > > > > > +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
> > > > > > +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
> > > > > > +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
> > > > > > +	     AS_PARM.  */
> > > > > > +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
> > > > > > +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
> > > > > > +	  addr_space_t as_common = as_parm ? 0 : as_arg;
> > > > > > +
> > > > > >     	  /* Consider the case where ARG is `const volatile int' and
> > > > > >     	     PARM is `const T'.  Then, T should be `volatile int'.  */
> > > > > > -	  arg = cp_build_qualified_type_real
> > > > > > -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
> > > > > > +	  int unified_cv =
> > > > > > +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
> > > > > > +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
> > > > > > +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
> > > > > >     	  if (arg == error_mark_node)
> > > > > >     	    return unify_invalid (explain_p);
> > > > > > diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
> > > > > > index 3b37567cbd7..5e14ac837fc 100644
> > > > > > --- a/gcc/cp/tree.cc
> > > > > > +++ b/gcc/cp/tree.cc
> > > > > > @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
> > > > > >         DECL_CHAIN (t) = NULL_TREE;
> > > > > >     }
> > > > > > -/* Stub for c-common.  Please keep in sync with c-decl.cc.
> > > > > > -   FIXME: If address space support is target specific, then this
> > > > > > -   should be a C target hook.  But currently this is not possible,
> > > > > > -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
> > > > > > -void
> > > > > > -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
> > > > > > -{
> > > > > > -}
> > > > > > -
> > > > > >     /* Return the number of operands in T that we care about for things like
> > > > > >        mangling.  */
> > > > > > diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> > > > > > index ceb80d9744f..7d810c6a12c 100644
> > > > > > --- a/gcc/cp/typeck.cc
> > > > > > +++ b/gcc/cp/typeck.cc
> > > > > > @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
> > > > > >     	  else
> > > > > >     	    return error_mark_node;
> > > > > >             }
> > > > > > +      /* If possible merge the address space into the superset of the address
> > > > > > +	  spaces of t1 and t2, or raise an error. */
> > > > > > +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
> > > > > > +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
> > > > > > +      addr_space_t as_common;
> > > > > > +
> > > > > > +      /* If the two named address spaces are different, determine the common
> > > > > > +	 superset address space.  If there isn't one, raise an error.  */
> > > > > > +      if (!addr_space_superset (as_t1, as_t2, &as_common))
> > > > > > +	{
> > > > > > +	  as_common = as_t1;
> > > > > > +	  error_at (location,
> > > > > > +		    "%qT and %qT are in disjoint named address spaces",
> > > > > > +		    t1, t2);
> > > > > > +	}
> > > > > >           result_type
> > > > > >     	= cp_build_qualified_type (void_type_node,
> > > > > > -				   (cp_type_quals (TREE_TYPE (t1))
> > > > > > -				    | cp_type_quals (TREE_TYPE (t2))));
> > > > > > +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
> > > > > > +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
> > > > > > +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
> > > > > >           result_type = build_pointer_type (result_type);
> > > > > >           /* Merge the attributes.  */
> > > > > >           attributes = (*targetm.merge_type_attributes) (t1, t2);
> > > > > > @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
> > > > > >     }
> > > > > >     /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
> > > > > > -   top-level qualifiers.  */
> > > > > > +   top-level qualifiers, except for named address spaces.  If the pointers point
> > > > > > +   to different named addresses spaces, then we must determine if one address
> > > > > > +   space is a subset of the other.  */
> > > > > >     bool
> > > > > >     same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> > > > > > @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
> > > > > >       if (type1 == type2)
> > > > > >         return true;
> > > > > > +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
> > > > > > +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
> > > > > > +  addr_space_t as_common;
> > > > > > +
> > > > > > +  /* Fail if pointers point to incompatible address spaces.  */
> > > > > > +  if (!addr_space_superset (as_type1, as_type2, &as_common))
> > > > > > +    return false;
> > > > > > +
> > > > > >       type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
> > > > > >       type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
> > > > > >       return same_type_p (type1, type2);
> > > > > > @@ -6374,10 +6400,32 @@ static tree
> > > > > >     pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
> > > > > >     	      tsubst_flags_t complain, tree *instrument_expr)
> > > > > >     {
> > > > > > -  tree result, inttype;
> > > > > >       tree restype = ptrdiff_type_node;
> > > > > > +  tree result, inttype;
> > > > > > +
> > > > > > +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
> > > > > > +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
> > > > > >       tree target_type = TREE_TYPE (ptrtype);
> > > > > > +  /* If the operands point into different address spaces, we need to
> > > > > > +     explicitly convert them to pointers into the common address space
> > > > > > +     before we can subtract the numerical address values.  */
> > > > > > +  if (as0 != as1)
> > > > > > +    {
> > > > > > +      addr_space_t as_common;
> > > > > > +      tree common_type;
> > > > > > +
> > > > > > +      /* Determine the common superset address space.  This is guaranteed
> > > > > > +	 to exist because the caller verified that comp_target_types
> > > > > > +	 returned non-zero.  */
> > > > > > +      if (!addr_space_superset (as0, as1, &as_common))
> > > > > > +	gcc_unreachable ();
> > > > > > +
> > > > > > +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
> > > > > > +      op0 = convert (common_type, op0);
> > > > > > +      op1 = convert (common_type, op1);
> > > > > > +    }
> > > > > > +
> > > > > >       if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
> > > > > >         return error_mark_node;
> > > > > > @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
> > > > > >     	      to_more_cv_qualified = true;
> > > > > >     	    }
> > > > > > +      /* Warn about conversions between pointers to disjoint
> > > > > > +	 address spaces.  */
> > > > > > +      if (TREE_CODE (from) == POINTER_TYPE
> > > > > > +	  && TREE_CODE (to) == POINTER_TYPE)
> > > > > > +	{
> > > > > > +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
> > > > > > +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
> > > > > > +	  addr_space_t as_common;
> > > > > > +
> > > > > > +	  if (!addr_space_superset (as_to, as_from, &as_common))
> > > > > > +	    return false;
> > > > > > +	}
> > > > > > +
> > > > > >     	  if (constp > 0)
> > > > > >     	    constp &= TYPE_READONLY (to);
> > > > > >     	}
> > > > > > diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> > > > > > index ac3db88566d..1e0d436c02c 100644
> > > > > > --- a/gcc/doc/extend.texi
> > > > > > +++ b/gcc/doc/extend.texi
> > > > > > @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
> > > > > >     @section Named Address Spaces
> > > > > >     @cindex Named Address Spaces
> > > > > > -As an extension, GNU C supports named address spaces as
> > > > > > +As an extension, GNU C and GNU C++ support named address spaces as
> > > > > >     defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
> > > > > >     address spaces in GCC will evolve as the draft technical report
> > > > > >     changes.  Calling conventions for any target might also change.  At
> > > > > > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..c01f8d6054a
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
> > > > > > @@ -0,0 +1,10 @@
> > > > > > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > > > > > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > > > > > +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
> > > > > > +
> > > > > > +int f (int volatile __seg_fs *a)
> > > > > > +{
> > > > > > +  return *a;
> > > > > > +}
> > > > > > +
> > > > > > +int main () {}
> > > > > > diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..862bbbdcdf2
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
> > > > > > @@ -0,0 +1,9 @@
> > > > > > +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
> > > > > > +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
> > > > > > +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
> > > > > > +
> > > > > > +template <class T>
> > > > > > +int f (T *p) { return *p; }
> > > > > > +int g (__seg_fs int *p) { return *p; }
> > > > > > +__seg_fs int *a;
> > > > > > +int main() { f(a); }
> > > > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..c04d2f497da
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
> > > > > > @@ -0,0 +1,5 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +__seg_fs char a, b, c;
> > > > > > +__seg_fs const int *p;
> > > > > > +static /* give internal linkage to the following anonymous struct */
> > > > > > +__seg_fs struct { int a; char b; } * __seg_gs q;
> > > > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..86c02d1e7f5
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
> > > > > > @@ -0,0 +1,20 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +int __seg_fs * fs1;
> > > > > > +int __seg_fs * fs2;
> > > > > > +float __seg_gs * gs1;
> > > > > > +float __seg_gs * gs2;
> > > > > > +
> > > > > > +int
> > > > > > +main ()
> > > > > > +{
> > > > > > +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
> > > > > > +  fs1 - fs2;
> > > > > > +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
> > > > > > +  fs1 == fs2;
> > > > > > +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > > > > > +  fs1 = fs2;
> > > > > > +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
> > > > > > +  fs1 > fs2;
> > > > > > +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
> > > > > > +  return 0;
> > > > > > +}
> > > > > > diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..12d7975e560
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
> > > > > > @@ -0,0 +1,31 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +// { dg-prune-output "does not allow .register. storage class specifier" }
> > > > > > +int __seg_fs * outer_b;
> > > > > > +
> > > > > > +struct s {
> > > > > > +  __seg_fs int * ok;
> > > > > > +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
> > > > > > +};
> > > > > > +
> > > > > > +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
> > > > > > +
> > > > > > +namespace ns_a
> > > > > > +{
> > > > > > +  int __seg_fs * inner_b;
> > > > > > +
> > > > > > +  template<typename T>
> > > > > > +  int f (T &a) { return a; }
> > > > > > +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
> > > > > > +  int h (__seg_fs int *a) { return *a; }
> > > > > > +}
> > > > > > +
> > > > > > +int
> > > > > > +main ()
> > > > > > +{
> > > > > > +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
> > > > > > +  static __seg_gs int static_gs;
> > > > > > +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
> > > > > > +  __seg_fs int *pa = outer_b;
> > > > > > +  __seg_fs int& ra = *ns_a::inner_b;
> > > > > > +  return ns_a::f(ra) + ns_a::f(*pa);
> > > > > > +}
> > > > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..ebb6316054a
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
> > > > > > @@ -0,0 +1,9 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +
> > > > > > +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
> > > > > > +
> > > > > > +int
> > > > > > +main ()
> > > > > > +{
> > > > > > +	return 0;
> > > > > > +}
> > > > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..2e8ee32a885
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
> > > > > > @@ -0,0 +1,10 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +// { dg-options "-std=gnu++98" }
> > > > > > +
> > > > > > +int
> > > > > > +main ()
> > > > > > +{
> > > > > > +	struct foo {int a; char b[2];} structure;
> > > > > > +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
> > > > > > +	return 0;
> > > > > > +}
> > > > > > diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..5b2c0f28078
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
> > > > > > @@ -0,0 +1,9 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +
> > > > > > +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
> > > > > > +
> > > > > > +int
> > > > > > +main ()
> > > > > > +{
> > > > > > +	return 0;
> > > > > > +}
> > > > > > diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > > > new file mode 100644
> > > > > > index 00000000000..ae9f4de0e1f
> > > > > > --- /dev/null
> > > > > > +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
> > > > > > @@ -0,0 +1,8 @@
> > > > > > +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
> > > > > > +
> > > > > > +template <class T>
> > > > > > +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
> > > > > > +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
> > > > > > +__seg_fs int *a;
> > > > > > +int main() { f(a); } // { dg-error "no matching" }
> > > > > > +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
> > > > > > diff --git a/gcc/tree.h b/gcc/tree.h
> > > > > > index 8844471e9a5..b7da4c5141a 100644
> > > > > > --- a/gcc/tree.h
> > > > > > +++ b/gcc/tree.h
> > > > > > @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
> > > > > >     /* Encode/decode the named memory support as part of the qualifier.  If more
> > > > > >        than 8 qualifiers are added, these macros need to be adjusted.  */
> > > > > > -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
> > > > > > +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
> > > > > >     #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
> > > > > >     /* Return all qualifiers except for the address space qualifiers.  */
> > > > > > 
> > > > > > 
> > > > > > 
> > > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > 
> > > > 
> > > > 
> > > > 
> > > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > > 
> > 
> > 
> > 
> > 
> > 
> > 
> 
> 
> 
> 
> 
> 
>
  

On 10/13/22 17:57, Paul Iannetta wrote:
> On Thu, Oct 13, 2022 at 03:41:16PM -0400, Jason Merrill wrote:
>> On 10/13/22 12:02, Paul Iannetta wrote:
>>> On Thu, Oct 13, 2022 at 11:47:42AM -0400, Jason Merrill wrote:
>>>> On 10/13/22 11:23, Paul Iannetta wrote:
>>>>> On Thu, Oct 13, 2022 at 11:02:24AM -0400, Jason Merrill wrote:
>>>>>> On 10/12/22 20:52, Paul Iannetta wrote:
>>>>>>> On Tue, Oct 11, 2022 at 09:49:43PM -0400, Jason Merrill wrote:
>>>>>>>>
>>>>>>>> It surprises that this is the only place we complain about an object with an
>>>>>>>> address-space qualifier.  Shouldn't we also complain about e.g. automatic
>>>>>>>> variables/parameters or non-static data members with address-space qualified
>>>>>>>> type?
>>>>>>>>
>>>>>>>
>>>>>>> Indeed, I was missing quite a few things here.  Thanks.
>>>>>>> I used the draft as basis this time and imported from the C
>>>>>>> implementation the relevant parts.  This time, the errors get properly
>>>>>>> emitted when an address space is unduly specified; and comparisons,
>>>>>>> assignments and comparisons are taken care of.
>>>>>>>
>>>>>>> There are quite a few things I would like to clarify concerning some
>>>>>>> implementation details.
>>>>>>>       - A variable with automatic storage (which is neither a pointer nor
>>>>>>>         a reference) cannot be qualified with an address space.  I detect
>>>>>>>         this by the combination of `sc_none' and `! toplevel_bindings_p ()',
>>>>>>>         but I've also seen the use of `at_function_scope' at other places.
>>>>>>>         And I'm unsure which one is appropriate here.
>>>>>>>         This detection happens at the very end of grokdeclarator because I
>>>>>>>         need to know that the type is a pointer, which is not know until
>>>>>>>         very late in the function.
>>>>>>
>>>>>> At that point you have the decl, and you can ask directly what its storage
>>>>>> duration is, perhaps using decl_storage_duration.
>>>>>>
>>>>>> But why do you need to know whether the type is a pointer?  The attribute
>>>>>> applies to the target type of the pointer, not the pointer type.  I think
>>>>>> the problem is that you're looking at declspecs when you ought to be looking
>>>>>> at type_quals.
>>>>>
>>>>> I need to know that the base type is a pointer to reject invalid
>>>>> declarations such as:
>>>>>
>>>>>        int f (__seg_fs int a) { }     or     int f () { __seg_fs int a; }
>>>>>
>>>>> because parameters and auto variables can have an address space
>>>>> qualifier only if they are pointer or reference type, which I can't
>>>>> tell only from type_quals.
>>>>
>>>> But "int *__seg_fs a" is just as invalid as the above; the difference is not
>>>> whether a is a pointer, but whether the address-space-qualified is the type
>>>> of a itself or some sub-type.
>>>
>>> I agree that "int * __seg_fs a" is invalid but it is accepted by the C
>>> front-end, and by clang (both C and C++), the behavior is that the
>>> address-name is silently ignored.
>>
>> Hmm, that sounds like a bug; in that case, presumably the user meant to
>> qualify the pointed-to type, and silently ignoring seems unlikely to give
>> the effect they want.
>>
> 
> Well, actually, I'm re-reading the draft and "int * __seg_fs a" is
> valid.  It means "pointer in address space __seg_fs pointing to an
> object in the generic address space", whereas "__seg_fs int * a" means
> "pointer in the generic address space pointing to an object in the
> __seg_fs address-space".
> 
> Oddities such as, "__seg_fs int * __seg_gs a" are also perfectly
> valid.

If a has static storage duration, sure; I was still thinking about 
declarations with automatic storage duration such as in your example above.

> The reason why I wrongly assumed that the address space was silently
> ignored is that I made a simple test which only relied on the mangled
> function name...
> 
> ```
> int * __seg_fs a;
> template <typename T> int f (T *a) { return *a; }
> int main () { return f (a); } // f<int>(int*), since a is in __seg_fs
>                                // but the pointer is to the generic
>                                // address-space.
> ```
> 
> Implementation-wise, I think I handle that correctly but I'll do a recheck.
> 
>>>> You need to look at the qualifiers on type (which should also be the ones in
>>>> type_quals), not the qualifiers in the declspecs.
>>>
>>> I'll have another look, thanks.
>>>
>>>>>>>       - I'm having some trouble deciding whether I include those three
>>>>>>>         stub programs as tests, they all compile fine and clang accepts
>>>>>>>         them as well.
>>>>>>
>>>>>> Why not?
>>>>>
>>>>> I thought they were pretty contrived, since it does not make much
>>>>> sense to strip address space qualifiers, even though it does prove
>>>>> that the implementation support those contrived but valid uses.
>>>>
>>>> Testcases are full of contrived examples testing corner cases.  :)
>>>>
>>>>>>
>>>>>>> Ex1:
>>>>>>> ```
>>>>>>> int __seg_fs * fs1;
>>>>>>> int __seg_gs * gs1;
>>>>>>>
>>>>>>> template<typename T> struct strip;
>>>>>>> template<typename T> struct strip<__seg_fs T *> { typedef T type; };
>>>>>>> template<typename T> struct strip<__seg_gs T *> { typedef T type; };
>>>>>>>
>>>>>>> int
>>>>>>> main ()
>>>>>>> {
>>>>>>>         *(strip<decltype(fs1)>::type *) fs1 == *(strip<decltype(gs1)>::type *) gs1;
>>>>>>>         return 0;
>>>>>>> }
>>>>>>> ```
>>>>>>>
>>>>>>> Ex2:
>>>>>>> ```
>>>>>>> int __seg_fs * fs1;
>>>>>>> int __seg_fs * fs2;
>>>>>>>
>>>>>>> template<typename T, typename U> auto f (T __seg_fs * a, U __seg_gs * b) { return a; }
>>>>>>> template<typename T, typename U> auto f (T __seg_gs * a, U __seg_fs * b) { return a; }
>>>>>>>
>>>>>>> int
>>>>>>> main ()
>>>>>>> {
>>>>>>>         f (fs1, gs1);
>>>>>>>         f (gs1, fs1);
>>>>>>>         return 0;
>>>>>>> }
>>>>>>> ```
>>>>>>>
>>>>>>> Ex3:
>>>>>>> ```
>>>>>>> int __seg_fs * fs1;
>>>>>>> int __seg_gs * gs1;
>>>>>>>
>>>>>>> template<typename T, typename U>
>>>>>>> auto f (T __seg_fs * a, U __seg_gs * b)
>>>>>>> {
>>>>>>>         return *(T *) a == *(U *) b;
>>>>>>> }
>>>>>>>
>>>>>>> int
>>>>>>> main ()
>>>>>>> {
>>>>>>>         return f (fs1, gs1);
>>>>>>> }
>>>>>>> ```
>>>>>>>
>>>>>>>
>>>>>>> Add support for custom address spaces in C++
>>>>>>>
>>>>>>> gcc/
>>>>>>>             * tree.h (ENCODE_QUAL_ADDR_SPACE): Missing parentheses.
>>>>>>>
>>>>>>> gcc/c/
>>>>>>>             * c-decl.cc: Remove c_register_addr_space.
>>>>>>>
>>>>>>> gcc/c-family/
>>>>>>>             * c-common.cc (c_register_addr_space): Imported from c-decl.cc
>>>>>>>             (addr_space_superset): Imported from gcc/c/c-typecheck.cc
>>>>>>>             * c-common.h: Remove the FIXME.
>>>>>>>             (addr_space_superset): New declaration.
>>>>>>>
>>>>>>> gcc/cp/
>>>>>>>             * cp-tree.h (enum cp_decl_spec): Add addr_space support.
>>>>>>>             (struct cp_decl_specifier_seq): Likewise.
>>>>>>>             * decl.cc (get_type_quals): Likewise.
>>>>>>>             (check_tag_decl): Likewise.
>>>>>>> 	(grokdeclarator): Likewise.
>>>>>>>             * parser.cc (cp_parser_type_specifier): Likewise.
>>>>>>>             (cp_parser_cv_qualifier_seq_opt): Likewise.
>>>>>>>             (cp_parser_postfix_expression): Likewise.
>>>>>>>             (cp_parser_type_specifier): Likewise.
>>>>>>>             (set_and_check_decl_spec_loc): Likewise.
>>>>>>>             * typeck.cc (composite_pointer_type): Likewise
>>>>>>>             (comp_ptr_ttypes_real): Likewise.
>>>>>>> 	(same_type_ignoring_top_level_qualifiers_p): Likewise.
>>>>>>>             * pt.cc (check_cv_quals_for_unify): Likewise.
>>>>>>>             (unify): Likewise.
>>>>>>>             * tree.cc: Remove c_register_addr_space stub.
>>>>>>>             * mangle.cc (write_CV_qualifiers_for_type): Mangle address spaces
>>>>>>>               using the extended qualifier notation.
>>>>>>>
>>>>>>> gcc/doc
>>>>>>>             * extend.texi (Named Address Spaces): add a mention about C++
>>>>>>>               support.
>>>>>>>
>>>>>>> gcc/testsuite/
>>>>>>>             * g++.dg/abi/mangle-addr-space1.C: New test.
>>>>>>>             * g++.dg/abi/mangle-addr-space2.C: New test.
>>>>>>>             * g++.dg/parse/addr-space.C: New test.
>>>>>>>             * g++.dg/parse/addr-space1.C: New test.
>>>>>>>             * g++.dg/parse/addr-space2.C: New test.
>>>>>>>             * g++.dg/parse/template/spec-addr-space.C: New test.
>>>>>>>             * g++.dg/ext/addr-space-decl.C: New test.
>>>>>>>             * g++.dg/ext/addr-space-ref.C: New test.
>>>>>>>             * g++.dg/ext/addr-space-ops.C: New test.
>>>>>>>
>>>>>>> # Please enter the commit message for your changes. Lines starting
>>>>>>> # with '#' will be ignored, and an empty message aborts the commit.
>>>>>>> #
>>>>>>> # Date:      Sun Oct 9 16:02:22 2022 +0200
>>>>>>> #
>>>>>>> # On branch releases/gcc-12
>>>>>>> # Your branch is ahead of 'origin/releases/gcc-12' by 2 commits.
>>>>>>> #   (use "git push" to publish your local commits)
>>>>>>> #
>>>>>>> # Changes to be committed:
>>>>>>> #	modified:   gcc/c-family/c-common.cc
>>>>>>> #	modified:   gcc/c-family/c-common.h
>>>>>>> #	modified:   gcc/c/c-decl.cc
>>>>>>> #	modified:   gcc/c/c-typeck.cc
>>>>>>> #	modified:   gcc/cp/cp-tree.h
>>>>>>> #	modified:   gcc/cp/decl.cc
>>>>>>> #	modified:   gcc/cp/mangle.cc
>>>>>>> #	modified:   gcc/cp/parser.cc
>>>>>>> #	modified:   gcc/cp/pt.cc
>>>>>>> #	modified:   gcc/cp/tree.cc
>>>>>>> #	modified:   gcc/cp/typeck.cc
>>>>>>> #	modified:   gcc/doc/extend.texi
>>>>>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>>>> #	new file:   gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>>>> #	modified:   gcc/tree.h
>>>>>>> #
>>>>>>> # Untracked files:
>>>>>>> #	Makefile
>>>>>>> #	addr-space-decl.C
>>>>>>> #	addr-space-decl.s
>>>>>>> #	addr-space-ops.C
>>>>>>> #	addr-space-ref.C
>>>>>>> #	addr-space-template.C
>>>>>>> #	addr-space-template.s
>>>>>>> #	addr-space-template2.C
>>>>>>> #	addr-space-template2.C.006t.gimple
>>>>>>> #	addr-space-template2.s
>>>>>>> #	addr-space-traits.C
>>>>>>> #	addr-space4.C
>>>>>>> #	addr-space4.C.006t.gimple
>>>>>>> #	addr-space4.s
>>>>>>> #	build-x86_64-pc-linux-gnu/
>>>>>>> #	compare
>>>>>>> #	host-x86_64-pc-linux-gnu/
>>>>>>> #	mangle-addr-space1.s
>>>>>>> #	prev-x86_64-pc-linux-gnu/
>>>>>>> #	rename
>>>>>>> #	stage1-x86_64-pc-linux-gnu/
>>>>>>> #	stage_current
>>>>>>> #	stage_final
>>>>>>> #	stage_last
>>>>>>> #	x86_64-pc-linux-gnu/
>>>>>>> #
>>>>>>> # ------------------------ >8 ------------------------
>>>>>>> # Do not modify or remove the line above.
>>>>>>> # Everything below it will be ignored.
>>>>>>> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
>>>>>>> index bb0544eeaea..ff1146ecc25 100644
>>>>>>> --- a/gcc/c-family/c-common.cc
>>>>>>> +++ b/gcc/c-family/c-common.cc
>>>>>>> @@ -615,6 +615,33 @@ c_addr_space_name (addr_space_t as)
>>>>>>>        return IDENTIFIER_POINTER (ridpointers [rid]);
>>>>>>>      }
>>>>>>> +/* Return true if between two named address spaces, whether there is a superset
>>>>>>> +   named address space that encompasses both address spaces.  If there is a
>>>>>>> +   superset, return which address space is the superset.  */
>>>>>>> +
>>>>>>> +bool
>>>>>>> +addr_space_superset (addr_space_t as1, addr_space_t as2,
>>>>>>> +		     addr_space_t * common)
>>>>>>> +{
>>>>>>> +  if (as1 == as2)
>>>>>>> +    {
>>>>>>> +      *common = as1;
>>>>>>> +      return true;
>>>>>>> +    }
>>>>>>> +  else if (targetm.addr_space.subset_p (as1, as2))
>>>>>>> +    {
>>>>>>> +      *common = as2;
>>>>>>> +      return true;
>>>>>>> +    }
>>>>>>> +  else if (targetm.addr_space.subset_p (as2, as1))
>>>>>>> +    {
>>>>>>> +      *common = as1;
>>>>>>> +      return true;
>>>>>>> +    }
>>>>>>> +  else
>>>>>>> +    return false;
>>>>>>> +}
>>>>>>> +
>>>>>>>      /* Push current bindings for the function name VAR_DECLS.  */
>>>>>>>      void
>>>>>>> @@ -2809,6 +2836,25 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
>>>>>>>        return build_nonstandard_integer_type (width, unsignedp);
>>>>>>>      }
>>>>>>> +/* Register reserved keyword WORD as qualifier for address space AS.  */
>>>>>>> +
>>>>>>> +void
>>>>>>> +c_register_addr_space (const char *word, addr_space_t as)
>>>>>>> +{
>>>>>>> +  int rid = RID_FIRST_ADDR_SPACE + as;
>>>>>>> +  tree id;
>>>>>>> +
>>>>>>> +  /* Address space qualifiers are only supported
>>>>>>> +     in C with GNU extensions enabled.  */
>>>>>>> +  if (c_dialect_objc () || flag_no_asm)
>>>>>>> +    return;
>>>>>>> +
>>>>>>> +  id = get_identifier (word);
>>>>>>> +  C_SET_RID_CODE (id, rid);
>>>>>>> +  TREE_LANG_FLAG_0 (id) = 1;
>>>>>>> +  ridpointers[rid] = id;
>>>>>>> +}
>>>>>>> +
>>>>>>>      /* The C version of the register_builtin_type langhook.  */
>>>>>>>      void
>>>>>>> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
>>>>>>> index 52a85bfb783..d36f9e4975b 100644
>>>>>>> --- a/gcc/c-family/c-common.h
>>>>>>> +++ b/gcc/c-family/c-common.h
>>>>>>> @@ -829,12 +829,11 @@ extern const struct attribute_spec c_common_format_attribute_table[];
>>>>>>>      extern tree (*make_fname_decl) (location_t, tree, int);
>>>>>>> -/* In c-decl.cc and cp/tree.cc.  FIXME.  */
>>>>>>> -extern void c_register_addr_space (const char *str, addr_space_t as);
>>>>>>> -
>>>>>>>      /* In c-common.cc.  */
>>>>>>>      extern bool in_late_binary_op;
>>>>>>>      extern const char *c_addr_space_name (addr_space_t as);
>>>>>>> +extern const char *c_addr_space_name (addr_space_t as);
>>>>>>> +extern bool addr_space_superset (addr_space_t, addr_space_t, addr_space_t *);
>>>>>>>      extern tree identifier_global_value (tree);
>>>>>>>      extern tree identifier_global_tag (tree);
>>>>>>>      extern bool names_builtin_p (const char *);
>>>>>>> @@ -952,6 +951,7 @@ extern void c_common_finish (void);
>>>>>>>      extern void c_common_parse_file (void);
>>>>>>>      extern FILE *get_dump_info (int, dump_flags_t *);
>>>>>>>      extern alias_set_type c_common_get_alias_set (tree);
>>>>>>> +extern void c_register_addr_space (const char *, addr_space_t);
>>>>>>>      extern void c_register_builtin_type (tree, const char*);
>>>>>>>      extern bool c_promoting_integer_type_p (const_tree);
>>>>>>>      extern bool self_promoting_args_p (const_tree);
>>>>>>> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
>>>>>>> index c701f07befe..e1bb4f1cf37 100644
>>>>>>> --- a/gcc/c/c-decl.cc
>>>>>>> +++ b/gcc/c/c-decl.cc
>>>>>>> @@ -12337,25 +12337,6 @@ c_parse_final_cleanups (void)
>>>>>>>        ext_block = NULL;
>>>>>>>      }
>>>>>>> -/* Register reserved keyword WORD as qualifier for address space AS.  */
>>>>>>> -
>>>>>>> -void
>>>>>>> -c_register_addr_space (const char *word, addr_space_t as)
>>>>>>> -{
>>>>>>> -  int rid = RID_FIRST_ADDR_SPACE + as;
>>>>>>> -  tree id;
>>>>>>> -
>>>>>>> -  /* Address space qualifiers are only supported
>>>>>>> -     in C with GNU extensions enabled.  */
>>>>>>> -  if (c_dialect_objc () || flag_no_asm)
>>>>>>> -    return;
>>>>>>> -
>>>>>>> -  id = get_identifier (word);
>>>>>>> -  C_SET_RID_CODE (id, rid);
>>>>>>> -  C_IS_RESERVED_WORD (id) = 1;
>>>>>>> -  ridpointers [rid] = id;
>>>>>>> -}
>>>>>>> -
>>>>>>>      /* Return identifier to look up for omp declare reduction.  */
>>>>>>>      tree
>>>>>>> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
>>>>>>> index b271af9bedb..c4b01368534 100644
>>>>>>> --- a/gcc/c/c-typeck.cc
>>>>>>> +++ b/gcc/c/c-typeck.cc
>>>>>>> @@ -296,32 +296,6 @@ c_type_promotes_to (tree type)
>>>>>>>        return type;
>>>>>>>      }
>>>>>>> -/* Return true if between two named address spaces, whether there is a superset
>>>>>>> -   named address space that encompasses both address spaces.  If there is a
>>>>>>> -   superset, return which address space is the superset.  */
>>>>>>> -
>>>>>>> -static bool
>>>>>>> -addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
>>>>>>> -{
>>>>>>> -  if (as1 == as2)
>>>>>>> -    {
>>>>>>> -      *common = as1;
>>>>>>> -      return true;
>>>>>>> -    }
>>>>>>> -  else if (targetm.addr_space.subset_p (as1, as2))
>>>>>>> -    {
>>>>>>> -      *common = as2;
>>>>>>> -      return true;
>>>>>>> -    }
>>>>>>> -  else if (targetm.addr_space.subset_p (as2, as1))
>>>>>>> -    {
>>>>>>> -      *common = as1;
>>>>>>> -      return true;
>>>>>>> -    }
>>>>>>> -  else
>>>>>>> -    return false;
>>>>>>> -}
>>>>>>> -
>>>>>>>      /* Return a variant of TYPE which has all the type qualifiers of LIKE
>>>>>>>         as well as those of TYPE.  */
>>>>>>> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
>>>>>>> index 72f4398a8f9..82a6d72f5df 100644
>>>>>>> --- a/gcc/cp/cp-tree.h
>>>>>>> +++ b/gcc/cp/cp-tree.h
>>>>>>> @@ -6206,6 +6206,7 @@ enum cp_decl_spec {
>>>>>>>        ds_const,
>>>>>>>        ds_volatile,
>>>>>>>        ds_restrict,
>>>>>>> +  ds_addr_space,
>>>>>>>        ds_inline,
>>>>>>>        ds_virtual,
>>>>>>>        ds_explicit,
>>>>>>> @@ -6252,6 +6253,8 @@ struct cp_decl_specifier_seq {
>>>>>>>        cp_storage_class storage_class;
>>>>>>>        /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>>>>>>>        int int_n_idx;
>>>>>>> +  /* The address space that the declaration belongs to.  */
>>>>>>> +  addr_space_t address_space;
>>>>>>>        /* True iff TYPE_SPEC defines a class or enum.  */
>>>>>>>        BOOL_BITFIELD type_definition_p : 1;
>>>>>>>        /* True iff multiple types were (erroneously) specified for this
>>>>>>> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
>>>>>>> index 9f78c500a15..fa5a1ddb21d 100644
>>>>>>> --- a/gcc/cp/decl.cc
>>>>>>> +++ b/gcc/cp/decl.cc
>>>>>>> @@ -5280,6 +5280,8 @@ get_type_quals (const cp_decl_specifier_seq *declspecs)
>>>>>>>          type_quals |= TYPE_QUAL_VOLATILE;
>>>>>>>        if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
>>>>>>>          type_quals |= TYPE_QUAL_RESTRICT;
>>>>>>> +  if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>>>>>> +    type_quals |= ENCODE_QUAL_ADDR_SPACE (declspecs->address_space);
>>>>>>>        return type_quals;
>>>>>>>      }
>>>>>>> @@ -5402,6 +5404,10 @@ check_tag_decl (cp_decl_specifier_seq *declspecs,
>>>>>>>      	error_at (declspecs->locations[ds_restrict],
>>>>>>>      		  "%<__restrict%> can only be specified for objects and "
>>>>>>>      		  "functions");
>>>>>>> +      else if (decl_spec_seq_has_spec_p (declspecs, ds_addr_space))
>>>>>>> +	error_at (declspecs->locations[ds_addr_space],
>>>>>>> +		  "address space can only be specified for objects and "
>>>>>>> +		  "functions");
>>>>>>>            else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
>>>>>>>      	error_at (declspecs->locations[ds_thread],
>>>>>>>      		  "%<__thread%> can only be specified for objects "
>>>>>>> @@ -14572,6 +14578,57 @@ grokdeclarator (const cp_declarator *declarator,
>>>>>>>          if (!processing_template_decl)
>>>>>>>            cp_apply_type_quals_to_decl (type_quals, decl);
>>>>>>> +    addr_space_t address_space = declspecs->address_space;
>>>>>>> +    if (!ADDR_SPACE_GENERIC_P (address_space) && !INDIRECT_TYPE_P (type))
>>>>>>> +      {
>>>>>>> +	if (decl_context == NORMAL)
>>>>>>> +	  {
>>>>>>> +	    switch (storage_class)
>>>>>>> +	      {
>>>>>>> +	      case sc_auto:
>>>>>>> +		error ("%qs combined with C++98 %<auto%> qualifier for %qs",
>>>>>>> +		       c_addr_space_name (address_space), name);
>>>>>>> +		break;
>>>>>>> +	      case sc_register:
>>>>>>> +		error ("%qs combined with %<register%> qualifier for %qs",
>>>>>>> +		       c_addr_space_name (address_space), name);
>>>>>>> +		break;
>>>>>>> +	      case sc_none:
>>>>>>> +		if (! toplevel_bindings_p ())
>>>>>>> +		  error ("%qs specified for auto variable %qs",
>>>>>>> +			 c_addr_space_name (address_space), name);
>>>>>>> +		break;
>>>>>>> +	      case sc_mutable:
>>>>>>> +		error ("%qs combined with %<mutable%> qualifier for %qs",
>>>>>>> +		       c_addr_space_name (address_space), name);
>>>>>>> +		break;
>>>>>>> +	      case sc_static:
>>>>>>> +	      case sc_extern:
>>>>>>> +		break;
>>>>>>> +	      default:
>>>>>>> +		gcc_unreachable ();
>>>>>>> +	      }
>>>>>>> +	  }
>>>>>>> +	else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
>>>>>>> +	  {
>>>>>>> +	    if (name)
>>>>>>> +	      error ("%qs specified for parameter %qs",
>>>>>>> +		     c_addr_space_name (address_space), name);
>>>>>>> +	    else
>>>>>>> +	      error ("%qs specified for unnamed parameter",
>>>>>>> +		     c_addr_space_name (address_space));
>>>>>>> +	  }
>>>>>>> +	else if (decl_context == FIELD)
>>>>>>> +	  {
>>>>>>> +	    if (name)
>>>>>>> +	      error ("%qs specified for structure field %qs",
>>>>>>> +		     c_addr_space_name (address_space), name);
>>>>>>> +	    else
>>>>>>> +	      error ("%qs specified for structure field",
>>>>>>> +		     c_addr_space_name (address_space));
>>>>>>> +	  }
>>>>>>> +      }
>>>>>>> +
>>>>>>>          return decl;
>>>>>>>        }
>>>>>>>      }
>>>>>>> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
>>>>>>> index eb53e0ebeb4..16cb2ff4332 100644
>>>>>>> --- a/gcc/cp/mangle.cc
>>>>>>> +++ b/gcc/cp/mangle.cc
>>>>>>> @@ -2509,6 +2509,14 @@ write_CV_qualifiers_for_type (const tree type)
>>>>>>>           array.  */
>>>>>>>        cp_cv_quals quals = TYPE_QUALS (type);
>>>>>>> +  if (addr_space_t as = DECODE_QUAL_ADDR_SPACE (quals))
>>>>>>> +    {
>>>>>>> +      const char *as_name = c_addr_space_name (as);
>>>>>>> +      write_char ('U');
>>>>>>> +      write_unsigned_number (strlen (as_name));
>>>>>>> +      write_string (as_name);
>>>>>>> +      ++num_qualifiers;
>>>>>>> +    }
>>>>>>>        if (quals & TYPE_QUAL_RESTRICT)
>>>>>>>          {
>>>>>>>            write_char ('r');
>>>>>>> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
>>>>>>> index 763df6f479b..f0169d83ab0 100644
>>>>>>> --- a/gcc/cp/parser.cc
>>>>>>> +++ b/gcc/cp/parser.cc
>>>>>>> @@ -7640,6 +7640,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
>>>>>>>      		    postfix_expression = error_mark_node;
>>>>>>>      		    break;
>>>>>>>      		  }
>>>>>>> +		if (type != error_mark_node
>>>>>>> +		    && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
>>>>>>> +		    && current_function_decl)
>>>>>>> +		  {
>>>>>>> +		    error
>>>>>>> +		      ("compound literal qualified by address-space qualifier");
>>>>>>> +		    type = error_mark_node;
>>>>>>> +		  }
>>>>>>>      		/* Form the representation of the compound-literal.  */
>>>>>>>      		postfix_expression
>>>>>>>      		  = finish_compound_literal (type, initializer,
>>>>>>> @@ -19408,6 +19416,15 @@ cp_parser_type_specifier (cp_parser* parser,
>>>>>>>            break;
>>>>>>>          }
>>>>>>> +
>>>>>>> +  if (RID_FIRST_ADDR_SPACE <= keyword && keyword <= RID_LAST_ADDR_SPACE)
>>>>>>> +    {
>>>>>>> +      ds = ds_addr_space;
>>>>>>> +      if (is_cv_qualifier)
>>>>>>> +	*is_cv_qualifier = true;
>>>>>>> +    }
>>>>>>> +
>>>>>>> +
>>>>>>>        /* Handle simple keywords.  */
>>>>>>>        if (ds != ds_last)
>>>>>>>          {
>>>>>>> @@ -23776,6 +23793,7 @@ cp_parser_ptr_operator (cp_parser* parser,
>>>>>>>         GNU Extension:
>>>>>>>         cv-qualifier:
>>>>>>> +     address-space-qualifier
>>>>>>>           __restrict__
>>>>>>>         Returns a bitmask representing the cv-qualifiers.  */
>>>>>>> @@ -23812,6 +23830,11 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
>>>>>>>      	  break;
>>>>>>>      	}
>>>>>>> +      if (RID_FIRST_ADDR_SPACE <= token->keyword &&
>>>>>>> +	  token->keyword <= RID_LAST_ADDR_SPACE)
>>>>>>> +	cv_qualifier =
>>>>>>> +	  ENCODE_QUAL_ADDR_SPACE (token->keyword - RID_FIRST_ADDR_SPACE);
>>>>>>> +
>>>>>>>            if (!cv_qualifier)
>>>>>>>      	break;
>>>>>>> @@ -32705,6 +32728,8 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>>>>>            decl_specs->locations[ds] = location;
>>>>>>>            if (ds == ds_thread)
>>>>>>>      	decl_specs->gnu_thread_keyword_p = token_is__thread (token);
>>>>>>> +      else if (ds == ds_addr_space)
>>>>>>> +	decl_specs->address_space = token->keyword - RID_FIRST_ADDR_SPACE;
>>>>>>>          }
>>>>>>>        else
>>>>>>>          {
>>>>>>> @@ -32737,6 +32762,25 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
>>>>>>>      	      error_at (&richloc, "duplicate %qD", token->u.value);
>>>>>>>      	    }
>>>>>>>      	}
>>>>>>> +      else if (ds == ds_addr_space)
>>>>>>> +	{
>>>>>>> +	  addr_space_t as1 = decl_specs->address_space;
>>>>>>> +	  addr_space_t as2 = token->keyword - RID_FIRST_ADDR_SPACE;
>>>>>>> +
>>>>>>> +	  gcc_rich_location richloc (location);
>>>>>>> +	  richloc.add_fixit_remove ();
>>>>>>> +	  if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2)
>>>>>>> +	      && as1 != as2)
>>>>>>> +	    error_at (&richloc,
>>>>>>> +		      "conflicting named address spaces (%s vs %s)",
>>>>>>> +		      c_addr_space_name (as1), c_addr_space_name (as2));
>>>>>>> +	  if (as1 == as2 && !ADDR_SPACE_GENERIC_P (as1))
>>>>>>> +	    error_at (&richloc,
>>>>>>> +		      "duplicate named address space %s",
>>>>>>> +		      c_addr_space_name (as1));
>>>>>>> +
>>>>>>> +	  decl_specs->address_space = as2;
>>>>>>> +	}
>>>>>>>            else
>>>>>>>      	{
>>>>>>>      	  static const char *const decl_spec_names[] = {
>>>>>>> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
>>>>>>> index bef31416fb7..c9d1c01f4ce 100644
>>>>>>> --- a/gcc/cp/pt.cc
>>>>>>> +++ b/gcc/cp/pt.cc
>>>>>>> @@ -23655,8 +23655,19 @@ template_decl_level (tree decl)
>>>>>>>      static int
>>>>>>>      check_cv_quals_for_unify (int strict, tree arg, tree parm)
>>>>>>>      {
>>>>>>> -  int arg_quals = cp_type_quals (arg);
>>>>>>> -  int parm_quals = cp_type_quals (parm);
>>>>>>> +  int arg_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>>>>>> +  int parm_quals = CLEAR_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>>>>>> +
>>>>>>> +  /*  Try to unify ARG's address space into PARM's address space.
>>>>>>> +      If PARM does not have any address space qualifiers (ie., as_parm is 0),
>>>>>>> +      there are no constraints on address spaces for this type.  */
>>>>>>> +  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (cp_type_quals (arg));
>>>>>>> +  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (cp_type_quals (parm));
>>>>>>> +  addr_space_t as_common;
>>>>>>> +  addr_space_superset (as_arg, as_parm, &as_common);
>>>>>>> +
>>>>>>> +  if (!(as_parm == as_common || as_parm == 0))
>>>>>>> +    return 0;
>>>>>>>        if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
>>>>>>>            && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
>>>>>>> @@ -24292,10 +24303,26 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
>>>>>>>      					 arg, parm))
>>>>>>>      	    return unify_cv_qual_mismatch (explain_p, parm, arg);
>>>>>>> +	  int arg_cv_quals = cp_type_quals (arg);
>>>>>>> +	  int parm_cv_quals = cp_type_quals (parm);
>>>>>>> +
>>>>>>> +	  /* If PARM does not contain any address space constraints it can
>>>>>>> +	     fully match the address space of ARG.  However, if PARM contains an
>>>>>>> +	     address space constraint, it becomes the upper bound.  That is,
>>>>>>> +	     AS_ARG may be promoted to AS_PARM but not the converse.  If we
>>>>>>> +	     ended up here, it means that `check_cv_quals_for_unify' succeeded
>>>>>>> +	     and that either AS_PARM is 0 (ie., no constraints) or AS_COMMON ==
>>>>>>> +	     AS_PARM.  */
>>>>>>> +	  addr_space_t as_arg = DECODE_QUAL_ADDR_SPACE (arg_cv_quals);
>>>>>>> +	  addr_space_t as_parm = DECODE_QUAL_ADDR_SPACE (parm_cv_quals);
>>>>>>> +	  addr_space_t as_common = as_parm ? 0 : as_arg;
>>>>>>> +
>>>>>>>      	  /* Consider the case where ARG is `const volatile int' and
>>>>>>>      	     PARM is `const T'.  Then, T should be `volatile int'.  */
>>>>>>> -	  arg = cp_build_qualified_type_real
>>>>>>> -	    (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
>>>>>>> +	  int unified_cv =
>>>>>>> +	    CLEAR_QUAL_ADDR_SPACE (arg_cv_quals & ~parm_cv_quals)
>>>>>>> +	    | ENCODE_QUAL_ADDR_SPACE (as_common);
>>>>>>> +	  arg = cp_build_qualified_type_real (arg, unified_cv, tf_none);
>>>>>>>      	  if (arg == error_mark_node)
>>>>>>>      	    return unify_invalid (explain_p);
>>>>>>> diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
>>>>>>> index 3b37567cbd7..5e14ac837fc 100644
>>>>>>> --- a/gcc/cp/tree.cc
>>>>>>> +++ b/gcc/cp/tree.cc
>>>>>>> @@ -6048,15 +6048,6 @@ cp_free_lang_data (tree t)
>>>>>>>          DECL_CHAIN (t) = NULL_TREE;
>>>>>>>      }
>>>>>>> -/* Stub for c-common.  Please keep in sync with c-decl.cc.
>>>>>>> -   FIXME: If address space support is target specific, then this
>>>>>>> -   should be a C target hook.  But currently this is not possible,
>>>>>>> -   because this function is called via REGISTER_TARGET_PRAGMAS.  */
>>>>>>> -void
>>>>>>> -c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
>>>>>>> -{
>>>>>>> -}
>>>>>>> -
>>>>>>>      /* Return the number of operands in T that we care about for things like
>>>>>>>         mangling.  */
>>>>>>> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
>>>>>>> index ceb80d9744f..7d810c6a12c 100644
>>>>>>> --- a/gcc/cp/typeck.cc
>>>>>>> +++ b/gcc/cp/typeck.cc
>>>>>>> @@ -656,10 +656,26 @@ composite_pointer_type (const op_location_t &location,
>>>>>>>      	  else
>>>>>>>      	    return error_mark_node;
>>>>>>>              }
>>>>>>> +      /* If possible merge the address space into the superset of the address
>>>>>>> +	  spaces of t1 and t2, or raise an error. */
>>>>>>> +      addr_space_t as_t1 = TYPE_ADDR_SPACE (t1);
>>>>>>> +      addr_space_t as_t2 = TYPE_ADDR_SPACE (t2);
>>>>>>> +      addr_space_t as_common;
>>>>>>> +
>>>>>>> +      /* If the two named address spaces are different, determine the common
>>>>>>> +	 superset address space.  If there isn't one, raise an error.  */
>>>>>>> +      if (!addr_space_superset (as_t1, as_t2, &as_common))
>>>>>>> +	{
>>>>>>> +	  as_common = as_t1;
>>>>>>> +	  error_at (location,
>>>>>>> +		    "%qT and %qT are in disjoint named address spaces",
>>>>>>> +		    t1, t2);
>>>>>>> +	}
>>>>>>>            result_type
>>>>>>>      	= cp_build_qualified_type (void_type_node,
>>>>>>> -				   (cp_type_quals (TREE_TYPE (t1))
>>>>>>> -				    | cp_type_quals (TREE_TYPE (t2))));
>>>>>>> +				   (CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t1)))
>>>>>>> +				    | CLEAR_QUAL_ADDR_SPACE (cp_type_quals (TREE_TYPE (t2)))
>>>>>>> +				    | ENCODE_QUAL_ADDR_SPACE (as_common)));
>>>>>>>            result_type = build_pointer_type (result_type);
>>>>>>>            /* Merge the attributes.  */
>>>>>>>            attributes = (*targetm.merge_type_attributes) (t1, t2);
>>>>>>> @@ -1579,7 +1595,9 @@ comptypes (tree t1, tree t2, int strict)
>>>>>>>      }
>>>>>>>      /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
>>>>>>> -   top-level qualifiers.  */
>>>>>>> +   top-level qualifiers, except for named address spaces.  If the pointers point
>>>>>>> +   to different named addresses spaces, then we must determine if one address
>>>>>>> +   space is a subset of the other.  */
>>>>>>>      bool
>>>>>>>      same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>>>>>> @@ -1589,6 +1607,14 @@ same_type_ignoring_top_level_qualifiers_p (tree type1, tree type2)
>>>>>>>        if (type1 == type2)
>>>>>>>          return true;
>>>>>>> +  addr_space_t as_type1 = TYPE_ADDR_SPACE (type1);
>>>>>>> +  addr_space_t as_type2 = TYPE_ADDR_SPACE (type2);
>>>>>>> +  addr_space_t as_common;
>>>>>>> +
>>>>>>> +  /* Fail if pointers point to incompatible address spaces.  */
>>>>>>> +  if (!addr_space_superset (as_type1, as_type2, &as_common))
>>>>>>> +    return false;
>>>>>>> +
>>>>>>>        type1 = cp_build_qualified_type (type1, TYPE_UNQUALIFIED);
>>>>>>>        type2 = cp_build_qualified_type (type2, TYPE_UNQUALIFIED);
>>>>>>>        return same_type_p (type1, type2);
>>>>>>> @@ -6374,10 +6400,32 @@ static tree
>>>>>>>      pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
>>>>>>>      	      tsubst_flags_t complain, tree *instrument_expr)
>>>>>>>      {
>>>>>>> -  tree result, inttype;
>>>>>>>        tree restype = ptrdiff_type_node;
>>>>>>> +  tree result, inttype;
>>>>>>> +
>>>>>>> +  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
>>>>>>> +  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
>>>>>>>        tree target_type = TREE_TYPE (ptrtype);
>>>>>>> +  /* If the operands point into different address spaces, we need to
>>>>>>> +     explicitly convert them to pointers into the common address space
>>>>>>> +     before we can subtract the numerical address values.  */
>>>>>>> +  if (as0 != as1)
>>>>>>> +    {
>>>>>>> +      addr_space_t as_common;
>>>>>>> +      tree common_type;
>>>>>>> +
>>>>>>> +      /* Determine the common superset address space.  This is guaranteed
>>>>>>> +	 to exist because the caller verified that comp_target_types
>>>>>>> +	 returned non-zero.  */
>>>>>>> +      if (!addr_space_superset (as0, as1, &as_common))
>>>>>>> +	gcc_unreachable ();
>>>>>>> +
>>>>>>> +      common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
>>>>>>> +      op0 = convert (common_type, op0);
>>>>>>> +      op1 = convert (common_type, op1);
>>>>>>> +    }
>>>>>>> +
>>>>>>>        if (!complete_type_or_maybe_complain (target_type, NULL_TREE, complain))
>>>>>>>          return error_mark_node;
>>>>>>> @@ -10805,6 +10853,19 @@ comp_ptr_ttypes_real (tree to, tree from, int constp)
>>>>>>>      	      to_more_cv_qualified = true;
>>>>>>>      	    }
>>>>>>> +      /* Warn about conversions between pointers to disjoint
>>>>>>> +	 address spaces.  */
>>>>>>> +      if (TREE_CODE (from) == POINTER_TYPE
>>>>>>> +	  && TREE_CODE (to) == POINTER_TYPE)
>>>>>>> +	{
>>>>>>> +	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (from));
>>>>>>> +	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (to));
>>>>>>> +	  addr_space_t as_common;
>>>>>>> +
>>>>>>> +	  if (!addr_space_superset (as_to, as_from, &as_common))
>>>>>>> +	    return false;
>>>>>>> +	}
>>>>>>> +
>>>>>>>      	  if (constp > 0)
>>>>>>>      	    constp &= TYPE_READONLY (to);
>>>>>>>      	}
>>>>>>> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
>>>>>>> index ac3db88566d..1e0d436c02c 100644
>>>>>>> --- a/gcc/doc/extend.texi
>>>>>>> +++ b/gcc/doc/extend.texi
>>>>>>> @@ -1448,7 +1448,7 @@ Fixed-point types are supported by the DWARF debug information format.
>>>>>>>      @section Named Address Spaces
>>>>>>>      @cindex Named Address Spaces
>>>>>>> -As an extension, GNU C supports named address spaces as
>>>>>>> +As an extension, GNU C and GNU C++ support named address spaces as
>>>>>>>      defined in the N1275 draft of ISO/IEC DTR 18037.  Support for named
>>>>>>>      address spaces in GCC will evolve as the draft technical report
>>>>>>>      changes.  Calling conventions for any target might also change.  At
>>>>>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..c01f8d6054a
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space1.C
>>>>>>> @@ -0,0 +1,10 @@
>>>>>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>>>>>> +// { dg-final { scan-assembler "_Z1fPU8__seg_fsVi" } }
>>>>>>> +
>>>>>>> +int f (int volatile __seg_fs *a)
>>>>>>> +{
>>>>>>> +  return *a;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int main () {}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..862bbbdcdf2
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/abi/mangle-addr-space2.C
>>>>>>> @@ -0,0 +1,9 @@
>>>>>>> +// { dg-do run { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +// { dg-options "-fabi-version=8 -Wabi -save-temps" }
>>>>>>> +// { dg-final { scan-assembler "_Z1fIU8__seg_fsiEiPT_" } }
>>>>>>> +
>>>>>>> +template <class T>
>>>>>>> +int f (T *p) { return *p; }
>>>>>>> +int g (__seg_fs int *p) { return *p; }
>>>>>>> +__seg_fs int *a;
>>>>>>> +int main() { f(a); }
>>>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-decl.C b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..c04d2f497da
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-decl.C
>>>>>>> @@ -0,0 +1,5 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +__seg_fs char a, b, c;
>>>>>>> +__seg_fs const int *p;
>>>>>>> +static /* give internal linkage to the following anonymous struct */
>>>>>>> +__seg_fs struct { int a; char b; } * __seg_gs q;
>>>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ops.C b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..86c02d1e7f5
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ops.C
>>>>>>> @@ -0,0 +1,20 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +int __seg_fs * fs1;
>>>>>>> +int __seg_fs * fs2;
>>>>>>> +float __seg_gs * gs1;
>>>>>>> +float __seg_gs * gs2;
>>>>>>> +
>>>>>>> +int
>>>>>>> +main ()
>>>>>>> +{
>>>>>>> +  fs1 + fs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_fs int.. to binary .operator.." }
>>>>>>> +  fs1 - fs2;
>>>>>>> +  fs1 - gs2; // { dg-error "invalid operands of types .__seg_fs int.. and .__seg_gs float.. to binary .operator.." }
>>>>>>> +  fs1 == fs2;
>>>>>>> +  fs1 != gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>>>>>> +  fs1 = fs2;
>>>>>>> +  fs1 = gs2; // { dg-error "cannot convert .__seg_gs float.. to .__seg_fs int.. in assignment" }
>>>>>>> +  fs1 > fs2;
>>>>>>> +  fs1 < gs2; // { dg-error "comparison between distinct pointer types .__seg_fs int.. and .__seg_gs float.. lacks a cast" }
>>>>>>> +  return 0;
>>>>>>> +}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/ext/addr-space-ref.C b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..12d7975e560
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/ext/addr-space-ref.C
>>>>>>> @@ -0,0 +1,31 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +// { dg-prune-output "does not allow .register. storage class specifier" }
>>>>>>> +int __seg_fs * outer_b;
>>>>>>> +
>>>>>>> +struct s {
>>>>>>> +  __seg_fs int * ok;
>>>>>>> +  __seg_gs int ko; // { dg-error ".__seg_gs. specified for structure field .ko." }
>>>>>>> +};
>>>>>>> +
>>>>>>> +int register __seg_fs reg_fs; // { dg-error ".__seg_fs. combined with .register. qualifier for .reg_fs." }
>>>>>>> +
>>>>>>> +namespace ns_a
>>>>>>> +{
>>>>>>> +  int __seg_fs * inner_b;
>>>>>>> +
>>>>>>> +  template<typename T>
>>>>>>> +  int f (T &a) { return a; }
>>>>>>> +  int g (__seg_fs int a) { return a; } // { dg-error ".__seg_fs. specified for parameter .a." }
>>>>>>> +  int h (__seg_fs int *a) { return *a; }
>>>>>>> +}
>>>>>>> +
>>>>>>> +int
>>>>>>> +main ()
>>>>>>> +{
>>>>>>> +  int register __seg_gs reg_gs; // { dg-error ".__seg_gs. combined with .register. qualifier for .reg_gs." }
>>>>>>> +  static __seg_gs int static_gs;
>>>>>>> +  __seg_fs int auto_fs; // { dg-error ".__seg_fs. specified for auto variable .auto_fs." }
>>>>>>> +  __seg_fs int *pa = outer_b;
>>>>>>> +  __seg_fs int& ra = *ns_a::inner_b;
>>>>>>> +  return ns_a::f(ra) + ns_a::f(*pa);
>>>>>>> +}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space.C b/gcc/testsuite/g++.dg/parse/addr-space.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..ebb6316054a
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space.C
>>>>>>> @@ -0,0 +1,9 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +
>>>>>>> +__seg_fs struct foo; // { dg-error "address space can only be specified for objects and functions" }
>>>>>>> +
>>>>>>> +int
>>>>>>> +main ()
>>>>>>> +{
>>>>>>> +	return 0;
>>>>>>> +}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space1.C b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..2e8ee32a885
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space1.C
>>>>>>> @@ -0,0 +1,10 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +// { dg-options "-std=gnu++98" }
>>>>>>> +
>>>>>>> +int
>>>>>>> +main ()
>>>>>>> +{
>>>>>>> +	struct foo {int a; char b[2];} structure;
>>>>>>> +	structure = ((__seg_fs struct foo) {1 + 2, 'a', 0}); // { dg-error "compound literal qualified by address-space qualifier" }
>>>>>>> +	return 0;
>>>>>>> +}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/parse/addr-space2.C b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..5b2c0f28078
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/parse/addr-space2.C
>>>>>>> @@ -0,0 +1,9 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +
>>>>>>> +__seg_fs __seg_gs int *a; // { dg-error "conflicting named address spaces .__seg_fs vs __seg_gs." }
>>>>>>> +
>>>>>>> +int
>>>>>>> +main ()
>>>>>>> +{
>>>>>>> +	return 0;
>>>>>>> +}
>>>>>>> diff --git a/gcc/testsuite/g++.dg/template/spec-addr-space.C b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>>>> new file mode 100644
>>>>>>> index 00000000000..ae9f4de0e1f
>>>>>>> --- /dev/null
>>>>>>> +++ b/gcc/testsuite/g++.dg/template/spec-addr-space.C
>>>>>>> @@ -0,0 +1,8 @@
>>>>>>> +// { dg-do compile { target { i?86-*-* x86_64-*-* } } }
>>>>>>> +
>>>>>>> +template <class T>
>>>>>>> +int f (T __seg_gs *p) { return *p; } // { dg-note "candidate: 'template<class T> int f.__seg_gs T\*." }
>>>>>>> +				     // { dg-note "template argument deduction/substitution failed:" "" { target *-*-* } .-1 }
>>>>>>> +__seg_fs int *a;
>>>>>>> +int main() { f(a); } // { dg-error "no matching" }
>>>>>>> +// { dg-note "types .__seg_gs T. and .__seg_fs int. have incompatible cv-qualifiers" "" { target *-*-* } .-1 }
>>>>>>> diff --git a/gcc/tree.h b/gcc/tree.h
>>>>>>> index 8844471e9a5..b7da4c5141a 100644
>>>>>>> --- a/gcc/tree.h
>>>>>>> +++ b/gcc/tree.h
>>>>>>> @@ -2229,7 +2229,7 @@ extern tree vector_element_bits_tree (const_tree);
>>>>>>>      /* Encode/decode the named memory support as part of the qualifier.  If more
>>>>>>>         than 8 qualifiers are added, these macros need to be adjusted.  */
>>>>>>> -#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
>>>>>>> +#define ENCODE_QUAL_ADDR_SPACE(NUM) (((NUM) & 0xFF) << 8)
>>>>>>>      #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
>>>>>>>      /* Return all qualifiers except for the address space qualifiers.  */
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>>
>>
>>
>>
>>
> 
> 
> 
> 
> 
>