OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adjust start-of-function braces to be compatible with Clang 

gdb/testsuite/
	* gdb.cp/cpexprs.cc: Move braces to the same line as the start
	of the function to work across GCC and Clang.
	* gdb.cp/cpexprs.exp: Account for GCC/Clang difference in vtable
	pointer types (const void ** const V void **).
This commit is contained in:
David Blaikie 2014-04-13 17:37:56 -07:00
parent 08937d8023
commit 25d4e99db8
3 changed files with 113 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gdb/testsuite/ChangeLog
View File

@ -1,3 +1,10 @@
2014-04-24 David Blaikie <dblaikie@gmail.com>
* gdb.cp/cpexprs.cc: Move braces to the same line as the start
of the function to work across GCC and Clang.
* gdb.cp/cpexprs.exp: Account for GCC/Clang difference in vtable
pointer types (const void ** const V void **).
2014-04-24 Michael Sturm <michael.sturm@mintel.com> 2014-04-24 Michael Sturm <michael.sturm@mintel.com>
Walfred Tedeschi <walfred.tedeschi@intel.com> Walfred Tedeschi <walfred.tedeschi@intel.com>

170
gdb/testsuite/gdb.cp/cpexprs.cc
View File

@ -49,8 +49,7 @@ void tclass<short>::do_something () { } // tclass<short>::do_something
// A simple template with multiple template parameters // A simple template with multiple template parameters
template <class A, class B, class C, class D, class E> template <class A, class B, class C, class D, class E>
void flubber (void) // flubber void flubber (void) { // flubber
{
A a; A a;
B b; B b;
C c; C c;
@ -144,128 +143,128 @@ public:
int overload (base& b) const { return 5; } // base::overload(base&) const int overload (base& b) const { return 5; } // base::overload(base&) const
// Operators // Operators
int operator+ (base const& o) const // base::operator+ int operator+ (base const& o) const { // base::operator+
{ return foo_ + o.foo_; } return foo_ + o.foo_; }
base operator++ (void) // base::operator++ base operator++ (void) { // base::operator++
{ ++foo_; return *this; } ++foo_; return *this; }
base operator+=(base const& o) // base::operator+= base operator+=(base const& o) { // base::operator+=
{ foo_ += o.foo_; return *this; } foo_ += o.foo_; return *this; }
int operator- (base const& o) const // base::operator- int operator- (base const& o) const { // base::operator-
{ return foo_ - o.foo_; } return foo_ - o.foo_; }
base operator-- (void) // base::operator-- base operator-- (void) { // base::operator--
{ --foo_; return *this; } --foo_; return *this; }
base operator-= (base const& o) // base::operator-= base operator-= (base const& o) { // base::operator-=
{ foo_ -= o.foo_; return *this; } foo_ -= o.foo_; return *this; }
int operator* (base const& o) const // base::operator* int operator* (base const& o) const { // base::operator*
{ return foo_ * o.foo_; } return foo_ * o.foo_; }
base operator*= (base const& o) // base::operator*= base operator*= (base const& o) { // base::operator*=
{ foo_ *= o.foo_; return *this; } foo_ *= o.foo_; return *this; }
int operator/ (base const& o) const // base::operator/ int operator/ (base const& o) const { // base::operator/
{ return foo_ / o.foo_; } return foo_ / o.foo_; }
base operator/= (base const& o) // base::operator/= base operator/= (base const& o) { // base::operator/=
{ foo_ /= o.foo_; return *this; } foo_ /= o.foo_; return *this; }
int operator% (base const& o) const // base::operator% int operator% (base const& o) const { // base::operator%
{ return foo_ % o.foo_; } return foo_ % o.foo_; }
base operator%= (base const& o) // base::operator%= base operator%= (base const& o) { // base::operator%=
{ foo_ %= o.foo_; return *this; } foo_ %= o.foo_; return *this; }
bool operator< (base const& o) const // base::operator< bool operator< (base const& o) const { // base::operator<
{ return foo_ < o.foo_; } return foo_ < o.foo_; }
bool operator<= (base const& o) const // base::operator<= bool operator<= (base const& o) const { // base::operator<=
{ return foo_ <= o.foo_; } return foo_ <= o.foo_; }
bool operator> (base const& o) const // base::operator> bool operator> (base const& o) const { // base::operator>
{ return foo_ > o.foo_; } return foo_ > o.foo_; }
bool operator>= (base const& o) const // base::operator>= bool operator>= (base const& o) const { // base::operator>=
{ return foo_ >= o.foo_; } return foo_ >= o.foo_; }
bool operator!= (base const& o) const // base::operator!= bool operator!= (base const& o) const { // base::operator!=
{ return foo_ != o.foo_; } return foo_ != o.foo_; }
bool operator== (base const& o) const // base::operator== bool operator== (base const& o) const { // base::operator==
{ return foo_ == o.foo_; } return foo_ == o.foo_; }
bool operator! (void) const // base::operator! bool operator! (void) const { // base::operator!
{ return !foo_; } return !foo_; }
bool operator&& (base const& o) const // base::operator&& bool operator&& (base const& o) const { // base::operator&&
{ return foo_ && o.foo_; } return foo_ && o.foo_; }
bool operator|| (base const& o) const // base::operator|| bool operator|| (base const& o) const { // base::operator||
{ return foo_ || o.foo_; } return foo_ || o.foo_; }
int operator<< (int value) const // base::operator<< int operator<< (int value) const { // base::operator<<
{ return foo_ << value; } return foo_ << value; }
base operator<<= (int value) // base::operator<<= base operator<<= (int value) { // base::operator<<=
{ foo_ <<= value; return *this; } foo_ <<= value; return *this; }
int operator>> (int value) const // base::operator>> int operator>> (int value) const { // base::operator>>
{ return foo_ >> value; } return foo_ >> value; }
base operator>>= (int value) // base::operator>>= base operator>>= (int value) { // base::operator>>=
{ foo_ >>= value; return *this; } foo_ >>= value; return *this; }
int operator~ (void) const // base::operator~ int operator~ (void) const { // base::operator~
{ return ~foo_; } return ~foo_; }
int operator& (base const& o) const // base::operator& int operator& (base const& o) const { // base::operator&
{ return foo_ & o.foo_; } return foo_ & o.foo_; }
base operator&= (base const& o) // base::operator&= base operator&= (base const& o) { // base::operator&=
{ foo_ &= o.foo_; return *this; } foo_ &= o.foo_; return *this; }
int operator| (base const& o) const // base::operator| int operator| (base const& o) const { // base::operator|
{ return foo_ | o.foo_; } return foo_ | o.foo_; }
base operator|= (base const& o) // base::operator|= base operator|= (base const& o) { // base::operator|=
{ foo_ |= o.foo_; return *this; } foo_ |= o.foo_; return *this; }
int operator^ (base const& o) const // base::operator^ int operator^ (base const& o) const { // base::operator^
{ return foo_ ^ o.foo_; } return foo_ ^ o.foo_; }
base operator^= (base const& o) // base::operator^= base operator^= (base const& o) { // base::operator^=
{ foo_ ^= o.foo_; return *this; } foo_ ^= o.foo_; return *this; }
base operator= (base const& o) // base::operator= base operator= (base const& o) { // base::operator=
{ foo_ = o.foo_; return *this; } foo_ = o.foo_; return *this; }
void operator() (void) const // base::operator() void operator() (void) const { // base::operator()
{ return; } return; }
int operator[] (int idx) const // base::operator[] int operator[] (int idx) const { // base::operator[]
{ return idx; } return idx; }
void* operator new (size_t size) throw () // base::operator new void* operator new (size_t size) throw () { // base::operator new
{ return malloc (size); } return malloc (size); }
void operator delete (void* ptr) // base::operator delete void operator delete (void* ptr) { // base::operator delete
{ free (ptr); } free (ptr); }
void* operator new[] (size_t size) throw () // base::operator new[] void* operator new[] (size_t size) throw () { // base::operator new[]
{ return malloc (size); } return malloc (size); }
void operator delete[] (void* ptr) // base::operator delete[] void operator delete[] (void* ptr) { // base::operator delete[]
{ free (ptr); } free (ptr); }
base const* operator-> (void) const // base::opeartor-> base const* operator-> (void) const { // base::opeartor->
{ return this; } return this; }
int operator->* (base const& b) const // base::operator->* int operator->* (base const& b) const { // base::operator->*
{ return foo_ * b.foo_; } return foo_ * b.foo_; }
operator char* () const { return const_cast<char*> ("hello"); } // base::operator char* operator char* () const { return const_cast<char*> ("hello"); } // base::operator char*
operator int () const { return 21; } // base::operator int operator int () const { return 21; } // base::operator int
@ -298,8 +297,7 @@ class derived : public base1, public base2
{ {
public: public:
derived(void) : foo_ (4) { } // derived::derived derived(void) : foo_ (4) { } // derived::derived
void a_function (void) const // derived::a_function void a_function (void) const { // derived::a_function
{
this->base1::a_function (); this->base1::a_function ();
this->base2::a_function (); this->base2::a_function ();
} }

32
gdb/testsuite/gdb.cp/cpexprs.exp
View File

@ -54,7 +54,7 @@ proc test_breakpoint {func} {
# Usage: # Usage:
# add NAME TYPE PRINT LST # add NAME TYPE PRINT LST
# add NAME TYPE PRINT - # add NAME TYPE PRINT -
proc add {func type print lst} { proc add_type_regexp {func type print lst} {
global all_functions CONVAR ADDR global all_functions CONVAR ADDR
set all_functions($func,type) $type set all_functions($func,type) $type
@ -67,13 +67,17 @@ proc add {func type print lst} {
regsub {\(void\)} $print {()} print regsub {\(void\)} $print {()} print
set all_functions($func,print) \ set all_functions($func,print) \
"$CONVAR = {[string_to_regexp $type]} $ADDR <[string_to_regexp $print].*>" "$CONVAR = {$type} $ADDR <[string_to_regexp $print].*>"
if {$lst == "-"} { if {$lst == "-"} {
set lst "$func" set lst "$func"
} }
set all_functions($func,list) ".*// [string_to_regexp $lst]" set all_functions($func,list) ".*// [string_to_regexp $lst]"
} }
proc add {func type print lst} {
add_type_regexp $func [string_to_regexp $type] $print $lst
}
proc get {func cmd} { proc get {func cmd} {
global all_functions global all_functions
return $all_functions($func,$cmd) return $all_functions($func,$cmd)
@ -139,32 +143,40 @@ add {base2::a_function} \
# On targets using the ARM EABI, the constructor is expected to return # On targets using the ARM EABI, the constructor is expected to return
# "this". # "this".
proc ctor { type arglist } { proc ctor_ret { type } {
if { [istarget arm*-*eabi*] } { if { [istarget arm*-*eabi*] } {
set ret "$type *" return "$type *"
} else { } else {
set ret "void " return "void "
} }
}
proc ctor_prefix { type } {
set ret [ctor_ret $type]
return "${ret}($type * const"
}
proc ctor { type arglist } {
if { $arglist != "" } { if { $arglist != "" } {
set arglist ", $arglist" set arglist ", $arglist"
} }
return "${ret}($type * const$arglist)" return "[ctor_prefix $type]$arglist)"
} }
add {derived::derived} \ add {derived::derived} \
[ctor derived ""] \ [ctor derived ""] \
- \ - \
- -
add {base1::base1(void)} \ add_type_regexp {base1::base1(void)} \
[ctor base1 "const void ** const"] \ "[string_to_regexp [ctor_prefix base1]], (const )?void \\*\\*( const)?\\)" \
- \ - \
- -
add {base1::base1(int)} \ add {base1::base1(int)} \
[ctor base1 "int"] \ [ctor base1 "int"] \
- \ - \
- -
add {base2::base2} \ add_type_regexp {base2::base2} \
[ctor base2 "const void ** const"] \ "[string_to_regexp [ctor_prefix base2]], (const )?void \\*\\*( const)?\\)" \
- \ - \
- -
add {base::base(void)} \ add {base::base(void)} \