[RFA,2/6] Handle alignof and _Alignof

Message ID 20180424152222.8053-3-tom@tromey.com
State Superseded
Headers show
Series
  • Teach gdb about type alignment
Related show

Commit Message

Tom Tromey April 24, 2018, 3:22 p.m.
This adds alignof and _Alignof to the C/C++ expression parser, and
adds new tests to test the features.  The tests are written to try to
ensure that gdb's knowledge of alignment rules stays in sync with the
compiler's.

2018-04-24  Tom Tromey  <tom@tromey.com>

	PR exp/17095:
	* NEWS: Update.
	* std-operator.def (UNOP_ALIGNOF): New operator.
	* expprint.c (dump_subexp_body_standard) <case UNOP_ALIGNOF>:
	New.
	* eval.c (evaluate_subexp_standard) <case UNOP_ALIGNOF>: New.
	* c-lang.c (c_op_print_tab): Add alignof.
	* c-exp.y (ALIGNOF): New token.
	(exp): Add "ALIGNOF" production.
	(ident_tokens): Add _Alignof and alignof.

2018-04-24  Tom Tromey  <tom@tromey.com>

	PR exp/17095:
	* gdb.dwarf2/dw2-align.exp: New file.
	* gdb.cp/align.exp: New file.
	* gdb.base/align.exp: New file.
---
 gdb/ChangeLog                          |  13 ++++
 gdb/NEWS                               |   3 +
 gdb/c-exp.y                            |   8 +-
 gdb/c-lang.c                           |   1 +
 gdb/eval.c                             |  13 ++++
 gdb/expprint.c                         |   1 +
 gdb/std-operator.def                   |   1 +
 gdb/testsuite/ChangeLog                |   7 ++
 gdb/testsuite/gdb.base/align.exp       |  94 ++++++++++++++++++++++++
 gdb/testsuite/gdb.cp/align.exp         | 129 +++++++++++++++++++++++++++++++++
 gdb/testsuite/gdb.dwarf2/dw2-align.exp |  83 +++++++++++++++++++++
 11 files changed, 352 insertions(+), 1 deletion(-)
 create mode 100644 gdb/testsuite/gdb.base/align.exp
 create mode 100644 gdb/testsuite/gdb.cp/align.exp
 create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-align.exp

-- 
2.14.3

Comments

Eli Zaretskii April 24, 2018, 5:03 p.m. | #1
> From: Tom Tromey <tom@tromey.com>

> Cc: Tom Tromey <tom@tromey.com>

> Date: Tue, 24 Apr 2018 09:22:18 -0600

> 

> diff --git a/gdb/NEWS b/gdb/NEWS

> index 63fe30d175..6631b53475 100644

> --- a/gdb/NEWS

> +++ b/gdb/NEWS

> @@ -9,6 +9,9 @@

>  * 'info proc' now works on running processes on FreeBSD systems and core

>    files created on FreeBSD systems.

>  

> +* C expressions can now use _Alignof, and C++ expressions can now use

> +  alignof.

> +

>  * New commands


OK for this part.

Thanks.
Pedro Alves April 24, 2018, 7:17 p.m. | #2
Hi Tom,

What's in the patch looks good to me.  I have comments on the
tests -- I think it'd be good to extend them a bit more.

On 04/24/2018 04:22 PM, Tom Tromey wrote:

> +

> +# The types we're going to test.

> +

> +set typelist {

> +    char {unsigned char}

> +    short {unsigned short}

> +    int {unsigned int}

> +    long {unsigned long}

> +    {long long} {unsigned long long}

> +    float

> +    double


Shouldn't we test "long double"?  Patch #1 handles it.
Not sure all GCC ports support it, may require separate compilation.

Also, I'm wondering about "__int128" if the target
supports it.

In C++, do we get the alignment of non-standard layout classes right?
E.g., structs with references.  And structs with virtual methods, like:

 struct S
 {
   virtual ~S ();
   char c;
 };

This should print 8 instead of 1 on x86-64, due to the vtable pointer.

I think it'd be good to cover those things in the tests too.

Likewise arrays, bitfields and typedefs?

I didn't spot any test for the
 "could not determine alignment of type"
case to make that that works gracefully without crashing.  

What do we do with _Alignof(void)?  We treat sizeof(void) == 1,
like gcc, so I assume the _Alignof will return 1 too instead
of erroring out.

Finally, for completeness, GCC allows _Alignof applied to
expressions, so I guess we should to.  Does the series allow that?
I.e., can we do _Alignof(1 + 1)?  Does the parser handle that?

Shouldn't we test _Alignof applied to the structure fields too?

There was a snippet in the patch that made me wonder if the patch
handles alignof of a no-debug-info variable and and the return-type
of a no-debug-info function correctly (instead of e.g., crashing).
I'd be nice to add a couples test to gdb.base/nodebug.exp
to make sure.  E.g.:
   p _Alignof (dataglobal64_1)
   p _Alignof (middle())"

Also, please add intro comments to the testcase .exp files, so
that later on people can find out what the testcase is
about easily.

Thanks,
Pedro Alves
Tom Tromey April 24, 2018, 8:23 p.m. | #3
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


Pedro> Shouldn't we test "long double"?  Patch #1 handles it.
Pedro> Not sure all GCC ports support it, may require separate compilation.

I thought C didn't have long double (it's tested in the C++ test), but I
see it does.  I will add that.

Pedro> Also, I'm wondering about "__int128" if the target
Pedro> supports it.

I have bad feelings about trying to detect this in the test.

Pedro> In C++, do we get the alignment of non-standard layout classes right?
Pedro> Likewise arrays, bitfields and typedefs?
Pedro> What do we do with _Alignof(void)?

I will add these.

Pedro> I didn't spot any test for the
Pedro>  "could not determine alignment of type"
Pedro> case to make that that works gracefully without crashing.  

I think this one is maybe hard to test without some kind of bug (so far
I've only seen it when some part of the patch was buggy), but I will see
what I can do.

Pedro> Finally, for completeness, GCC allows _Alignof applied to
Pedro> expressions, so I guess we should to.  Does the series allow that?
Pedro> I.e., can we do _Alignof(1 + 1)?  Does the parser handle that?

No, and this is hard to do.  I've left the door open a bit by the way
the new expression emits a new OP instead of simply writing out a
constant (and this allows alignof(typeof(..)) to work as well).
However, I think the way the parser is written makes this difficult,
which is one reason that sizeof requires or does not require parens
depending on whether the argument is an expression or a type.

It would be possible to write "alignof expression", but I didn't want to
add an extension, especially since "alignof(typeof(expression))" is
pretty easy.

Pedro> Shouldn't we test _Alignof applied to the structure fields too?

It seems to me that this would necessarily be an expression, not a type.

Pedro> There was a snippet in the patch that made me wonder if the patch
Pedro> handles alignof of a no-debug-info variable and and the return-type
Pedro> of a no-debug-info function correctly (instead of e.g., crashing).
Pedro> I'd be nice to add a couples test to gdb.base/nodebug.exp
Pedro> to make sure.  E.g.:
Pedro>    p _Alignof (dataglobal64_1)
Pedro>    p _Alignof (middle())"

Pedro> Also, please add intro comments to the testcase .exp files, so
Pedro> that later on people can find out what the testcase is
Pedro> about easily.

Ok to all.

Tom
Tom Tromey April 26, 2018, 8:45 p.m. | #4
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


Pedro> What do we do with _Alignof(void)?  We treat sizeof(void) == 1,
Pedro> like gcc, so I assume the _Alignof will return 1 too instead
Pedro> of erroring out.

_Alignof(void) is accepted by gcc but alignof(void) is rejected by g++.
I've made the test do the former.

Tom
Tom Tromey April 26, 2018, 8:54 p.m. | #5
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


Pedro> There was a snippet in the patch that made me wonder if the patch
Pedro> handles alignof of a no-debug-info variable and and the return-type
Pedro> of a no-debug-info function correctly (instead of e.g., crashing).
Pedro> I'd be nice to add a couples test to gdb.base/nodebug.exp
Pedro> to make sure.  E.g.:
Pedro>    p _Alignof (dataglobal64_1)
Pedro>    p _Alignof (middle())"

I think these can't be done because _Alignof only applies to types.

Tom
Pedro Alves April 27, 2018, 6:02 p.m. | #6
On 04/24/2018 09:23 PM, Tom Tromey wrote:
>>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

> 

> Pedro> Shouldn't we test "long double"?  Patch #1 handles it.

> Pedro> Not sure all GCC ports support it, may require separate compilation.

> 

> I thought C didn't have long double (it's tested in the C++ test), but I

> see it does.  I will add that.

> 

> Pedro> Also, I'm wondering about "__int128" if the target

> Pedro> supports it.

> 

> I have bad feelings about trying to detect this in the test.


My thought was to simply support compiling a separate testcase
binary for a given type instead of mixing all types in
the same program.  So if a type is not supported, the program
won't compile and we'd skip the testing that type.  It'd basically
require moving the body of the testing code to a procedure that
is passed a list of types to compile & test in group.  So the
basic types that must be supported by all C/C++ implementations
would be one single group.  While other types like __int128 and
any other we add in future would be in separate groups / passes.

> 

> Pedro> In C++, do we get the alignment of non-standard layout classes right?

> Pedro> Likewise arrays, bitfields and typedefs?

> Pedro> What do we do with _Alignof(void)?

> 

> I will add these.

> 

> Pedro> I didn't spot any test for the

> Pedro>  "could not determine alignment of type"

> Pedro> case to make that that works gracefully without crashing.  

> 

> I think this one is maybe hard to test without some kind of bug (so far

> I've only seen it when some part of the patch was buggy), but I will see

> what I can do.

> 

> Pedro> Finally, for completeness, GCC allows _Alignof applied to

> Pedro> expressions, so I guess we should to.  Does the series allow that?

> Pedro> I.e., can we do _Alignof(1 + 1)?  Does the parser handle that?

> 

> No, and this is hard to do.  I've left the door open a bit by the way

> the new expression emits a new OP instead of simply writing out a

> constant (and this allows alignof(typeof(..)) to work as well).

> However, I think the way the parser is written makes this difficult,


OOC, can you expand a bit on what you mean here?  I would have assumed
that at the parser level, we'd just copy exactly what is done for
supporting expressions with sizeof.

> which is one reason that sizeof requires or does not require parens

> depending on whether the argument is an expression or a type.


Not clear what you mean here.  I know that sizeof with an expression
requires parenthesis in C/C++, but I'm not connecting the dots with
the above comments.

> It would be possible to write "alignof expression", but I didn't want to

> add an extension, 


Oh, you mean, you would want to make gdb require the parens when
given an expression as prerequisite for supporting expressions?

I wouldn't think that as a blocker, since AFAICS, we already have
that "extension" for sizeof:

 (gdb) p sizeof 1 + 1
 $1 = 5

so I wouldn't see it as a problem to make alignof work the same way,
and then if/when somebody wants to make gdb require the parens,
he'd just do it to both sizeof/alignof.

Anyway, I'll take alignof/_Alignof with no expressions over
no alignof/_Alignof, for sure.  :-)

> especially since "alignof(typeof(expression))" is

> pretty easy.


Ah, if that works, then yeah, that's a good escape hatch.

Should we have a test for that?

> 

> Pedro> Shouldn't we test _Alignof applied to the structure fields too?

> 

> It seems to me that this would necessarily be an expression, not a type.


Yeah.  I think the main complication here would be related to how the
expression machinery returns values and types, and then how to
distinguish a struct field of type X with a standalone variable of
type X, for alignof purposes (given x86's funny alignments).

Thanks,
Pedro Alves
Pedro Alves April 27, 2018, 6:05 p.m. | #7
On 04/26/2018 09:45 PM, Tom Tromey wrote:
>>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

> 

> Pedro> What do we do with _Alignof(void)?  We treat sizeof(void) == 1,

> Pedro> like gcc, so I assume the _Alignof will return 1 too instead

> Pedro> of erroring out.

> 

> _Alignof(void) is accepted by gcc but alignof(void) is rejected by g++.

> I've made the test do the former.


It's a warning, not rejected.  Just like for sizeof(void).

Thanks,
Pedro Alves
Tom Tromey April 27, 2018, 8:53 p.m. | #8
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


Pedro> My thought was to simply support compiling a separate testcase
Pedro> binary for a given type instead of mixing all types in
Pedro> the same program.  So if a type is not supported, the program
Pedro> won't compile and we'd skip the testing that type.

Ok, I can do that.  I'll put the "void" test there too -- the problem
with it being that (1) we'd need "nowarnings" and (2) since it isn't
really valid, presumably some other C++ compiler might reject it.

Tom> No, and this is hard to do.  I've left the door open a bit by the way
Tom> the new expression emits a new OP instead of simply writing out a
Tom> constant (and this allows alignof(typeof(..)) to work as well).
Tom> However, I think the way the parser is written makes this difficult,

Pedro> OOC, can you expand a bit on what you mean here?  I would have assumed
Pedro> that at the parser level, we'd just copy exactly what is done for
Pedro> supporting expressions with sizeof.

Right now we have:

exp	:	ALIGNOF '(' type_exp ')'	%prec UNARY
			{ write_exp_elt_opcode (pstate, UNOP_ALIGNOF); }
	;


We could add another production like:

exp : ALIGNOF '(' exp ')' ...

... but when I tried this the resulting parser had issues with the tests
-- claiming syntax errors where there were none.

Tom> which is one reason that sizeof requires or does not require parens
Tom> depending on whether the argument is an expression or a type.

Pedro> Not clear what you mean here.  I know that sizeof with an expression
Pedro> requires parenthesis in C/C++, but I'm not connecting the dots with
Pedro> the above comments.

For sizeof there are two productions:

exp	:	SIZEOF exp       %prec UNARY
			{ write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
	;

exp	:	SIZEOF '(' type ')'	%prec UNARY


I don't really know offhand why the latter is taken when a paren is
seen, it seems ambiguous to me.

Debugging this stuff is not very easy or enjoyable.  Switching to a
recursive descent parser would eliminate problems like this, because
some of the decisions would be turned into more simple programming
problems.

Tom> especially since "alignof(typeof(expression))" is
Tom> pretty easy.

Pedro> Ah, if that works, then yeah, that's a good escape hatch.

Pedro> Should we have a test for that?

Yeah, I'll add one.

Pedro> Yeah.  I think the main complication here would be related to how the
Pedro> expression machinery returns values and types, and then how to
Pedro> distinguish a struct field of type X with a standalone variable of
Pedro> type X, for alignof purposes (given x86's funny alignments).

I think with the new agreed-upon definition of alignof, this is no
longer a concern.

Tom
Tom Tromey April 30, 2018, 4:46 p.m. | #9
Pedro> My thought was to simply support compiling a separate testcase
Pedro> binary for a given type instead of mixing all types in
Pedro> the same program.

I ended up just adding a gdb_caching_proc that detects __int128 and then
conditionally appending __int128 to the list of types.  This seemed
simpler, and also it seemed to me that the test should have a lot of
type mixing anyway.

Tom

Patch

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 94d166e310..563aa517b8 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,16 @@ 
+2018-04-24  Tom Tromey  <tom@tromey.com>
+
+	PR exp/17095:
+	* NEWS: Update.
+	* std-operator.def (UNOP_ALIGNOF): New operator.
+	* expprint.c (dump_subexp_body_standard) <case UNOP_ALIGNOF>:
+	New.
+	* eval.c (evaluate_subexp_standard) <case UNOP_ALIGNOF>: New.
+	* c-lang.c (c_op_print_tab): Add alignof.
+	* c-exp.y (ALIGNOF): New token.
+	(exp): Add "ALIGNOF" production.
+	(ident_tokens): Add _Alignof and alignof.
+
 2018-04-24  Tom Tromey  <tom@tromey.com>
 
 	* i386-tdep.c (i386_type_align): New function.
diff --git a/gdb/NEWS b/gdb/NEWS
index 63fe30d175..6631b53475 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -9,6 +9,9 @@ 
 * 'info proc' now works on running processes on FreeBSD systems and core
   files created on FreeBSD systems.
 
+* C expressions can now use _Alignof, and C++ expressions can now use
+  alignof.
+
 * New commands
 
 set debug fbsd-nat
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 8dc3c068a5..64ec00da07 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -173,7 +173,7 @@  static void c_print_token (FILE *file, int type, YYSTYPE value);
 %token <ssym> NAME_OR_INT
 
 %token OPERATOR
-%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
+%token STRUCT CLASS UNION ENUM SIZEOF ALIGNOF UNSIGNED COLONCOLON
 %token TEMPLATE
 %token ERROR
 %token NEW DELETE
@@ -307,6 +307,10 @@  exp	:	SIZEOF exp       %prec UNARY
 			{ write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
 	;
 
+exp	:	ALIGNOF '(' type_exp ')'	%prec UNARY
+			{ write_exp_elt_opcode (pstate, UNOP_ALIGNOF); }
+	;
+
 exp	:	exp ARROW name
 			{ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 			  write_exp_string (pstate, $3);
@@ -2314,6 +2318,8 @@  static const struct token ident_tokens[] =
     {"struct", STRUCT, OP_NULL, 0},
     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
     {"sizeof", SIZEOF, OP_NULL, 0},
+    {"_Alignof", ALIGNOF, OP_NULL, 0},
+    {"alignof", ALIGNOF, OP_NULL, FLAG_CXX},
     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
     {"class", CLASS, OP_NULL, FLAG_CXX},
diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index 658c7f7826..15e633f8c8 100644
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -751,6 +751,7 @@  const struct op_print c_op_print_tab[] =
   {"*", UNOP_IND, PREC_PREFIX, 0},
   {"&", UNOP_ADDR, PREC_PREFIX, 0},
   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
+  {"alignof ", UNOP_ALIGNOF, PREC_PREFIX, 0},
   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
   {NULL, OP_NULL, PREC_PREFIX, 0}
diff --git a/gdb/eval.c b/gdb/eval.c
index b6fbfcf6c9..47ca03b5e1 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2662,6 +2662,19 @@  evaluate_subexp_standard (struct type *expect_type,
 	}
       return evaluate_subexp_for_sizeof (exp, pos, noside);
 
+    case UNOP_ALIGNOF:
+      {
+	struct type *type
+	  = value_type (evaluate_subexp (NULL_TYPE, exp, pos,
+					 EVAL_AVOID_SIDE_EFFECTS));
+	/* FIXME: This should be size_t.  */
+	struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
+	ULONGEST align = type_align (type);
+	if (align == 0)
+	  error (_("could not determine alignment of type"));
+	return value_from_longest (size_type, align);
+      }
+
     case UNOP_CAST:
       (*pos) += 2;
       type = exp->elts[pc + 1].type;
diff --git a/gdb/expprint.c b/gdb/expprint.c
index c906904599..5985f70a8f 100644
--- a/gdb/expprint.c
+++ b/gdb/expprint.c
@@ -846,6 +846,7 @@  dump_subexp_body_standard (struct expression *exp,
     case UNOP_PREDECREMENT:
     case UNOP_POSTDECREMENT:
     case UNOP_SIZEOF:
+    case UNOP_ALIGNOF:
     case UNOP_PLUS:
     case UNOP_CAP:
     case UNOP_CHR:
diff --git a/gdb/std-operator.def b/gdb/std-operator.def
index 87bb518877..1297c1edeb 100644
--- a/gdb/std-operator.def
+++ b/gdb/std-operator.def
@@ -234,6 +234,7 @@  OP (UNOP_POSTINCREMENT)		/* ++ after an expression */
 OP (UNOP_PREDECREMENT)		/* -- before an expression */
 OP (UNOP_POSTDECREMENT)		/* -- after an expression */
 OP (UNOP_SIZEOF)		/* Unary sizeof (followed by expression) */
+OP (UNOP_ALIGNOF)		/* Unary alignof (followed by expression) */
 
 OP (UNOP_PLUS)			/* Unary plus */
 
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index d5e9429041..ad7889b677 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,10 @@ 
+2018-04-24  Tom Tromey  <tom@tromey.com>
+
+	PR exp/17095:
+	* gdb.dwarf2/dw2-align.exp: New file.
+	* gdb.cp/align.exp: New file.
+	* gdb.base/align.exp: New file.
+
 2018-04-19  Richard Bunt  <richard.bunt@arm.com>
 
 	* gdb.threads/multiple-successive-infcall.c: New test.
diff --git a/gdb/testsuite/gdb.base/align.exp b/gdb/testsuite/gdb.base/align.exp
new file mode 100644
index 0000000000..98c19e3086
--- /dev/null
+++ b/gdb/testsuite/gdb.base/align.exp
@@ -0,0 +1,94 @@ 
+# Copyright 2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the gdb testsuite
+
+# The types we're going to test.
+
+set typelist {
+    char {unsigned char}
+    short {unsigned short}
+    int {unsigned int}
+    long {unsigned long}
+    {long long} {unsigned long long}
+    float
+    double
+}
+
+# Create the test file.
+
+set filename [standard_output_file align.c]
+set outfile [open $filename w]
+
+# Prologue.
+puts -nonewline $outfile "#define DEF(T,U) struct align_pair_ ## T ## _x_ ## U "
+puts $outfile "{ T one; U two; }"
+
+# First emit single items.
+foreach type $typelist {
+    set utype [join [split $type] _]
+    if {$type != $utype} {
+	puts $outfile "typedef $type $utype;"
+    }
+    puts $outfile "$type item_$utype;"
+    puts $outfile "unsigned a_$utype\n  = _Alignof ($type);"
+    set utype [join [split $type] _]
+}
+
+# Now emit all pairs.
+foreach type $typelist {
+    set utype [join [split $type] _]
+    foreach inner $typelist {
+	set uinner [join [split $inner] _]
+	puts $outfile "DEF ($utype, $uinner);"
+	set joined "${utype}_x_${uinner}"
+	puts $outfile "struct align_pair_$joined item_${joined};"
+	puts $outfile "unsigned a_${joined}"
+	puts $outfile "  = _Alignof (struct align_pair_${joined});"
+    }
+}
+
+# Epilogue.
+puts $outfile {
+    int main() {
+	return 0;
+    }
+}
+
+close $outfile
+
+standard_testfile $filename
+
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug}]} {
+    return -1
+}
+
+if {![runto_main]} {
+    perror "test suppressed"
+    return
+}
+
+foreach type $typelist {
+    set utype [join [split $type] _]
+    set expected [get_integer_valueof a_$utype 0]
+    gdb_test "print _Alignof($type)" " = $expected"
+
+    foreach inner $typelist {
+	set uinner [join [split $inner] _]
+	set expected [get_integer_valueof a_${utype}_x_${uinner} 0]
+	gdb_test "print _Alignof(struct align_pair_${utype}_x_${uinner})" \
+	    " = $expected"
+    }
+}
diff --git a/gdb/testsuite/gdb.cp/align.exp b/gdb/testsuite/gdb.cp/align.exp
new file mode 100644
index 0000000000..9037aeb2c7
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/align.exp
@@ -0,0 +1,129 @@ 
+# Copyright 2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the gdb testsuite
+
+if {[skip_cplus_tests]} { continue }
+
+# The types we're going to test.
+
+set typelist {
+    char {unsigned char}
+    short {unsigned short}
+    int {unsigned int}
+    long {unsigned long}
+    {long long} {unsigned long long}
+    float
+    double {long double}
+    bigenum
+}
+
+# Create the test file.
+
+set filename [standard_output_file align.cc]
+set outfile [open $filename w]
+
+# Prologue.
+puts $outfile {
+    template<typename T, typename U>
+    struct align_pair
+    {
+	T one;
+	U two;
+    };
+
+    template<typename T, typename U>
+    struct align_union
+    {
+	T one;
+	U two;
+    };
+
+    enum bigenum { VALUE = 0xffffffffull };
+
+    struct empty { };
+    empty item_empty;
+    unsigned a_empty = alignof (empty);
+}
+
+# First emit single items.
+foreach type $typelist {
+    set utype [join [split $type] _]
+    puts $outfile "$type item_$utype;"
+    puts $outfile "unsigned a_$utype\n  = alignof ($type);"
+}
+
+# Now emit all pairs.
+foreach type $typelist {
+    set utype [join [split $type] _]
+    foreach inner $typelist {
+	set uinner [join [split $inner] _]
+	puts $outfile "align_pair<$type, $inner> item_${utype}_x_${uinner};"
+	puts $outfile "unsigned a_${utype}_x_${uinner}"
+	puts $outfile "  = alignof (align_pair<$type, $inner>);"
+
+	puts $outfile "align_union<$type, $inner> item_${utype}_u_${uinner};"
+	puts $outfile "unsigned a_${utype}_u_${uinner}"
+	puts $outfile "  = alignof (align_union<$type, $inner>);"
+    }
+}
+
+# Epilogue.
+puts $outfile {
+    int main() {
+	return 0;
+    }
+}
+
+close $outfile
+
+standard_testfile $filename
+
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
+	 {debug c++ additional_flags=-std=c++11}]} {
+    return -1
+}
+
+if {![runto_main]} {
+    perror "test suppressed"
+    return
+}
+
+foreach type $typelist {
+    set utype [join [split $type] _]
+    set expected [get_integer_valueof a_$utype 0]
+
+    # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69560
+    # The g++ implementation of alignof is changing to match C11.
+    if {[is_x86_like_target]
+	&& ($type == "double" || $type == "long long"
+	    || $type == "unsigned long long")} {
+	setup_xfail *-*-*
+    }
+
+    gdb_test "print alignof($type)" " = $expected"
+
+    foreach inner $typelist {
+	set uinner [join [split $inner] _]
+	set expected [get_integer_valueof a_${utype}_x_${uinner} 0]
+	gdb_test "print alignof(align_pair<${type},${inner}>)" " = $expected"
+
+	set expected [get_integer_valueof a_${utype}_u_${uinner} 0]
+	gdb_test "print alignof(align_union<${type},${inner}>)" " = $expected"
+    }
+}
+
+set expected [get_integer_valueof a_empty 0]
+gdb_test "print alignof(empty)" " = $expected"
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-align.exp b/gdb/testsuite/gdb.dwarf2/dw2-align.exp
new file mode 100644
index 0000000000..2c2faf7591
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-align.exp
@@ -0,0 +1,83 @@ 
+# Copyright 2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+load_lib dwarf.exp
+
+# This test can only be run on targets which support DWARF-2 and use gas.
+if {![dwarf2_support]} {
+    return 0
+}
+
+standard_testfile main.c align-dw.S
+
+# Make some DWARF for the test.
+
+set asm_file [standard_output_file $srcfile2]
+Dwarf::assemble $asm_file {
+    global srcdir subdir srcfile
+
+    cu {} {
+	DW_TAG_compile_unit {
+                {DW_AT_language @DW_LANG_C_plus_plus}
+                {DW_AT_name     dw2-align.c}
+                {DW_AT_comp_dir /tmp}
+        } {
+	    declare_labels itype ptype
+
+            itype: DW_TAG_base_type {
+                {DW_AT_byte_size 4 DW_FORM_sdata}
+                {DW_AT_encoding  @DW_ATE_signed}
+                {DW_AT_name int_4096}
+		{DW_AT_alignment 4096 DW_FORM_sdata}
+            }
+
+            ptype: DW_TAG_pointer_type {
+                {DW_AT_byte_size 8 DW_FORM_sdata}
+                {DW_AT_type :$itype}
+		{DW_AT_alignment 4096 DW_FORM_sdata}
+            }
+
+            DW_TAG_typedef {
+                {DW_AT_name ptr_4096}
+                {DW_AT_type :$ptype}
+            }
+
+	    DW_TAG_structure_type {
+		{DW_AT_name "struct_4096"}
+		{DW_AT_byte_size 4096 DW_FORM_sdata}
+		{DW_AT_alignment 4096 DW_FORM_udata}
+	    } {
+		member {
+		    {name a}
+		    {type :$itype}
+		    {data_member_location 0 data1}
+		}
+	    }
+	}
+    }
+}
+
+if { [prepare_for_testing "failed to prepare" ${testfile} \
+	  [list $srcfile $asm_file] {nodebug}] } {
+    return -1
+}
+
+if ![runto_main] {
+    return -1
+}
+
+gdb_test_no_output "set lang c++"
+gdb_test "print alignof(int_4096)" " = 4096"
+gdb_test "print alignof(ptr_4096)" " = 4096"
+gdb_test "print alignof(struct_4096)" " = 4096"