mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
1d506c26d9
This commit is the result of the following actions:
- Running gdb/copyright.py to update all of the copyright headers to
include 2024,
- Manually updating a few files the copyright.py script told me to
update, these files had copyright headers embedded within the
file,
- Regenerating gdbsupport/Makefile.in to refresh it's copyright
date,
- Using grep to find other files that still mentioned 2023. If
these files were updated last year from 2022 to 2023 then I've
updated them this year to 2024.
I'm sure I've probably missed some dates. Feel free to fix them up as
you spot them.
498 lines
8.9 KiB
C++
498 lines
8.9 KiB
C++
/* This testcase is part of GDB, the GNU debugger.
|
|
|
|
Copyright 2017-2024 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/>. */
|
|
|
|
/* Code for the all-param-prefixes test. */
|
|
|
|
void
|
|
param_prefixes_test_long (long)
|
|
{}
|
|
|
|
void
|
|
param_prefixes_test_intp_intr (int *, int&)
|
|
{}
|
|
|
|
/* Code for the overload test. */
|
|
|
|
void
|
|
overload_ambiguous_test (long)
|
|
{}
|
|
|
|
void
|
|
overload_ambiguous_test (int, int)
|
|
{}
|
|
|
|
void
|
|
overload_ambiguous_test (int, long)
|
|
{}
|
|
|
|
/* Code for the overload-2 test. */
|
|
|
|
/* Generate functions/methods all with the same name, in different
|
|
scopes, but all with different parameters. */
|
|
|
|
struct overload2_arg1 {};
|
|
struct overload2_arg2 {};
|
|
struct overload2_arg3 {};
|
|
struct overload2_arg4 {};
|
|
struct overload2_arg5 {};
|
|
struct overload2_arg6 {};
|
|
struct overload2_arg7 {};
|
|
struct overload2_arg8 {};
|
|
struct overload2_arg9 {};
|
|
struct overload2_arga {};
|
|
|
|
#define GEN_OVERLOAD2_FUNCTIONS(ARG1, ARG2) \
|
|
void __attribute__ ((used)) \
|
|
overload2_function (ARG1) \
|
|
{} \
|
|
\
|
|
struct struct_overload2_test \
|
|
{ \
|
|
void __attribute__ ((used)) \
|
|
overload2_function (ARG2); \
|
|
}; \
|
|
\
|
|
void __attribute__ ((used)) \
|
|
struct_overload2_test::overload2_function (ARG2) \
|
|
{}
|
|
|
|
/* In the global namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS( overload2_arg1, overload2_arg2)
|
|
|
|
namespace
|
|
{
|
|
/* In an anonymous namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg3, overload2_arg4)
|
|
}
|
|
|
|
namespace ns_overload2_test
|
|
{
|
|
/* In a namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg5, overload2_arg6)
|
|
|
|
namespace
|
|
{
|
|
/* In a nested anonymous namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg7, overload2_arg8)
|
|
|
|
namespace ns_overload2_test
|
|
{
|
|
/* In a nested namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg9, overload2_arga)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Code for the overload-3 test. */
|
|
|
|
#define GEN_OVERLOAD3_FUNCTIONS(ARG1, ARG2) \
|
|
void __attribute__ ((used)) \
|
|
overload3_function (ARG1) \
|
|
{} \
|
|
void __attribute__ ((used)) \
|
|
overload3_function (ARG2) \
|
|
{} \
|
|
\
|
|
struct struct_overload3_test \
|
|
{ \
|
|
void __attribute__ ((used)) \
|
|
overload3_function (ARG1); \
|
|
void __attribute__ ((used)) \
|
|
overload3_function (ARG2); \
|
|
}; \
|
|
\
|
|
void __attribute__ ((used)) \
|
|
struct_overload3_test::overload3_function (ARG1) \
|
|
{} \
|
|
void __attribute__ ((used)) \
|
|
struct_overload3_test::overload3_function (ARG2) \
|
|
{}
|
|
|
|
/* In the global namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace
|
|
{
|
|
/* In an anonymous namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
}
|
|
|
|
namespace ns_overload3_test
|
|
{
|
|
/* In a namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace
|
|
{
|
|
/* In a nested anonymous namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace ns_overload3_test
|
|
{
|
|
/* In a nested namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Code for the template-function_foo (template parameter completion) tests. */
|
|
|
|
template <typename T>
|
|
struct template_struct
|
|
{
|
|
T template_overload_fn (T);
|
|
};
|
|
|
|
template <typename T>
|
|
T template_struct<T>::template_overload_fn (T t)
|
|
{
|
|
return t;
|
|
}
|
|
|
|
template_struct<int> template_struct_int;
|
|
template_struct<long> template_struct_long;
|
|
|
|
/* Code for the template-parameter-overload test. */
|
|
|
|
template <typename T>
|
|
void foo (T c) {}
|
|
|
|
template <typename T1, typename T2>
|
|
void foo (T1 a, T2 b) {}
|
|
|
|
template <typename T>
|
|
struct a
|
|
{
|
|
void method () {}
|
|
};
|
|
|
|
template <typename T>
|
|
struct b
|
|
{
|
|
void method () {}
|
|
};
|
|
|
|
template <typename T>
|
|
struct c
|
|
{
|
|
void method () {}
|
|
};
|
|
|
|
template <typename T>
|
|
struct d
|
|
{
|
|
void method () {};
|
|
};
|
|
|
|
template <typename T1, typename T2>
|
|
struct A
|
|
{
|
|
void method () {}
|
|
};
|
|
|
|
template <typename T1, typename T2>
|
|
struct B
|
|
{
|
|
void method () {}
|
|
};
|
|
|
|
namespace n
|
|
{
|
|
struct na {};
|
|
struct nb {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct NA {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct NB {};
|
|
};
|
|
|
|
static void
|
|
template_function_foo ()
|
|
{
|
|
a<a<int>> aa;
|
|
aa.method ();
|
|
a<b<int>> ab;
|
|
ab.method ();
|
|
c<c<int>> cc;
|
|
cc.method ();
|
|
c<d<int>> cd;
|
|
cd.method ();
|
|
foo (aa);
|
|
foo (ab);
|
|
foo (cc);
|
|
foo (cd);
|
|
foo (aa, ab);
|
|
foo (aa, cc);
|
|
foo (aa, cd);
|
|
|
|
A<a<b<int>>, c<d<int>>> Aabcd;
|
|
Aabcd.method ();
|
|
foo (Aabcd);
|
|
|
|
A<a<b<int>>, a<a<int>>> Aabaa;
|
|
Aabaa.method ();
|
|
foo (Aabaa);
|
|
|
|
A<a<b<int>>, a<b<int>>> Aabab;
|
|
Aabab.method ();
|
|
foo (Aabab);
|
|
|
|
B<a<b<int>>, c<d<int>>> Babcd;
|
|
Babcd.method ();
|
|
foo (Babcd);
|
|
|
|
foo (Aabcd, Babcd);
|
|
foo (Aabcd, Aabaa);
|
|
foo (Aabcd, Aabab);
|
|
|
|
n::na na;
|
|
n::nb nb;
|
|
foo (na, nb);
|
|
a<n::na> ana;
|
|
b<n::nb> bnb;
|
|
foo (ana, bnb);
|
|
|
|
n::NA<n::na, n::nb> NAnanb;
|
|
n::NB<n::na, n::nb> Nbnanb;
|
|
foo (NAnanb, Nbnanb);
|
|
}
|
|
|
|
/* Code for the template2-ret-type tests. */
|
|
|
|
template <typename T>
|
|
struct template2_ret_type {};
|
|
|
|
template <typename T>
|
|
struct template2_struct
|
|
{
|
|
template <typename T2, typename T3>
|
|
T template2_fn (T = T (), T2 t2 = T2 (), T3 t3 = T3 ());
|
|
};
|
|
|
|
template <typename T>
|
|
template <typename T2, typename T3>
|
|
T template2_struct<T>::template2_fn (T t, T2 t2, T3 t3)
|
|
{
|
|
return T ();
|
|
}
|
|
|
|
template2_struct<template2_ret_type<int> > template2_struct_inst;
|
|
|
|
/* Code for the const-overload tests. */
|
|
|
|
struct struct_with_const_overload
|
|
{
|
|
void const_overload_fn ();
|
|
void const_overload_fn () const;
|
|
};
|
|
|
|
void
|
|
struct_with_const_overload::const_overload_fn ()
|
|
{}
|
|
|
|
void
|
|
struct_with_const_overload::const_overload_fn () const
|
|
{}
|
|
|
|
void
|
|
not_overloaded_fn ()
|
|
{}
|
|
|
|
/* Code for the incomplete-scope-colon tests. */
|
|
|
|
struct struct_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test ();
|
|
};
|
|
|
|
void
|
|
struct_incomplete_scope_colon_test::incomplete_scope_colon_test ()
|
|
{}
|
|
|
|
namespace ns_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test () {}
|
|
}
|
|
|
|
namespace ns2_incomplete_scope_colon_test
|
|
{
|
|
struct struct_in_ns2_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test ();
|
|
};
|
|
|
|
void
|
|
struct_in_ns2_incomplete_scope_colon_test::incomplete_scope_colon_test ()
|
|
{}
|
|
}
|
|
|
|
/* Code for the anon-ns tests. */
|
|
|
|
namespace
|
|
{
|
|
void __attribute__ ((used)) anon_ns_function ()
|
|
{}
|
|
|
|
struct anon_ns_struct
|
|
{
|
|
void __attribute__ ((used)) anon_ns_function ();
|
|
};
|
|
|
|
void __attribute__ ((used))
|
|
anon_ns_struct::anon_ns_function ()
|
|
{}
|
|
}
|
|
|
|
namespace the_anon_ns_wrapper_ns
|
|
{
|
|
|
|
namespace
|
|
{
|
|
void __attribute__ ((used)) anon_ns_function ()
|
|
{}
|
|
|
|
struct anon_ns_struct
|
|
{
|
|
void __attribute__ ((used)) anon_ns_function ();
|
|
};
|
|
|
|
void __attribute__ ((used))
|
|
anon_ns_struct::anon_ns_function ()
|
|
{}
|
|
}
|
|
|
|
} /* the_anon_ns_wrapper_ns */
|
|
|
|
/* Code for the global-ns-scope-op tests. */
|
|
|
|
void global_ns_scope_op_function ()
|
|
{
|
|
}
|
|
|
|
/* Add a function with the same name to a namespace. We want to test
|
|
that "b ::global_ns_function" does NOT select it. */
|
|
namespace the_global_ns_scope_op_ns
|
|
{
|
|
void global_ns_scope_op_function ()
|
|
{
|
|
}
|
|
}
|
|
|
|
/* Code for the ambiguous-prefix tests. */
|
|
|
|
/* Create a few functions/methods with the same "ambiguous_prefix_"
|
|
prefix. They in different scopes, but "b ambiguous_prefix_<tab>"
|
|
should list them all, and figure out the LCD is
|
|
ambiguous_prefix_. */
|
|
|
|
void ambiguous_prefix_global_func ()
|
|
{
|
|
}
|
|
|
|
namespace the_ambiguous_prefix_ns
|
|
{
|
|
void ambiguous_prefix_ns_func ()
|
|
{
|
|
}
|
|
}
|
|
|
|
struct the_ambiguous_prefix_struct
|
|
{
|
|
void ambiguous_prefix_method ();
|
|
};
|
|
|
|
void
|
|
the_ambiguous_prefix_struct::ambiguous_prefix_method ()
|
|
{
|
|
}
|
|
|
|
/* Code for the function-labels test. */
|
|
|
|
int
|
|
function_with_labels (int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
label1:
|
|
return i + 20;
|
|
}
|
|
else
|
|
{
|
|
label2:
|
|
return i + 10;
|
|
}
|
|
}
|
|
|
|
/* Code for the no-data-symbols and if-expression tests. */
|
|
|
|
int code_data = 0;
|
|
|
|
int another_data = 0;
|
|
|
|
/* A function that has a same "code" prefix as the global above. We
|
|
want to ensure that completing on "b code" doesn't offer the data
|
|
symbol. */
|
|
void
|
|
code_function ()
|
|
{
|
|
}
|
|
|
|
/* Code for the operator< tests. */
|
|
|
|
enum foo_enum
|
|
{
|
|
foo_value
|
|
};
|
|
|
|
bool operator<(foo_enum lhs, foo_enum rhs)
|
|
{
|
|
label1:
|
|
return false;
|
|
}
|
|
|
|
/* Code for the in-source-file-unconstrained /
|
|
in-source-file-ambiguous tests. */
|
|
|
|
int
|
|
file_constrained_test_cpls_function (int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
label1:
|
|
return i + 20;
|
|
}
|
|
else
|
|
{
|
|
label2:
|
|
return i + 10;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
main ()
|
|
{
|
|
template2_struct_inst.template2_fn<int, int> ();
|
|
template_struct_int.template_overload_fn(0);
|
|
template_struct_long.template_overload_fn(0);
|
|
template_function_foo ();
|
|
|
|
return 0;
|
|
}
|