The execute tests use abort/exit to report failure/success, but
they generally do not declare these functions (or include <stdlib.h>).
This change adds declarations as appropriate.
It would have been possible to switch to __builtin_abort and
__builtin_exit instead. Existing practice varies. Adding the
declarations makes it easier to write the GNU-style commit message
because it is not necessary to mention the function with the call
site.
Instead of this change, it would be possible to create a special
header file with the declarations that is included during the
test file compilation using -include, but that would mean that
many tests would no longer build standalone.
gcc/testsuite/ChangeLog:
* gcc.c-torture/execute/
20000112-1.c: Declare exit and abort
as appropriate.
* gcc.c-torture/execute/
20000113-1.c: Likewise.
* gcc.c-torture/execute/
20000205-1.c: Likewise.
* gcc.c-torture/execute/
20000217-1.c: Likewise.
* gcc.c-torture/execute/
20000223-1.c: Likewise.
* gcc.c-torture/execute/
20000224-1.c: Likewise.
* gcc.c-torture/execute/
20000225-1.c: Likewise.
* gcc.c-torture/execute/
20000227-1.c: Likewise.
* gcc.c-torture/execute/
20000313-1.c: Likewise.
* gcc.c-torture/execute/
20000314-1.c: Likewise.
* gcc.c-torture/execute/
20000314-2.c: Likewise.
* gcc.c-torture/execute/
20000314-3.c: Likewise.
* gcc.c-torture/execute/
20000402-1.c: Likewise.
* gcc.c-torture/execute/
20000403-1.c: Likewise.
* gcc.c-torture/execute/
20000412-1.c: Likewise.
* gcc.c-torture/execute/
20000412-2.c: Likewise.
* gcc.c-torture/execute/
20000412-4.c: Likewise.
* gcc.c-torture/execute/
20000412-5.c: Likewise.
* gcc.c-torture/execute/
20000412-6.c: Likewise.
* gcc.c-torture/execute/
20000419-1.c: Likewise.
* gcc.c-torture/execute/
20000422-1.c: Likewise.
* gcc.c-torture/execute/
20000503-1.c: Likewise.
* gcc.c-torture/execute/
20000511-1.c: Likewise.
* gcc.c-torture/execute/
20000519-1.c: Likewise.
* gcc.c-torture/execute/
20000519-2.c: Likewise.
* gcc.c-torture/execute/
20000523-1.c: Likewise.
* gcc.c-torture/execute/
20000528-1.c: Likewise.
* gcc.c-torture/execute/
20000603-1.c: Likewise.
* gcc.c-torture/execute/
20000605-1.c: Likewise.
* gcc.c-torture/execute/
20000605-2.c: Likewise.
* gcc.c-torture/execute/
20000605-3.c: Likewise.
* gcc.c-torture/execute/
20000622-1.c: Likewise.
* gcc.c-torture/execute/
20000717-1.c: Likewise.
* gcc.c-torture/execute/
20000717-2.c: Likewise.
* gcc.c-torture/execute/
20000717-5.c: Likewise.
* gcc.c-torture/execute/
20000722-1.c: Likewise.
* gcc.c-torture/execute/
20000726-1.c: Likewise.
* gcc.c-torture/execute/
20000731-1.c: Likewise.
* gcc.c-torture/execute/
20000731-2.c: Likewise.
* gcc.c-torture/execute/
20000801-3.c: Likewise.
* gcc.c-torture/execute/
20000801-4.c: Likewise.
* gcc.c-torture/execute/
20000808-1.c: Likewise.
* gcc.c-torture/execute/
20000815-1.c: Likewise.
* gcc.c-torture/execute/
20000818-1.c: Likewise.
* gcc.c-torture/execute/
20000819-1.c: Likewise.
* gcc.c-torture/execute/
20000822-1.c: Likewise.
* gcc.c-torture/execute/
20000914-1.c: Likewise.
* gcc.c-torture/execute/
20000917-1.c: Likewise.
* gcc.c-torture/execute/
20001009-1.c: Likewise.
* gcc.c-torture/execute/
20001009-2.c: Likewise.
* gcc.c-torture/execute/
20001013-1.c: Likewise.
* gcc.c-torture/execute/
20001017-1.c: Likewise.
* gcc.c-torture/execute/
20001017-2.c: Likewise.
* gcc.c-torture/execute/
20001024-1.c: Likewise.
* gcc.c-torture/execute/
20001027-1.c: Likewise.
* gcc.c-torture/execute/
20001101.c: Likewise.
* gcc.c-torture/execute/
20001108-1.c: Likewise.
* gcc.c-torture/execute/
20001112-1.c: Likewise.
* gcc.c-torture/execute/
20001124-1.c: Likewise.
* gcc.c-torture/execute/
20001130-1.c: Likewise.
* gcc.c-torture/execute/
20001130-2.c: Likewise.
* gcc.c-torture/execute/
20001203-2.c: Likewise.
* gcc.c-torture/execute/
20001221-1.c: Likewise.
* gcc.c-torture/execute/
20001228-1.c: Likewise.
* gcc.c-torture/execute/
20001229-1.c: Likewise.
* gcc.c-torture/execute/
20010106-1.c: Likewise.
* gcc.c-torture/execute/
20010118-1.c: Likewise.
* gcc.c-torture/execute/
20010119-1.c: Likewise.
* gcc.c-torture/execute/
20010206-1.c: Likewise.
* gcc.c-torture/execute/
20010209-1.c: Likewise.
* gcc.c-torture/execute/
20010221-1.c: Likewise.
* gcc.c-torture/execute/
20010222-1.c: Likewise.
* gcc.c-torture/execute/
20010329-1.c: Likewise.
* gcc.c-torture/execute/
20010403-1.c: Likewise.
* gcc.c-torture/execute/
20010409-1.c: Likewise.
* gcc.c-torture/execute/
20010422-1.c: Likewise.
* gcc.c-torture/execute/
20010518-1.c: Likewise.
* gcc.c-torture/execute/
20010518-2.c: Likewise.
* gcc.c-torture/execute/
20010520-1.c: Likewise.
* gcc.c-torture/execute/
20010604-1.c: Likewise.
* gcc.c-torture/execute/
20010711-1.c: Likewise.
* gcc.c-torture/execute/
20010723-1.c: Likewise.
* gcc.c-torture/execute/
20010904-1.c: Likewise.
* gcc.c-torture/execute/
20010904-2.c: Likewise.
* gcc.c-torture/execute/
20010915-1.c: Likewise.
* gcc.c-torture/execute/
20010924-1.c: Likewise.
* gcc.c-torture/execute/
20011024-1.c: Likewise.
* gcc.c-torture/execute/
20011109-1.c: Likewise.
* gcc.c-torture/execute/
20011109-2.c: Likewise.
* gcc.c-torture/execute/
20011114-1.c: Likewise.
* gcc.c-torture/execute/
20011121-1.c: Likewise.
* gcc.c-torture/execute/
20011126-1.c: Likewise.
* gcc.c-torture/execute/
20011128-1.c: Likewise.
* gcc.c-torture/execute/
20011217-1.c: Likewise.
* gcc.c-torture/execute/
20020213-1.c: Likewise.
* gcc.c-torture/execute/
20020215-1.c: Likewise.
* gcc.c-torture/execute/
20020225-2.c: Likewise.
* gcc.c-torture/execute/
20020226-1.c: Likewise.
* gcc.c-torture/execute/
20020227-1.c: Likewise.
* gcc.c-torture/execute/
20020307-1.c: Likewise.
* gcc.c-torture/execute/
20020328-1.c: Likewise.
* gcc.c-torture/execute/
20020404-1.c: Likewise.
* gcc.c-torture/execute/
20020406-1.c: Likewise.
* gcc.c-torture/execute/
20020413-1.c: Likewise.
* gcc.c-torture/execute/
20020418-1.c: Likewise.
* gcc.c-torture/execute/
20020508-1.c: Likewise.
* gcc.c-torture/execute/
20020508-2.c: Likewise.
* gcc.c-torture/execute/
20020508-3.c: Likewise.
* gcc.c-torture/execute/
20020529-1.c: Likewise.
* gcc.c-torture/execute/
20020611-1.c: Likewise.
* gcc.c-torture/execute/
20020615-1.c: Likewise.
* gcc.c-torture/execute/
20020619-1.c: Likewise.
* gcc.c-torture/execute/
20020904-1.c: Likewise.
* gcc.c-torture/execute/
20020916-1.c: Likewise.
* gcc.c-torture/execute/
20021010-1.c: Likewise.
* gcc.c-torture/execute/
20021113-1.c: Likewise.
* gcc.c-torture/execute/
20021118-1.c: Likewise.
* gcc.c-torture/execute/
20021118-2.c: Likewise.
* gcc.c-torture/execute/
20021120-1.c: Likewise.
* gcc.c-torture/execute/
20021120-2.c: Likewise.
* gcc.c-torture/execute/
20021120-3.c: Likewise.
* gcc.c-torture/execute/
20030105-1.c: Likewise.
* gcc.c-torture/execute/
20030109-1.c: Likewise.
* gcc.c-torture/execute/
20030117-1.c: Likewise.
* gcc.c-torture/execute/
20030120-1.c: Likewise.
* gcc.c-torture/execute/
20030125-1.c: Likewise.
* gcc.c-torture/execute/
20030128-1.c: Likewise.
* gcc.c-torture/execute/
20030209-1.c: Likewise.
* gcc.c-torture/execute/
20030222-1.c: Likewise.
* gcc.c-torture/execute/
20030316-1.c: Likewise.
* gcc.c-torture/execute/
20030403-1.c: Likewise.
* gcc.c-torture/execute/
20030404-1.c: Likewise.
* gcc.c-torture/execute/
20030501-1.c: Likewise.
* gcc.c-torture/execute/
20030606-1.c: Likewise.
* gcc.c-torture/execute/
20030828-1.c: Likewise.
* gcc.c-torture/execute/
20030828-2.c: Likewise.
* gcc.c-torture/execute/
20030903-1.c: Likewise.
* gcc.c-torture/execute/
20030910-1.c: Likewise.
* gcc.c-torture/execute/
20030913-1.c: Likewise.
* gcc.c-torture/execute/
20030914-1.c: Likewise.
* gcc.c-torture/execute/
20030914-2.c: Likewise.
* gcc.c-torture/execute/
20030916-1.c: Likewise.
* gcc.c-torture/execute/
20030928-1.c: Likewise.
* gcc.c-torture/execute/
20031010-1.c: Likewise.
* gcc.c-torture/execute/
20031201-1.c: Likewise.
* gcc.c-torture/execute/
20031204-1.c: Likewise.
* gcc.c-torture/execute/
20031211-1.c: Likewise.
* gcc.c-torture/execute/
20040208-1.c: Likewise.
* gcc.c-torture/execute/
20040218-1.c: Likewise.
* gcc.c-torture/execute/
20040307-1.c: Likewise.
* gcc.c-torture/execute/
20040319-1.c: Likewise.
* gcc.c-torture/execute/
20040411-1.c: Likewise.
* gcc.c-torture/execute/
20040423-1.c: Likewise.
* gcc.c-torture/execute/
20040625-1.c: Likewise.
* gcc.c-torture/execute/
20040703-1.c: Likewise.
* gcc.c-torture/execute/
20040706-1.c: Likewise.
* gcc.c-torture/execute/
20040707-1.c: Likewise.
* gcc.c-torture/execute/
20040805-1.c: Likewise.
* gcc.c-torture/execute/
20040917-1.c: Likewise.
* gcc.c-torture/execute/
20041011-1.c: Likewise.
* gcc.c-torture/execute/
20041113-1.c: Likewise.
* gcc.c-torture/execute/
20041124-1.c: Likewise.
* gcc.c-torture/execute/
20041210-1.c: Likewise.
* gcc.c-torture/execute/
20041212-1.c: Likewise.
* gcc.c-torture/execute/
20050410-1.c: Likewise.
* gcc.c-torture/execute/
20051113-1.c: Likewise.
* gcc.c-torture/execute/
20070623-1.c: Likewise.
* gcc.c-torture/execute/
20091229-1.c: Likewise.
* gcc.c-torture/execute/
20101025-1.c: Likewise.
* gcc.c-torture/execute/
20120817-1.c: Likewise.
* gcc.c-torture/execute/
20170401-2.c: Likewise.
* gcc.c-torture/execute/900409-1.c: Likewise.
* gcc.c-torture/execute/920202-1.c: Likewise.
* gcc.c-torture/execute/920302-1.c: Likewise.
* gcc.c-torture/execute/920410-1.c: Likewise.
* gcc.c-torture/execute/920501-2.c: Likewise.
* gcc.c-torture/execute/920501-3.c: Likewise.
* gcc.c-torture/execute/920501-4.c: Likewise.
* gcc.c-torture/execute/920501-5.c: Likewise.
* gcc.c-torture/execute/920501-6.c: Likewise.
* gcc.c-torture/execute/920501-8.c: Likewise.
* gcc.c-torture/execute/920506-1.c: Likewise.
* gcc.c-torture/execute/920604-1.c: Likewise.
* gcc.c-torture/execute/920612-2.c: Likewise.
* gcc.c-torture/execute/920618-1.c: Likewise.
* gcc.c-torture/execute/920625-1.c: Likewise.
* gcc.c-torture/execute/920710-1.c: Likewise.
* gcc.c-torture/execute/920721-1.c: Likewise.
* gcc.c-torture/execute/920721-4.c: Likewise.
* gcc.c-torture/execute/920726-1.c: Likewise.
* gcc.c-torture/execute/920829-1.c: Likewise.
* gcc.c-torture/execute/920908-1.c: Likewise.
* gcc.c-torture/execute/920922-1.c: Likewise.
* gcc.c-torture/execute/920929-1.c: Likewise.
* gcc.c-torture/execute/921006-1.c: Likewise.
* gcc.c-torture/execute/921007-1.c: Likewise.
* gcc.c-torture/execute/921016-1.c: Likewise.
* gcc.c-torture/execute/921019-1.c: Likewise.
* gcc.c-torture/execute/921019-2.c: Likewise.
* gcc.c-torture/execute/921029-1.c: Likewise.
* gcc.c-torture/execute/921104-1.c: Likewise.
* gcc.c-torture/execute/921112-1.c: Likewise.
* gcc.c-torture/execute/921113-1.c: Likewise.
* gcc.c-torture/execute/921117-1.c: Likewise.
* gcc.c-torture/execute/921123-2.c: Likewise.
* gcc.c-torture/execute/921202-2.c: Likewise.
* gcc.c-torture/execute/921204-1.c: Likewise.
* gcc.c-torture/execute/921208-1.c: Likewise.
* gcc.c-torture/execute/930123-1.c: Likewise.
* gcc.c-torture/execute/930126-1.c: Likewise.
* gcc.c-torture/execute/930406-1.c: Likewise.
* gcc.c-torture/execute/930408-1.c: Likewise.
* gcc.c-torture/execute/930429-1.c: Likewise.
* gcc.c-torture/execute/930603-2.c: Likewise.
* gcc.c-torture/execute/930608-1.c: Likewise.
* gcc.c-torture/execute/930614-1.c: Likewise.
* gcc.c-torture/execute/930614-2.c: Likewise.
* gcc.c-torture/execute/930622-2.c: Likewise.
* gcc.c-torture/execute/930628-1.c: Likewise.
* gcc.c-torture/execute/930725-1.c: Likewise.
* gcc.c-torture/execute/930930-2.c: Likewise.
* gcc.c-torture/execute/931002-1.c: Likewise.
* gcc.c-torture/execute/931004-1.c: Likewise.
* gcc.c-torture/execute/931004-10.c: Likewise.
* gcc.c-torture/execute/931004-11.c: Likewise.
* gcc.c-torture/execute/931004-12.c: Likewise.
* gcc.c-torture/execute/931004-13.c: Likewise.
* gcc.c-torture/execute/931004-14.c: Likewise.
* gcc.c-torture/execute/931004-2.c: Likewise.
* gcc.c-torture/execute/931004-3.c: Likewise.
* gcc.c-torture/execute/931004-4.c: Likewise.
* gcc.c-torture/execute/931004-5.c: Likewise.
* gcc.c-torture/execute/931004-6.c: Likewise.
* gcc.c-torture/execute/931004-7.c: Likewise.
* gcc.c-torture/execute/931004-8.c: Likewise.
* gcc.c-torture/execute/931004-9.c: Likewise.
* gcc.c-torture/execute/931005-1.c: Likewise.
* gcc.c-torture/execute/931110-1.c: Likewise.
* gcc.c-torture/execute/931110-2.c: Likewise.
* gcc.c-torture/execute/941014-1.c: Likewise.
* gcc.c-torture/execute/941015-1.c: Likewise.
* gcc.c-torture/execute/941021-1.c: Likewise.
* gcc.c-torture/execute/941025-1.c: Likewise.
* gcc.c-torture/execute/941031-1.c: Likewise.
* gcc.c-torture/execute/950221-1.c: Likewise.
* gcc.c-torture/execute/950426-2.c: Likewise.
* gcc.c-torture/execute/950503-1.c: Likewise.
* gcc.c-torture/execute/950511-1.c: Likewise.
* gcc.c-torture/execute/950607-1.c: Likewise.
* gcc.c-torture/execute/950607-2.c: Likewise.
* gcc.c-torture/execute/950612-1.c: Likewise.
* gcc.c-torture/execute/950628-1.c: Likewise.
* gcc.c-torture/execute/950704-1.c: Likewise.
* gcc.c-torture/execute/950706-1.c: Likewise.
* gcc.c-torture/execute/950710-1.c: Likewise.
* gcc.c-torture/execute/950714-1.c: Likewise.
* gcc.c-torture/execute/950809-1.c: Likewise.
* gcc.c-torture/execute/950906-1.c: Likewise.
* gcc.c-torture/execute/950915-1.c: Likewise.
* gcc.c-torture/execute/950929-1.c: Likewise.
* gcc.c-torture/execute/951003-1.c: Likewise.
* gcc.c-torture/execute/951115-1.c: Likewise.
* gcc.c-torture/execute/951204-1.c: Likewise.
* gcc.c-torture/execute/960116-1.c: Likewise.
* gcc.c-torture/execute/960117-1.c: Likewise.
* gcc.c-torture/execute/960209-1.c: Likewise.
* gcc.c-torture/execute/960215-1.c: Likewise.
* gcc.c-torture/execute/960219-1.c: Likewise.
* gcc.c-torture/execute/960301-1.c: Likewise.
* gcc.c-torture/execute/960302-1.c: Likewise.
* gcc.c-torture/execute/960311-1.c: Likewise.
* gcc.c-torture/execute/960311-2.c: Likewise.
* gcc.c-torture/execute/960311-3.c: Likewise.
* gcc.c-torture/execute/960312-1.c: Likewise.
* gcc.c-torture/execute/960317-1.c: Likewise.
* gcc.c-torture/execute/960321-1.c: Likewise.
* gcc.c-torture/execute/960326-1.c: Likewise.
* gcc.c-torture/execute/960327-1.c: Likewise.
* gcc.c-torture/execute/960405-1.c: Likewise.
* gcc.c-torture/execute/960416-1.c: Likewise.
* gcc.c-torture/execute/960419-1.c: Likewise.
* gcc.c-torture/execute/960419-2.c: Likewise.
* gcc.c-torture/execute/960512-1.c: Likewise.
* gcc.c-torture/execute/960513-1.c: Likewise.
* gcc.c-torture/execute/960608-1.c: Likewise.
* gcc.c-torture/execute/960801-1.c: Likewise.
* gcc.c-torture/execute/960802-1.c: Likewise.
* gcc.c-torture/execute/960909-1.c: Likewise.
* gcc.c-torture/execute/961004-1.c: Likewise.
* gcc.c-torture/execute/961017-1.c: Likewise.
* gcc.c-torture/execute/961017-2.c: Likewise.
* gcc.c-torture/execute/961026-1.c: Likewise.
* gcc.c-torture/execute/961122-1.c: Likewise.
* gcc.c-torture/execute/961122-2.c: Likewise.
* gcc.c-torture/execute/961125-1.c: Likewise.
* gcc.c-torture/execute/961206-1.c: Likewise.
* gcc.c-torture/execute/961213-1.c: Likewise.
* gcc.c-torture/execute/970214-1.c: Likewise.
* gcc.c-torture/execute/970214-2.c: Likewise.
* gcc.c-torture/execute/970217-1.c: Likewise.
* gcc.c-torture/execute/970923-1.c: Likewise.
* gcc.c-torture/execute/980205.c: Likewise.
* gcc.c-torture/execute/980223.c: Likewise.
* gcc.c-torture/execute/980424-1.c: Likewise.
* gcc.c-torture/execute/980505-1.c: Likewise.
* gcc.c-torture/execute/980505-2.c: Likewise.
* gcc.c-torture/execute/980506-1.c: Likewise.
* gcc.c-torture/execute/980506-2.c: Likewise.
* gcc.c-torture/execute/980506-3.c: Likewise.
* gcc.c-torture/execute/980526-1.c: Likewise.
* gcc.c-torture/execute/980526-2.c: Likewise.
* gcc.c-torture/execute/980526-3.c: Likewise.
* gcc.c-torture/execute/980602-1.c: Likewise.
* gcc.c-torture/execute/980602-2.c: Likewise.
* gcc.c-torture/execute/980604-1.c: Likewise.
* gcc.c-torture/execute/980605-1.c: Likewise.
* gcc.c-torture/execute/980612-1.c: Likewise.
* gcc.c-torture/execute/980617-1.c: Likewise.
* gcc.c-torture/execute/980618-1.c: Likewise.
* gcc.c-torture/execute/980701-1.c: Likewise.
* gcc.c-torture/execute/980709-1.c: Likewise.
* gcc.c-torture/execute/980716-1.c: Likewise.
* gcc.c-torture/execute/980929-1.c: Likewise.
* gcc.c-torture/execute/981001-1.c: Likewise.
* gcc.c-torture/execute/981019-1.c: Likewise.
* gcc.c-torture/execute/981130-1.c: Likewise.
* gcc.c-torture/execute/981206-1.c: Likewise.
* gcc.c-torture/execute/990106-2.c: Likewise.
* gcc.c-torture/execute/990117-1.c: Likewise.
* gcc.c-torture/execute/990128-1.c: Likewise.
* gcc.c-torture/execute/990130-1.c: Likewise.
* gcc.c-torture/execute/990208-1.c: Likewise.
* gcc.c-torture/execute/990222-1.c: Likewise.
* gcc.c-torture/execute/990324-1.c: Likewise.
* gcc.c-torture/execute/990326-1.c: Likewise.
* gcc.c-torture/execute/990404-1.c: Likewise.
* gcc.c-torture/execute/990513-1.c: Likewise.
* gcc.c-torture/execute/990524-1.c: Likewise.
* gcc.c-torture/execute/990525-1.c: Likewise.
* gcc.c-torture/execute/990525-2.c: Likewise.
* gcc.c-torture/execute/990527-1.c: Likewise.
* gcc.c-torture/execute/990531-1.c: Likewise.
* gcc.c-torture/execute/990604-1.c: Likewise.
* gcc.c-torture/execute/990804-1.c: Likewise.
* gcc.c-torture/execute/990811-1.c: Likewise.
* gcc.c-torture/execute/990826-0.c: Likewise.
* gcc.c-torture/execute/990827-1.c: Likewise.
* gcc.c-torture/execute/990829-1.c: Likewise.
* gcc.c-torture/execute/990923-1.c: Likewise.
* gcc.c-torture/execute/991014-1.c: Likewise.
* gcc.c-torture/execute/991016-1.c: Likewise.
* gcc.c-torture/execute/991019-1.c: Likewise.
* gcc.c-torture/execute/991023-1.c: Likewise.
* gcc.c-torture/execute/991030-1.c: Likewise.
* gcc.c-torture/execute/991112-1.c: Likewise.
* gcc.c-torture/execute/991118-1.c: Likewise.
* gcc.c-torture/execute/991201-1.c: Likewise.
* gcc.c-torture/execute/991202-1.c: Likewise.
* gcc.c-torture/execute/991202-2.c: Likewise.
* gcc.c-torture/execute/991202-3.c: Likewise.
* gcc.c-torture/execute/991216-1.c: Likewise.
* gcc.c-torture/execute/991216-2.c: Likewise.
* gcc.c-torture/execute/991216-4.c: Likewise.
* gcc.c-torture/execute/991221-1.c: Likewise.
* gcc.c-torture/execute/991227-1.c: Likewise.
* gcc.c-torture/execute/991228-1.c: Likewise.
* gcc.c-torture/execute/align-1.c: Likewise.
* gcc.c-torture/execute/align-2.c: Likewise.
* gcc.c-torture/execute/align-3.c: Likewise.
* gcc.c-torture/execute/alloca-1.c: Likewise.
* gcc.c-torture/execute/anon-1.c: Likewise.
* gcc.c-torture/execute/arith-1.c: Likewise.
* gcc.c-torture/execute/arith-rand-ll.c: Likewise.
* gcc.c-torture/execute/arith-rand.c: Likewise.
* gcc.c-torture/execute/bf-layout-1.c: Likewise.
* gcc.c-torture/execute/bf-pack-1.c: Likewise.
* gcc.c-torture/execute/bf-sign-1.c: Likewise.
* gcc.c-torture/execute/bf-sign-2.c: Likewise.
* gcc.c-torture/execute/bf64-1.c: Likewise.
* gcc.c-torture/execute/builtin-constant.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-1.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-2.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-3.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-4.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-5.c: Likewise.
* gcc.c-torture/execute/builtin-prefetch-6.c: Likewise.
* gcc.c-torture/execute/builtin-types-compatible-p.c: Likewise.
* gcc.c-torture/execute/cbrt.c: Likewise.
* gcc.c-torture/execute/complex-1.c: Likewise.
* gcc.c-torture/execute/complex-2.c: Likewise.
* gcc.c-torture/execute/complex-3.c: Likewise.
* gcc.c-torture/execute/complex-4.c: Likewise.
* gcc.c-torture/execute/complex-5.c: Likewise.
* gcc.c-torture/execute/compndlit-1.c: Likewise.
* gcc.c-torture/execute/conversion.c: Likewise.
* gcc.c-torture/execute/cvt-1.c: Likewise.
* gcc.c-torture/execute/divconst-1.c: Likewise.
* gcc.c-torture/execute/divconst-2.c: Likewise.
* gcc.c-torture/execute/divconst-3.c: Likewise.
* gcc.c-torture/execute/enum-1.c: Likewise.
* gcc.c-torture/execute/enum-2.c: Likewise.
* gcc.c-torture/execute/extzvsi.c: Likewise.
* gcc.c-torture/execute/frame-address.c: Likewise.
* gcc.c-torture/execute/func-ptr-1.c: Likewise.
* gcc.c-torture/execute/gofast.c: Likewise.
* gcc.c-torture/execute/ieee/
20000320-1.c: Likewise.
* gcc.c-torture/execute/ieee/
20001122-1.c: Likewise.
* gcc.c-torture/execute/ieee/
20010226-1.c: Likewise.
* gcc.c-torture/execute/ieee/
20011123-1.c: Likewise.
* gcc.c-torture/execute/ieee/920518-1.c: Likewise.
* gcc.c-torture/execute/ieee/920810-1.c: Likewise.
* gcc.c-torture/execute/ieee/930529-1.c: Likewise.
* gcc.c-torture/execute/ieee/980619-1.c: Likewise.
* gcc.c-torture/execute/ieee/acc1.c: Likewise.
* gcc.c-torture/execute/ieee/acc2.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-1.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-2.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-3.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-4.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-5.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-6.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-8.c: Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-9.c: Likewise.
* gcc.c-torture/execute/ieee/hugeval.c: Likewise.
* gcc.c-torture/execute/ieee/minuszero.c: Likewise.
* gcc.c-torture/execute/ieee/mul-subnormal-single-1.c: Likewise.
* gcc.c-torture/execute/ieee/mzero2.c: Likewise.
* gcc.c-torture/execute/ieee/mzero3.c: Likewise.
* gcc.c-torture/execute/ieee/mzero5.c: Likewise.
* gcc.c-torture/execute/ieee/mzero6.c: Likewise.
* gcc.c-torture/execute/ieee/pr28634.c: Likewise.
* gcc.c-torture/execute/ieee/rbug.c: Likewise.
* gcc.c-torture/execute/index-1.c: Likewise.
* gcc.c-torture/execute/longlong.c: Likewise.
* gcc.c-torture/execute/loop-1.c: Likewise.
* gcc.c-torture/execute/loop-10.c: Likewise.
* gcc.c-torture/execute/loop-11.c: Likewise.
* gcc.c-torture/execute/loop-13.c: Likewise.
* gcc.c-torture/execute/loop-14.c: Likewise.
* gcc.c-torture/execute/loop-15.c: Likewise.
* gcc.c-torture/execute/loop-2b.c: Likewise.
* gcc.c-torture/execute/loop-2e.c: Likewise.
* gcc.c-torture/execute/loop-4.c: Likewise.
* gcc.c-torture/execute/loop-4b.c: Likewise.
* gcc.c-torture/execute/loop-5.c: Likewise.
* gcc.c-torture/execute/loop-6.c: Likewise.
* gcc.c-torture/execute/loop-7.c: Likewise.
* gcc.c-torture/execute/loop-8.c: Likewise.
* gcc.c-torture/execute/memcpy-1.c: Likewise.
* gcc.c-torture/execute/memcpy-2.c: Likewise.
* gcc.c-torture/execute/memcpy-bi.c: Likewise.
* gcc.c-torture/execute/memset-1.c: Likewise.
* gcc.c-torture/execute/memset-2.c: Likewise.
* gcc.c-torture/execute/memset-3.c: Likewise.
* gcc.c-torture/execute/multdi-1.c: Likewise.
* gcc.c-torture/execute/multi-ix.c: Likewise.
* gcc.c-torture/execute/nest-stdar-1.c: Likewise.
* gcc.c-torture/execute/nestfunc-1.c: Likewise.
* gcc.c-torture/execute/nestfunc-2.c: Likewise.
* gcc.c-torture/execute/nestfunc-3.c: Likewise.
* gcc.c-torture/execute/nestfunc-4.c: Likewise.
* gcc.c-torture/execute/packed-1.c: Likewise.
* gcc.c-torture/execute/pending-4.c: Likewise.
* gcc.c-torture/execute/pr15262-1.c: Likewise.
* gcc.c-torture/execute/pr15262-2.c: Likewise.
* gcc.c-torture/execute/pr15262.c: Likewise.
* gcc.c-torture/execute/pr15296.c: Likewise.
* gcc.c-torture/execute/pr17252.c: Likewise.
* gcc.c-torture/execute/pr17377.c: Likewise.
* gcc.c-torture/execute/pr19606.c: Likewise.
* gcc.c-torture/execute/pr21964-1.c: Likewise.
* gcc.c-torture/execute/pr22061-2.c: Likewise.
* gcc.c-torture/execute/pr22061-3.c: Likewise.
* gcc.c-torture/execute/pr22061-4.c: Likewise.
* gcc.c-torture/execute/pr23467.c: Likewise.
* gcc.c-torture/execute/pr27073.c: Likewise.
* gcc.c-torture/execute/pr27364.c: Likewise.
* gcc.c-torture/execute/pr28403.c: Likewise.
* gcc.c-torture/execute/pr31605.c: Likewise.
* gcc.c-torture/execute/pr38969.c: Likewise.
* gcc.c-torture/execute/pr40657.c: Likewise.
* gcc.c-torture/execute/pr44575.c: Likewise.
* gcc.c-torture/execute/pr56799.c: Likewise.
* gcc.c-torture/execute/pr58640.c: Likewise.
* gcc.c-torture/execute/pr71335.c: Likewise.
* gcc.c-torture/execute/ptr-arith-1.c: Likewise.
* gcc.c-torture/execute/regstack-1.c: Likewise.
* gcc.c-torture/execute/scope-1.c: Likewise.
* gcc.c-torture/execute/simd-1.c: Likewise.
* gcc.c-torture/execute/simd-2.c: Likewise.
* gcc.c-torture/execute/simd-4.c: Likewise.
* gcc.c-torture/execute/simd-5.c: Likewise.
* gcc.c-torture/execute/strcmp-1.c: Likewise.
* gcc.c-torture/execute/strcpy-1.c: Likewise.
* gcc.c-torture/execute/strct-pack-1.c: Likewise.
* gcc.c-torture/execute/strct-pack-2.c: Likewise.
* gcc.c-torture/execute/strct-pack-4.c: Likewise.
* gcc.c-torture/execute/strct-stdarg-1.c: Likewise.
* gcc.c-torture/execute/strct-varg-1.c: Likewise.
* gcc.c-torture/execute/strlen-1.c: Likewise.
* gcc.c-torture/execute/strncmp-1.c: Likewise.
* gcc.c-torture/execute/struct-ini-1.c: Likewise.
* gcc.c-torture/execute/struct-ini-2.c: Likewise.
* gcc.c-torture/execute/struct-ini-3.c: Likewise.
* gcc.c-torture/execute/struct-ini-4.c: Likewise.
* gcc.c-torture/execute/struct-ret-1.c: Likewise.
* gcc.c-torture/execute/struct-ret-2.c: Likewise.
* gcc.c-torture/execute/usmul.c: Likewise.
* gcc.c-torture/execute/va-arg-1.c: Likewise.
* gcc.c-torture/execute/va-arg-10.c: Likewise.
* gcc.c-torture/execute/va-arg-11.c: Likewise.
* gcc.c-torture/execute/va-arg-12.c: Likewise.
* gcc.c-torture/execute/va-arg-13.c: Likewise.
* gcc.c-torture/execute/va-arg-14.c: Likewise.
* gcc.c-torture/execute/va-arg-15.c: Likewise.
* gcc.c-torture/execute/va-arg-16.c: Likewise.
* gcc.c-torture/execute/va-arg-17.c: Likewise.
* gcc.c-torture/execute/va-arg-18.c: Likewise.
* gcc.c-torture/execute/va-arg-19.c: Likewise.
* gcc.c-torture/execute/va-arg-2.c: Likewise.
* gcc.c-torture/execute/va-arg-20.c: Likewise.
* gcc.c-torture/execute/va-arg-23.c: Likewise.
* gcc.c-torture/execute/va-arg-26.c: Likewise.
* gcc.c-torture/execute/va-arg-4.c: Likewise.
* gcc.c-torture/execute/va-arg-5.c: Likewise.
* gcc.c-torture/execute/va-arg-6.c: Likewise.
* gcc.c-torture/execute/va-arg-9.c: Likewise.
* gcc.c-torture/execute/widechar-1.c: Likewise.
* gcc.c-torture/execute/widechar-2.c: Likewise.
#include <string.h>
+void abort (void);
+void exit (int);
+
static int
special_format (fmt)
const char *fmt;
+void abort (void);
+void exit (int);
+
struct x {
unsigned x1:1;
unsigned x2:2;
+void abort (void);
+void exit (int);
+
static int f (int a)
{
if (a == 0)
+void abort(void);
+void exit(int);
+
unsigned short int showbug(unsigned short int *a, unsigned short int *b)
{
*a += *b -8;
eg, sizeof(long double) might be 12, but that means it must be alignable
on a 4 byte boundary. */
+void abort (void);
+
void check (char const *type, int align)
{
if ((align & -align) != align)
+void abort (void);
+void exit (int);
+
int loop_1 = 100;
int loop_2 = 7;
int flag = 0;
+void abort (void);
+void exit (int);
+
int main ()
{
int nResult;
+void abort(void);
+
static const unsigned char f[] = "\0\377";
static const unsigned char g[] = "\0ÿ";
+void abort (void);
+
unsigned int buggy (unsigned int *param)
{
unsigned int accu, zero = 0, borrow;
+void abort (void);
+void exit (int);
+
int main ()
{
long winds = 0;
+void abort(void);
+void exit(int);
+
typedef unsigned long long uint64;
const uint64 bigconst = 1ULL << 34;
extern void abort (void);
+extern void exit (int);
static char arg0[] = "arg0";
static char arg1[] = "arg1";
+void abort(void);
+void exit(int);
+
#include <limits.h>
#if ULONG_LONG_MAX != 18446744073709551615ull && ULONG_MAX != 18446744073709551615ull
+void abort (void);
+void exit (int);
+
extern unsigned long aa[], bb[];
int seqgt (unsigned long a, unsigned short win, unsigned long b);
+void abort(void);
+void exit(int);
+
short int i = -1;
const char * const wordlist[207];
+void abort (void);
+void exit (int);
+
int f(int a,int *y)
{
int x = a;
+ void abort (void);
+ void exit (int);
+
void f(int i, int j, int radius, int width, int N)
{
const int diff = i-radius;
+void abort (void);
+void exit (int);
+
int main( void ) {
struct {
int node;
+void abort (void);
+void exit (int);
+
unsigned bug (unsigned short value, unsigned short *buffer,
unsigned short *bufend);
+void abort (void);
+void exit (int);
+
struct foo { int a, b, c; };
void
+void abort (void);
+void exit (int);
+
int ops[13] =
{
11, 12, 46, 3, 2, 2, 3, 2, 1, 3, 2, 1, 2
+void abort (void);
+void exit (int);
+
unsigned long
sub (int a)
{
+void abort (void);
+void exit (int);
+
void f (int value, int expect)
{
if (value != expect)
+void abort (void);
+
#include <stdarg.h>
int
+void abort (void);
+void exit (int);
+
long x = -1L;
int main()
+void abort (void);
+void exit (int);
+
int
main (void)
{
/* Copyright (C) 2000 Free Software Foundation */
/* Contributed by Alexandre Oliva <aoliva@cygnus.com> */
+void abort (void);
+void exit (int);
+
unsigned long l = (unsigned long)-2;
unsigned short s;
http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_236.htm. However,
there seems to be consensus that the presence of a union to aggregate
struct s1 and struct s2 should make it conforming. */
+void abort(void);
+
struct s1 { double d; };
struct s2 { double d; };
union u { struct s1 x; struct s2 y; };
+void abort (void);
+void exit (int);
+
typedef struct _RenderInfo RenderInfo;
struct _RenderInfo
{
+void abort (void);
+void exit (int);
+
struct F { int i; };
void f1(struct F *x, struct F *y)
+void abort (void);
+
struct F { int x; int y; };
int main()
+void abort(void);
+void exit(int);
+
long foo(long a, long b, long c)
{
if (a != 12 || b != 1 || c != 11)
+void abort (void);
+void exit (int);
+
typedef struct trio { int a, b, c; } trio;
int
+void abort (void);
+void exit (int);
+
static void
compare (long long foo)
{
+void abort (void);
+void exit (int);
+
typedef struct trio { int a, b, c; } trio;
int
+void abort (void);
+void exit (int);
+
struct s { char *p; int t; };
extern void bar (void);
+void abort (void);
+void exit (int);
+
void adjust_xy (short *, short *);
struct adjust_template
+void abort (void);
+void exit (int);
+
double
foo (void)
{
+void abort (void);
+void exit (int);
+
int
main()
{
to a testcase by Joseph Myers <jsm28@cam.ac.uk>.
*/
+void abort (void);
+void exit (int);
+
typedef struct { } empty;
typedef struct {
standard, but was fixed in TC2 and C99; see DRs #060, #092.
*/
extern void abort (void);
+extern void exit (int);
int
foo (void)
+void abort (void);
+void exit (int);
+
typedef struct {
long int p_x, p_y;
} Point;
+void abort(void);
+
struct table_elt
{
void *exp;
by Manfred Hollstein <manfredh@redhat.com> */
+void abort (void);
+void exit (int);
+
void *temporary_obstack;
static int input (void);
+void abort (void);
+void exit (int);
+
int a[2] = { 2, 0 };
void foo(int *sp, int cnt)
/* { dg-require-effective-target trampolines } */
+void abort (void);
+
int f0(int (*fn)(int *), int *p)
{
return (*fn) (p);
+extern void abort (void);
+extern void exit (int);
extern void *malloc(__SIZE_TYPE__);
enum tree_code {
/* This bug exists in gcc-2.95, egcs-1.1.2, gcc-2.7.2 and probably
every other version as well. */
+void abort (void);
+void exit (int);
+
typedef struct int3 { int a, b, c; } int3;
int3
+void abort(void);
int a,b;
main()
{
+void abort(void);
int b=1;
int foo()
{
+void abort (void);
+void exit (int);
+
struct x {
int a, b;
} z = { -4028, 4096 };
+void abort (void);
void bug (double *Cref, char transb, int m, int n, int k,
double a, double *A, int fdA, double *B, int fdB,
+void abort (void);
+
void
fn_4parms (unsigned char a, long *b, long *c, unsigned int *d)
{
+void abort (void);
+void exit (int);
+
struct a;
extern int baz (struct a *__restrict x);
+void abort (void);
+void exit (int);
+
int x,*p=&x;
int main()
/* { dg-require-effective-target untyped_assembly } */
extern void abort(void);
+extern void exit(int);
typedef struct
{
+void abort (void);
+void exit (int);
+
long long
signed_poly (long long sum, long x)
{
+void abort (void);
+void exit (int);
+
int main ()
{
long long i = 1;
+void abort(void);
+void exit(int);
struct inode {
long long i_size;
+void abort(void);
static inline int bar(void) { return 1; }
static int mem[3];
+void abort (void);
+void exit (int);
+
static int which_alternative = 3;
static const char *i960_output_ldconst (void);
+void abort (void);
+void exit (int);
+
struct obstack
{
long chunk_size;
+void abort (void);
+void exit (int);
+
int main ()
{
unsigned long long a;
+void abort (void);
+void exit (int);
+
int foo1(void)
{
union {
So: If we know how, ask the kernel to deliver SIGBUS instead so
that the test case visibly fails. */
-
+
+void abort (void);
+void exit (int);
+
#if defined(__alpha__) && defined(__linux__)
#include <asm/sysinfo.h>
#include <asm/unistd.h>
/* Copyright 2001 Free Software Foundation
Contributed by Alexandre Oliva <aoliva@redhat.com> */
+void abort (void);
+void exit (int);
+
int f(int i) {
switch (i)
{
+void abort (void);
+void exit (int);
+
typedef struct {
int a, b, c, d, e, f;
} A;
+void exit (int);
+
#ifdef __OPTIMIZE__
extern void undef (void);
+void abort (void);
+void exit (int);
+
int foo (void)
{
int i;
/* { dg-require-effective-target alloca } */
+void abort (void);
+void exit (int);
+
int b;
int foo (void)
{
+void abort (void);
+void exit (int);
int n = 2;
+void abort (void);
+void exit (int);
+
int a[2] = { 18, 6 };
int main ()
#include <limits.h>
+void abort (void);
+void exit (int);
+
int main (void)
{
void *x = ((void *)((unsigned int)INT_MAX + 2));
+void abort (void);
+void exit (int);
+
void b (int *);
void c (int, int);
void d (int);
+void abort (void);
+void exit (int);
+
typedef __SIZE_TYPE__ size_t;
extern size_t strlen (const char *s);
+void abort (void);
+void exit (int);
+
unsigned int foo(unsigned int x)
{
if (x < 5)
/* Leaf functions with many arguments. */
+void abort (void);
+void exit (int);
+
int
add (int a,
int b,
/* Mis-aligned packed structures. */
+void abort (void);
+void exit (int);
+
typedef struct
{
char b0;
+void abort (void);
+void exit (int);
+
static unsigned int expr_hash_table_size = 1;
int
#include <stdbool.h>
+void abort (void);
+void exit (int);
+
int f (int a, int b, int c, _Bool d, _Bool e, _Bool f, char g)
{
if (g != 1 || d != true || e != true || f != true) abort ();
+void abort (void);
+void exit (int);
+
void foo (int *a) {}
int main ()
+void abort (void);
+void exit (int);
+
int
test ()
{
#define alignment 32
#endif
+void abort (void);
+void exit (int);
+
typedef struct x { int a; int b; } __attribute__((aligned(alignment))) X;
typedef struct y { X x[32]; int c; } Y;
#define alignment 32
#endif
+void abort (void);
+void exit (int);
+
typedef struct x { int a; int b; } __attribute__((aligned(alignment))) X;
typedef struct y { X x; X y[31]; int c; } Y;
/* Bug in reorg.c, deleting the "++" in the last loop in main.
Origin: <hp@axis.com>. */
+void abort (void);
+void exit (int);
+
extern void f (void);
extern int x (int, char **);
extern int r (const char *);
/* Verify that flexible arrays can be initialized from STRING_CST
constructors. */
+void abort(void);
+
/* Baselines. */
struct {
char a1c;
any memory. */
typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
extern void *memcpy (void *dest, const void *src, size_t n);
extern size_t strlen (const char *s);
extern int strcmp (const char *s1, const char *s2) __attribute__((pure));
+void abort (void);
+void exit (int);
+
void fail1(void)
{
abort ();
+void abort (void);
+void exit (int);
+
int main(void)
{
char *c1 = "foo";
+void abort (void);
+void exit (int);
+
char foo(char bar[])
{
return bar[1];
+void abort (void);
+void exit (int);
+
struct s
{
int i[18];
/* Produced a overflow in ifcvt.c, causing S to contain 0xffffffff7fffffff. */
+void abort (void);
+
int a = 1;
int main ()
+void exit (int);
+
main()
{
char blah[33] = "01234567890123456789";
+void abort (void);
+void exit (int);
+
int
main()
{
incorrectly assumed it is safe to first write into a.a2 b-1
and then read the original value from it. */
+void abort (void);
int bar (float);
struct A {
find_dummy_reload would return (reg:SI 1) for the subreg reload,
despite that not being a valid register. */
+void abort (void);
+void exit (int);
+
struct s
{
short i1;
+void abort (void);
+void exit (int);
+
static int
test(int x)
{
#include <limits.h>
+void abort (void);
+void exit (int);
+
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
to an unaligned mem:SC, gcc tried doing it by parts from a (concat:SC
(reg:SF 293) (reg:SF 294)). */
+void abort (void);
+void exit (int);
+
typedef __complex__ float cf;
struct x { char c; cf f; } __attribute__ ((__packed__));
extern void f2 (struct x*);
+void abort (void);
+void exit (int);
+
#define MASK(N) ((1UL << (N)) - 1)
#define BITS(N) ((1UL << ((N) - 1)) + 2)
+void abort (void);
+void exit (int);
+
int b = 0;
func () { }
/* { dg-skip-if "pointers can be truncated" { m32c-*-* } } */
/* Extracted from GDB sources. */
+void abort (void);
+void exit (int);
+
typedef long long bfd_signed_vma;
typedef bfd_signed_vma file_ptr;
// Origin: abbott@dima.unige.it
// PR c/5120
+extern void abort (void);
extern void * malloc (__SIZE_TYPE__);
extern void * calloc (__SIZE_TYPE__, __SIZE_TYPE__);
+void abort (void);
+void exit (int);
+
void test(long double val, int *eval)
{
long double tmp = 1.0l;
/* ifcvt accidentally deletes a referenced label while generating
conditional traps on machines having such patterns */
+void exit (int);
+
struct foo { int a; };
void gcc_crash(struct foo *p)
#include <limits.h>
+void abort (void);
+void exit (int);
+
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
#include <limits.h>
+void abort (void);
+void exit (int);
+
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
#include <limits.h>
+void abort (void);
+void exit (int);
+
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
Reported to nvidia 2016-05-18. */
/* { dg-skip-if "PTX assembler bug" { nvptx-*-* } { "-O0" } { "" } } */
+void abort (void);
+void exit (int);
+
struct xx
{
int a;
/* PR target/6997. Missing (set_attr "cc" "none") in sleu pattern in
cris.md. Testcase from hp@axis.com. */
+void abort (void);
+void exit (int);
+
int p;
int k;
unsigned int n;
epilogue delay-slot set the return-value register with the testcase
below. Derived from ghostscript-6.52 (GPL) by hp@axis.com. */
+void abort (void);
+void exit (int);
+
typedef struct font_hints_s {
int axes_swapped;
int x_inverted, y_inverted;
+void abort (void);
#if (__SIZEOF_INT__ == 4)
typedef int int32;
#elif (__SIZEOF_LONG__ == 4)
/* Verify that GCC zero-extends integer constants
in unsigned binary operations. */
+void abort (void);
+
typedef unsigned char u8;
u8 fun(u8 y)
/* Distilled from try_pre_increment in flow.c. If-conversion inserted
new instructions at the wrong place on ppc. */
+void abort(void);
+
int foo(int a)
{
int x;
#include <limits.h>
+void abort (void);
+void exit (int);
+
int
sub ()
{
/* This program tests a data flow bug that would cause constant propagation
to propagate constants through function calls. */
+void abort (void);
+void exit (int);
+
foo (int *p)
{
*p = 10;
+void abort (void);
+void exit (int);
+
struct s { int f[4]; };
int foo (struct s s, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
/* Originally added to test SH constant pool layout. t1() failed for
non-PIC and t2() failed for PIC. */
+void abort (void);
+void exit (int);
+
int t1 (float *f, int i,
void (*f1) (double),
void (*f2) (float, float))
+void abort (void);
+void exit (int);
+
/* Macros to emit "L Nxx R" for each octal number xx between 000 and 037. */
#define OP1(L, N, R, I, J) L N##I##J R
#define OP2(L, N, R, I) \
+void abort (void);
+void exit (int);
+
int g1, g2;
void foo (int x)
/* Test whether a partly call-clobbered register will be moved over a call.
Although the original test case didn't use any GNUisms, it proved
difficult to reduce without the named register extension. */
+
+void abort (void);
+void exit (int);
+
#if __SH64__ == 32
#define LOC asm ("r10")
#else
+void abort (void);
+void exit (int);
+
int __attribute__ ((noinline))
foo ()
{
/* Verify that an empty initializer inside a partial
parent initializer doesn't confuse GCC. */
+void abort (void);
+
struct X
{
int a;
+void abort (void);
+void exit (int);
+
int foo (int, int, int);
int bar (int, int, int);
/* On H8/300 port, NOTICE_UPDATE_CC had a bug that causes the final
pass to remove test insns that should be kept. */
+void abort (void);
+void exit (int);
+
unsigned short
test1 (unsigned short w)
{
/* Verify whether math functions are simplified. */
/* { dg-require-effective-target c99_runtime } */
/* { dg-require-weak "" } */
+void abort(void);
double sin(double);
double floor(double);
float
+void abort (void);
+void exit (int);
+
unsigned char x = 50;
volatile short y = -5;
/* { dg-require-stack-size "8*100*100" } */
+void abort (void);
+void exit (int);
+
double x[100][100];
int main ()
{
/* { dg-skip-if "asm requires register allocation" { nvptx-*-* } } */
#include <limits.h>
+void abort (void);
+void exit (int);
+
void
ll_to_int (long long x, volatile int *p)
{
/* PR target/9164 */
/* The comparison operand was sign extended erraneously. */
+void abort (void);
+
int
main (void)
{
#include <limits.h>
+void abort (void);
+
int
main ()
{
defined, CCP was not traversing the edges out of the if(), which caused
the PHI node for 'k' at the top of the while to only be visited once.
This ended up causing CCP to think that 'k' was the constant '1'. */
+void abort (void);
+
main()
{
int i, j, k;
+void abort (void);
+void exit (int);
+
int
main (int argc, char **argv)
{
+void abort (void);
+void exit (int);
int * foo (int *x, int b)
{
+void abort (void);
+void exit (int);
+
const int *p;
int bar (void)
+void abort (void);
+void exit (int);
+
struct rtx_def
{
int code;
the entire set of possibilities. Such an assumption is false for C,
but true for other languages. */
+void abort (void);
+
enum X { X1 = 1, X2, X3, X4 };
static volatile enum X test = 0;
static void y(int);
nodes. These need to be treated like a COMPONENT_REF so their address can
be taken. */
+void abort (void);
+void exit (int);
+
int main()
{
__complex double dc;
/* Assignments via pointers pointing to global variables were being killed
by SSA-DCE. Test contributed by Paul Brook <paul@nowt.org> */
+void abort (void);
+void exit (int);
+
int g;
void
stack, with an odd number of words in the register part. Check that
the long double stack argument (PC) is still accessed properly. */
+void abort (void);
+void exit (int);
+
struct s { int val[16]; };
long double f (int pa, struct s pb, long double pc)
one for the partial argument and one for the varargs save area.
Make sure that these uses don't conflict. */
+void abort (void);
+void exit (int);
+
struct s { int i[18]; };
int f (struct s pa, int pb, ...)
/* "i" overflows in f(). Check that x[i] is not treated as a giv. */
#include <limits.h>
+void abort (void);
+void exit (int);
+
#if CHAR_BIT == 8
void f (unsigned int *x)
#include <limits.h>
+void abort (void);
+void exit (int);
+
#if INT_MAX <= 32767
int main () { exit (0); }
#else
/* A reminder to process ops in generate_expr_as_of_bb exactly once. */
+void abort (void);
+
long __attribute__((noinline))
foo (long ct, long cf, _Bool p1, _Bool p2, _Bool p3)
{
STRICT_LOW_PART was handled incorrectly in delay slots.
Origin: Hans-Peter Nilsson. */
+void abort (void);
+void exit (int);
+
typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s1;
typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s2;
typedef struct { s1 i12; s2 i16; } io;
#include <string.h>
+void abort(void);
+
typedef unsigned long u32;
u32 in_aton(const char* x)
+void abort (void);
+void exit (int);
+
struct a { unsigned int bitfield : 1; };
unsigned int x;
+void abort (void);
+void exit (int);
+
int main ()
{
long double x;
postincrement.
Origin: <hp@axis.com>. */
+void abort (void);
+void exit (int);
+
long int xb (long int *y) __attribute__ ((__noinline__));
long int xw (long int *y) __attribute__ ((__noinline__));
short int yb (short int *y) __attribute__ ((__noinline__));
+void abort (void);
+
int main()
{
int b = 0;
+void abort (void);
+void exit (int);
+
int
blah (int zzz)
{
+void abort (void);
+
int
sub1 (int i, int j)
{
+void abort (void);
+
int
sub1 (int i, int j)
{
/* From PR target/16176 */
+void abort (void);
+void exit (int);
+
struct __attribute__ ((packed)) s { struct s *next; };
struct s * __attribute__ ((noinline))
/* PR 16341 */
/* { dg-require-effective-target int32plus } */
+void abort (void);
+void exit (int);
+
#define PART_PRECISION (sizeof (cpp_num_part) * 8)
typedef unsigned int cpp_num_part;
+void abort (void);
+void exit (int);
+
int main ()
{
int i;
+void exit (int);
+
struct s { char c1, c2; };
void foo (struct s s)
{
/* { dg-require-stack-size "0x12000" } */
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ < 32768
int main () { exit (0); }
#else
/* submitted by kenneth zadeck */
+void abort (void);
+
static int test_var;
/* the idea here is that not only is inlinable, inlinable but since it
+void abort (void);
+void exit (int);
+
typedef unsigned long long ull;
volatile int gvol[32];
ull gull;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
void test (int x, ...)
{
va_list ap;
+void abort (void);
+void exit (int);
+
struct s { _Complex unsigned short x; };
struct s gs = { 100 + 200i };
struct s __attribute__((noinline)) foo (void) { return gs; }
wrongly claimed to set the C and V flags. */
#include <limits.h>
+void abort (void);
+void exit (int);
+
int x[4] = { INT_MIN / 2, INT_MAX, 2, 4 };
int
/* A function pointer compared with a void pointer should not be canonicalized.
See PR middle-end/17564. */
+void abort (void);
+void exit (int);
+
void *f (void) __attribute__ ((__noinline__));
void *
f (void)
+void abort (void);
+void exit (int);
+
int s = 200;
int __attribute__((noinline))
foo (void)
+extern void abort(void);
extern void *malloc(__SIZE_TYPE__);
extern void *memset(void *, int, __SIZE_TYPE__);
typedef struct
#include <limits.h>
+void abort (void);
+void exit (int);
+
int __attribute__((noinline)) nge(int a, int b) {return -(a >= b);}
int __attribute__((noinline)) ngt(int a, int b) {return -(a > b);}
int __attribute__((noinline)) nle(int a, int b) {return -(a <= b);}
+void abort (void);
+void exit (int);
+
long long foo(long long v) { return v / -0x080000000LL; }
int main(int argc, char **argv) { if (foo(0x080000000LL) != -1) abort(); exit (0); }
+void abort (void);
+void exit (int);
+
static int g_7;
static int *volatile g_6 = &g_7;
int g_3;
+void abort (void);
+void exit (int);
+
typedef unsigned long long u64;
unsigned long foo = 0;
u64 f() __attribute__((noinline));
+void abort (void);
+void exit (int);
+
void adjust_xy (short *, short *);
struct adjust_template
+void abort (void);
+void exit (int);
+
long f1(long a){return a&0xff000000L;}
long f2 (long a){return a&~0xff000000L;}
long f3(long a){return a&0x000000ffL;}
+void exit (int);
+
static int rule_text_needs_stack_pop = 0;
static int input_stack_pos = 1;
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
short optab[5];
char buf[10];
execute (ip)
/* { dg-require-stack-size "40000 * 4 + 256" } */
+void exit (int);
+
main(){int d[40000];d[0]=0;exit(0);}
+void abort (void);
+void exit (int);
+
unsigned long
gcd_ll (unsigned long long x, unsigned long long y)
{
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
int tab[9];
execute(oip, ip)
unsigned short *oip, *ip;
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
int
x (int i)
{
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
x (int i)
{
void *j[] = {&&x, &&y, &&z};
#include <stdio.h>
+void abort (void);
+void exit (int);
+
/* Convert a decimal string to a long long unsigned. No error check is
performed. */
/* { dg-additional-options "-Wl,-u,_printf_float" { target newlib_nano_io } } */
+void abort (void);
+void exit (int);
+
#include <stdio.h>
#include <stdarg.h>
+void abort (void);
+void exit (int);
int l[]={0,1};
main(){int*p=l;switch(*p++){case 0:exit(0);case 1:break;case 2:break;case 3:case 4:break;}abort();}
+void exit (int);
+
long long
mod (a, b)
long long a, b;
/* { dg-require-effective-target trampolines } */
+void abort (void);
+void exit (int);
+
main ()
{
int i = 0;
+void abort (void);
+void exit (int);
main(){if(1.17549435e-38F<=1.1)exit(0);abort();}
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef struct{double x,y;}point;
point pts[]={{1.0,2.0},{3.0,4.0},{5.0,6.0},{7.0,8.0}};
static int va1(int nargs,...)
+void abort (void);
+void exit (int);
+
main()
{
if ((double) 18446744073709551615ULL < 1.84467440737095e+19 ||
+void abort (void);
+void exit (int);
long f(short a,short b){return (long)a/b;}
main(){if(f(-32768,-1)!=32768L)abort();else exit(0);}
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
int try (int num) {
__label__ lab1, lab2, lab3, lab4, lab5, lab6, default_lab;
#include <stdio.h>
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct spurious
{
int anumber;
+void abort (void);
+void exit (int);
long long c=2863311530LL,c3=2863311530LL*3;
main(){if(c*3!=c3)abort();exit(0);}
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef struct{int A;}T;
T f(int x,...)
+void abort (void);
+void exit (int);
+
unsigned long*
f(p)unsigned long*p;
{
/* { dg-skip-if "requires alloca" { ! alloca } { "-O0" } { "" } } */
/* REPRODUCED:RUN:SIGNAL MACHINE:sparc OPTIONS: */
+void exit (int);
f(int n)
{
int i;
/* REPRODUCED:RUN:SIGNAL MACHINE:i386 OPTIONS:-O */
+void abort(void);
+void exit(int);
main()
{
if(strcmp("X","")<0)abort();
+void abort(void);
+void exit(int);
static int strcmp(){return-1;}
#define strcmp __builtin_strcmp
main()
+void abort (void);
+void exit (int);
+
main()
{
int j=1081;
+void abort (void);
+void exit (int);
+
void *foo[]={(void *)&("X"[0])};
main ()
+void abort (void);
+void exit (int);
+
main()
{
double x,y=0.5;
+void abort (void);
+void exit (int);
+
typedef unsigned long long ULL;
ULL back;
ULL hpart, lpart;
+void abort (void);
+void exit (int);
+
main ()
{
unsigned long val = 1;
+void abort (void);
+void exit (int);
+
union u {
struct { int i1, i2; } t;
double d;
/* { dg-require-stack-size "128 * 128 * 4 + 1024" } */
+void abort (void);
+void exit (int);
+
typedef struct {
float wsx;
} struct_list;
+void abort (void);
+void exit (int);
+
struct s {
char text[11];
int flag;
+void abort (void);
+void exit (int);
+
typedef struct
{
unsigned short b0, b1, b2, b3;
+void abort (void);
+void exit (int);
+
int
f(long long x)
{
/* The bit-field below would have a problem if __INT_MAX__ is too
small. */
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ < 2147483647
int
main (void)
+void abort (void);
+void exit (int);
+
double
f(double x)
{
+void abort (void);
+void exit (int);
+
f(int *x)
{
*x = 0;
+void abort (void);
+void exit (int);
+
struct s {
unsigned long long a:8, b:32;
};
/* { dg-add-options stack_size } */
+void exit (int);
+
f()
{
int x = 1;
+void abort (void);
+void exit (int);
+
typedef enum foo E;
enum foo { e0, e1 };
+void abort (void);
+void exit (int);
+
char *
f (char *p)
{
+void abort (void);
+void exit (int);
+
int w[2][2];
f ()
+void abort (void);
+void exit (int);
+
double f (double a) {}
double (* const a[]) (double) = {&f};
+void abort (void);
+void exit (int);
+
f (double *ty)
{
*ty = -1.0;
+void abort (void);
+void exit (int);
+
main ()
{
int i, j, k, l;
+void abort (void);
+void exit (int);
+
long double
ll_to_ld (long long n)
{
+void abort (void);
+void exit (int);
+
f (double x[2], double y[2])
{
if (x == y)
+void abort (void);
+void exit (int);
+
int v;
char *
+void abort (void);
+void exit (int);
+
int
test_endianness()
{
/* { dg-require-effective-target trampolines } */
+void exit (int);
+
f (void (*func) ())
{
func ();
+void abort (void);
+void exit (int);
+
struct tiny
{
int c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
int c;
+void abort (void);
+void exit (int);
+
struct tiny
{
short c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
short c;
+void abort (void);
+void exit (int);
+
struct tiny
{
short c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
short c;
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
+void abort (void);
+void exit (int);
+
typedef struct
{
char x;
+void exit (int);
+
typedef struct
{
short f:3, g:3, h:10;
+void abort (void);
+void exit (int);
+
main ()
{
static int a[] = {3, 4};
+void abort (void);
+void exit (int);
+
int f (int a, int b) { }
main ()
+void abort (void);
+void exit (int);
+
int
foo1 (value)
long long value;
+void abort (void);
+void exit (int);
+
double glob_dbl;
f (pdbl, value)
+void abort (void);
+void exit (int);
+
long f (x, y)
long x,y;
{
+void abort (void);
+void exit (int);
+
typedef long mpt;
int
/* { dg-add-options stack_size } */
+void abort (void);
+void exit (int);
+
struct parsefile
{
long fd;
+void abort (void);
+void exit (int);
+
main()
{
long int i = -2147483647L - 1L; /* 0x80000000 */
+void abort (void);
+void exit (int);
+
main ()
{
int tmp;
+void abort (void);
+void exit (int);
+
main ()
{
unsigned long long xx;
+void abort (void);
+void exit (int);
+
main ()
{
struct { long status; } h;
+void abort (void);
+void exit (int);
+
typedef struct {
long int p_x, p_y;
} Point;
+void abort (void);
+void exit (int);
+
unsigned int
f1 (int diff)
{
+void abort (void);
+void exit (int);
+
typedef struct
{
char hours, day, month;
/* { dg-additional-options "-fwrapv" } */
+void abort (void);
+void exit (int);
+
int errflag;
long long
+void abort (void);
+void exit (int);
+
int
f (int n)
{
+void abort (void);
+void exit (int);
+
struct twelve
{
int a;
+void abort (void);
+void exit (int);
+
int array[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
main ()
+void abort (void);
+void exit (int);
+
struct S
{
int *sp, fc, *sc, a[2];
+void abort (void);
+void exit (int);
+
g (int i)
{
}
+void abort (void);
+void exit (int);
+
long int a = 100000;
long int b = 21475;
+void abort (void);
+void exit (int);
+
int f (char *p) { }
main ()
+void abort (void);
+void exit (int);
+
int f (i) { return 12; }
int g () { return 0; }
+void abort (void);
+void exit (int);
+
int var = 0;
g ()
+void abort (void);
+void exit (int);
+
f (char *x)
{
*x = 'x';
+void abort (void);
+void exit (int);
+
static inline
p (int *p)
{
+void exit (int);
+
static char id_space[2] [32 +1];
typedef short COUNT;
+void abort (void);
+void exit (int);
+
struct a_struct
{
unsigned char a_character;
+void abort (void);
+void exit (int);
+
long double C = 2;
long double U = 1;
long double Y2 = 3;
+void abort (void);
+void exit (int);
+
f (int i)
{
if (((1 << i) & 1) == 0)
+void abort (void);
+void exit (int);
+
struct foo {
unsigned : 12;
unsigned field : 4;
+void abort (void);
+void exit (int);
+
long a = 1;
foo ()
#include <stdio.h>
+void abort (void);
+void exit (int);
+
#ifdef DEBUG
#define abort() printf ("error, line %d\n", __LINE__)
#endif
#include <stdio.h>
+void abort (void);
+void exit (int);
+
#ifdef DEBUG
#define abort() printf ("error, line %d\n", __LINE__)
#endif
#include <stdio.h>
+void abort (void);
+void exit (int);
+
#ifdef DEBUG
#define abort() printf ("error, line %d\n", __LINE__)
#endif
+void abort (void);
+void exit (int);
+
struct S
{
int *sp, fc, *sc, a[2];
+void abort (void);
+void exit (int);
+
int
f (unsigned bitcount, int mant)
{
+void abort (void);
+void exit (int);
+
char a[10] = "deadbeef";
char
+void abort (void);
+void exit (int);
+
struct s
{
int a;
#include <stdio.h>
+
+void abort (void);
+void exit (int);
+
g ()
{
return '\n';
+void abort (void);
+void exit (int);
+
#define X 5.9486574767861588254287966331400356538172e4931L
long double x = X + X;
+void abort (void);
+void exit (int);
+
typedef unsigned long int st;
typedef unsigned long long dt;
typedef union
+void abort (void);
+void exit (int);
+
static int i;
void
+void abort (void);
+void exit (int);
+
#define SIZE 8
main()
+void abort (void);
+void exit (int);
+
__complex__
double f ()
{
+void abort (void);
+void exit (int);
+
long double
f (d, i)
long double d;
+void abort (void);
+void exit (int);
+
typedef struct
{
unsigned char a : 2;
+void abort (void);
+void exit (int);
+
unsigned
f ()
{
+void abort (void);
+void exit (int);
+
long val = 0x5e000000;
long
+void abort (void);
+void exit (int);
+
int
ffs (x)
int x;
+void abort (void);
+void exit (int);
+
int k = 0;
main()
+void exit (int);
+
main ()
{
unsigned char z = 0;
+void abort (void);
+void exit (int);
+
main ()
{
int i = 0;
+void abort (void);
+void exit (int);
+
int
test (arg)
int arg;
+void abort (void);
+void exit (int);
+
long long acc;
addhi (short a)
+void abort (void);
+void exit (int);
+
int
f (int a)
{
+void abort (void);
+void exit (int);
+
static char *
begfield (int tab, char *ptr, char *lim, int sword, int schar)
{
+void abort (void);
+void exit (int);
+
int
sub1 (unsigned long long i)
{
+void abort (void);
+void exit (int);
+
int
g (unsigned long long int *v, int n, unsigned int a[], int b)
{
+void exit (int);
+
#define L 1
main ()
{
+void exit (int);
+
#define m(L) (L'1' + (L))
main ()
{
+void exit (int);
+
sub (int i, int array[i++])
{
return i;
+void abort (void);
+void exit (int);
+
int
ts(a)
int a;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
void fdouble (double one, ...)
{
double value;
+void abort(void);
+
typedef struct { char *addr; long type; } object;
object bar (object blah)
+void abort (void);
+void exit (int);
+
int i, a[99];
void f (int one)
+void abort (void);
+void exit (int);
+
static int f(int) __attribute__((const));
int main()
{
+void abort (void);
+void exit (int);
+
typedef unsigned short Uint16;
typedef unsigned int Uint;
+void exit (int);
+
struct decision
{
char enforce_mode;
+void abort (void);
+void exit (int);
+
static void *self(void *p){ return p; }
int
+void abort (void);
+void exit (int);
+
unsigned char lookup_table [257];
static int
/* { dg-require-effective-target label_values } */
+void abort (void);
+void exit (int);
+
int expect_do1 = 1, expect_do2 = 2;
static int doit(int x){
+void abort (void);
+void exit (int);
+
typedef unsigned int dev_t;
typedef unsigned int kdev_t;
+void abort (void);
+void exit (int);
+
int compare(x, y)
unsigned int x;
unsigned int y;
+void abort (void);
+void exit (int);
+
main()
{
int i;
+void abort (void);
+void exit (int);
+
/* The bit-field below would have a problem if __INT_MAX__ is too
small. */
#if __INT_MAX__ < 2147483647
+void abort (void);
+void exit (int);
+
int a = 1;
int b = -1;
#include <stdio.h>
+void abort (void);
+void exit (int);
+
#ifndef STACK_SIZE
#define STACK_SIZE 200000
#endif
+void abort (void);
+void exit (int);
+
struct fd
{
unsigned char a;
+void abort (void);
+void exit (int);
+
void foo (unsigned int * p)
{
if ((signed char)(*p & 0xFF) == 17 || (signed char)(*p & 0xFF) == 18)
+void abort (void);
+void exit (int);
+
void func(int, int);
int main()
+void abort (void);
+void exit (int);
+
ns_name_skip (unsigned char **x, unsigned char *y)
{
*x = 0;
/* { dg-xfail-if "Can not call system libm.a with -msoft-float" { powerpc-*-aix* rs6000-*-aix* } { "-msoft-float" } { "" } } */
#include <math.h>
+void abort (void);
+void exit (int);
+
main()
{
volatile double a;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
void
stub(int num, ...)
{
+void abort (void);
+void exit (int);
+
void f(int i)
{
if (i != 1000)
+void abort (void);
+void exit (int);
+
#define NG 0x100L
unsigned long flg = 0;
+extern void abort(void);
extern int f2(void);
extern int f3(void);
extern void f1(void);
/* { dg-xfail-if "alias analysis conflicts with instruction scheduling" { m32r-*-* } { "-O2" "-O1" "-O0" "-Os"} { "" } } */
+void abort (void);
+void exit (int);
struct s { int a; int b;};
struct s s1;
struct s s2 = { 1, 2, };
/* Verify unaligned address aliasing on Alpha EV[45]. */
+void abort (void);
+void exit (int);
+
static unsigned short x, y;
void foo()
+void abort (void);
+void exit (int);
+
unsigned calc_mp(unsigned mod)
{
unsigned a,b,c;
+void abort (void);
+
int
foo (int x, int y, int i, int j)
{
+extern void abort (void);
+extern void exit (int);
extern int printf (const char *,...);
struct s { struct s *n; } *p;
+void abort (void);
+void exit (int);
+
int count = 0;
int dummy;
of function explicitly marked inline just because a label therein had
its address taken. */
+void abort (void);
+void exit (int);
+
static void *ptr1, *ptr2;
static int i = 1;
+void abort(void);
+
char line[4] = { '1', '9', '9', '\0' };
int main()
+void abort (void);
+void exit (int);
+
void f(long i)
{
if ((signed char)i < 0 || (signed char)i == 0)
+void abort (void);
+void exit (int);
+
struct a {
char a, b;
short c;
+void abort (void);
+void exit (int);
int x[10] = { 0,1,2,3,4,5,6,7,8,9};
#include <string.h>
+void abort (void);
+
void foo (int *BM_tab, int j)
{
int *BM_tab_base;
+void abort (void);
+void exit (int);
+
char a[] = "12345";
char b[] = "12345";
+void abort (void);
+void exit (int);
+
struct blah {
int m1, m2;
};
+void abort (void);
+void exit (int);
+
typedef struct {
int v[4];
} Test1;
+void abort (void);
+void exit (int);
+
int sum;
void
+void abort (void);
+void exit (int);
+
unsigned long bad(int reg, unsigned long inWord)
{
union {
+void abort (void);
+
int b;
void f ()
{
+void abort (void);
+void exit (int);
+
int gfbyte ( void )
{
return 0;
+void abort (void);
+void exit (int);
+
struct s {long a; int b;};
int foo(int x, void *y)
#include <stdio.h>
#include <math.h>
+void abort (void);
+
int
main()
{
+void abort (void);
+void exit (int);
+
unsigned test(unsigned one , unsigned bit)
{
unsigned val= bit & 1;
+void abort (void);
+void exit (int);
+
double test (const double le, const double ri)
{
double val = ( ri - le ) / ( ri * ( le + 1.0 ) );
+void abort (void);
+void exit (int);
+
#define mask 0xffff0000L
#define value 0xabcd0000L
-
typedef __SIZE_TYPE__ Size_t;
+void abort(void);
#if __SIZEOF_LONG__ < __SIZEOF_POINTER__
#define bufsize ((1LL << (8 * sizeof(Size_t) - 2))-256)
mode but have different alias sets. DOIT tries to get gcse to
invalidly hoist one of the values out of the loop. */
+void abort (void);
+void exit (int);
+
typedef int T0;
typedef long T1;
typedef long long T2;
+void abort (void);
+void exit (int);
+
typedef struct {
double epsilon;
} material_type;
-
+void abort (void);
+void exit (int);
int blah;
foo()
+void abort (void);
+void exit (int);
+
double x = 0x1.fp1;
int main()
{
/* This code was miscompiled at -O3 on x86.
Reported by Jim Meyering; distilled from bash. */
+void abort(void);
+
int rl_show_char (int c) { return 0; }
int rl_character_len (int c, int pos)
+void abort (void);
+void exit (int);
+
struct tmp
{
long long int pad : 12;
+void abort (void);
+void exit (int);
+
struct vc_data {
unsigned long space;
unsigned char vc_palette[16*3];
+void exit (int);
+
int x, y;
int
+void abort (void);
+void exit (int);
int
f1 ()
+void abort (void);
+void exit (int);
unsigned int f (unsigned int a)
{
+void abort (void);
+void exit (int);
+
#define VALUE 0x123456789abcdefLL
#define AFTER 0x55
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
#define VALUE 0x123456789abcdefLL
#define AFTER 0x55
/* Test against a problem with loop reversal. */
+void abort (void);
+void exit (int);
+
static void bug(int size, int tries)
{
int i;
+void abort (void);
+void exit (int);
+
int main( void )
{
unsigned long totalsize = 80;
+void abort (void);
+void exit (int);
char* doit(int flag)
{
return 1 + (flag ? "\0wrong\n" : "\0right\n");
+void abort (void);
+void exit (int);
+
__extension__ union { double d; int i[2]; } u = { d: -0.25 };
/* This assumes the endianness of words in a long long is the same as
+void abort (void);
+
typedef int new_int __attribute__ ((aligned(16)));
struct S { int x; };
/* Simple alignment checks;
looking for compiler/assembler alignment disagreements,
agreement between struct initialization and access. */
+void abort (void);
+
struct a_short { char c; short s; } s_c_s = { 'a', 13 };
struct a_int { char c ; int i; } s_c_i = { 'b', 14 };
struct b_int { short s; int i; } s_s_i = { 15, 16 };
/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+void abort (void);
+
void func(void) __attribute__((aligned(256)));
void func(void)
can only happen on !STRICT_ALIGNMENT targets. */
typedef __SIZE_TYPE__ size_t;
+void abort (void);
struct dummy { int x __attribute__((aligned)); };
#define BIGGEST_ALIGNMENT __alignof__(struct dummy)
/* Source: Neil Booth, 4 Nov 2001, derived from PR 2820 - field lookup in
nested anonymous entities was broken. */
+void abort (void);
+
struct
{
int x;
+void abort (void);
+void exit (int);
+
unsigned
sat_add (unsigned i)
{
+void abort (void);
+void exit (int);
+
long long
simple_rand ()
{
+void abort (void);
+void exit (int);
+
long
simple_rand ()
{
+void abort (void);
+void exit (int);
+
struct { long f8:8; long f24:24; } a;
struct { long f32:32; } b;
+void abort (void);
+void exit (int);
+
struct foo
{
unsigned half:16;
+void abort (void);
+void exit (int);
+
main ()
{
struct {
implementing signed and unsigned arithmetic.
*/
+void abort (void);
+void exit (int);
+
struct X {
unsigned int u3:3;
signed long int s31:31;
/* { dg-xfail-if "ABI specifies bitfields cannot exceed 32 bits" { mcore-*-* } } */
+
+void abort (void);
+void exit (int);
+
struct tmp
{
long long int pad : 12;
/* PR optimization/8423. */
+void abort (void);
+void exit (int);
+
#define btest(x) __builtin_constant_p(x) ? "1" : "0"
#ifdef __OPTIMIZE__
Prefetch using all valid combinations of rw and locality values.
These must be compile-time constants. */
+void exit (int);
+
#define NO_TEMPORAL_LOCALITY 0
#define LOW_TEMPORAL_LOCALITY 1
#define MODERATE_TEMPORAL_LOCALITY 1
Prefetch data using a variety of storage classes and address
expressions. */
+void exit (int);
+
int glob_int_arr[100];
int *glob_ptr_int = glob_int_arr;
int glob_int = 4;
Prefetch data using a variety of storage classes and address
expressions with volatile variables and pointers. */
+void exit (int);
+
int glob_int_arr[100];
int glob_int = 4;
volatile int glob_vol_int_arr[100];
data prefetch. Check changes to pointers and to array indices that are
either global variables or arguments. */
+void abort (void);
+void exit (int);
+
#define ARRSIZE 100
int arr[ARRSIZE];
compiler takes care of that. This fails if it aborts, anything else
is OK. */
+void exit (int);
+
struct S {
short a;
short b;
#include <limits.h>
+void exit (int);
+
#define ARRSIZE 65
int *bad_addr[ARRSIZE];
int arr_used;
+void abort (void);
+void exit (int);
+
int i;
double d;
* ====================================================
*/
+void abort (void);
+void exit (int);
+
#ifndef __vax__
static const unsigned long
B1 = 715094163, /* B1 = (682-0.03306235651)*2**20 */
+void abort (void);
+void exit (int);
+
double
g0 (double x)
{
+void abort (void);
+void exit (int);
+
__complex__ double
f (__complex__ double x, __complex__ double y)
{
+void abort (void);
+void exit (int);
+
struct complex
{
float r;
+void abort (void);
+void exit (int);
+
main ()
{
if ((__complex__ double) 0.0 != (__complex__ double) (-0.0))
+void abort (void);
+void exit (int);
+
float __complex__
p (float __complex__ a, float __complex__ b)
{
/* The bit-field below would have a problem if __INT_MAX__ is too
small. */
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ < 2147483647
int
main (void)
Note that this code is NOT intended for testing of accuracy of fp
conversions. */
+void abort (void);
+void exit (int);
+
float
u2f(u)
unsigned int u;
+void abort (void);
+void exit (int);
+
static inline long
g1 (double x)
{
+void abort (void);
+void exit (int);
+
typedef struct
{
unsigned a, b, c, d;
+void abort (void);
+void exit (int);
+
long
f (long x)
{
+void abort (void);
+void exit (int);
+
long long
f (long long x)
{
+void abort (void);
+void exit (int);
+
typedef enum
{
END = -1,
/* Copyright (C) 2000 Free Software Foundation */
/* by Alexandre Oliva <aoliva@redhat.com> */
+void abort (void);
+void exit (int);
+
enum foo { FOO, BAR };
/* Even though the underlying type of an enum is unspecified, the type
/* The bit-field below would have a problem if __INT_MAX__ is too
small. */
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ < 2147483647
int
main (void)
/* { dg-require-effective-target return_address } */
+void abort (void);
+
int check_fa_work (const char *, const char *) __attribute__((noinline));
int check_fa_mid (const char *) __attribute__((noinline));
int check_fa (char *) __attribute__((noinline));
+void abort (void);
+void exit (int);
+
static double f (float a);
static double (*fp) (float a);
#include <stdio.h>
+void abort (void);
+void exit (int);
+
float fp_add (float a, float b) { return a + b; }
float fp_sub (float a, float b) { return a - b; }
float fp_mul (float a, float b) { return a * b; }
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ != 2147483647 || (__LONG_LONG_MAX__ != 9223372036854775807ll && __LONG_MAX__ != 9223372036854775807ll)
int main(void) { exit (0); }
#else
+void abort (void);
+void exit (int);
+
volatile double a, *p;
int main ()
#include <float.h>
+void abort (void);
+
long double dfrom = 1.1L;
long double m1;
long double m2;
+void abort (void);
+void exit (int);
+
main()
{
double db1 = 1.7976931348623157e+308;
+void abort (void);
+void exit (int);
+
unsigned u=2147483839;float f0=2147483648e0,f1=2147483904e0;
main()
{
#include <stdio.h>
+void abort (void);
+void exit (int);
double normalize(x)double x;{if(x==0)x=0;return x;}
main(){char b[9];sprintf(b,"%g",normalize(-0.0));if(strcmp(b,"0"))abort();exit(0);}
+void abort (void);
+void exit (int);
+
main ()
{
union {
+ void abort (void);
+ void exit (int);
+
int main(void)
{
float reale = 1.0f;
/* Tail call optimizations would reverse the order of additions in func(). */
+void abort (void);
+void exit (int);
+
double func (const double *array)
{
double d = *array;
/* Tail call optimizations would reverse the order of multiplications
in func(). */
+void abort (void);
+void exit (int);
+
double func (const double *array)
{
double d = *array;
#include <signal.h>
#endif
+void abort (void);
+void exit (int);
+
double dnan = 1.0/0.0 - 1.0/0.0;
double x = 1.0;
#include <signal.h>
#endif
+void abort (void);
+void exit (int);
+
float fnan = 1.0f/0.0f - 1.0f/0.0f;
float x = 1.0f;
#include <signal.h>
#endif
+void abort (void);
+void exit (int);
+
long double dnan = 1.0l/0.0l - 1.0l/0.0l;
long double x = 1.0l;
+void abort (void);
+void exit (int);
+
#ifndef FLOAT
#define FLOAT double
#endif
/* Like fp-cmp-4.c, but test that the setcc patterns are correct. */
+void abort (void);
+void exit (int);
+
static int
test_isunordered(double x, double y)
{
extern void link_error (void);
extern void abort (void);
+extern void exit (int);
main ()
{
+void abort (void);
+void exit (int);
+
#ifndef FLOAT
#define FLOAT double
#endif
extern void link_error (void);
extern void abort (void);
+extern void exit (int);
main ()
{
#include <math.h>
+void abort (void);
+void exit (int);
+
static const double zero = 0.0;
static const double pone = 1.0;
static const double none = -1.0;
+void abort (void);
+void exit (int);
+
main ()
{
union
/* This test requires that float and unsigned int are the same size and
that the sign-bit of the float is at MSB of the unsigned int. */
+void abort (void);
+void exit (int);
+
#if __INT_MAX__ != 2147483647L
int main () { exit (0); }
#else
/* Test IEEE +0/-0 rules */
+void abort (void);
+void exit (int);
+
static double pzero = +0.0;
static double nzero = -0.0;
static double pinf = +1.0 / 0.0;
In the MMIX port, negdf2 was bogusly expanding -x into 0 - x. */
+void abort (void);
+void exit (int);
+
double nzerod = -0.0;
float nzerof = -0.0;
double zerod = 0.0;
/* Test gcse handling of IEEE 0/-0 rules. */
+void abort (void);
static double zero = 0.0;
int
which mishandles the case where 'd' is -0. They also initialised 'acc'
to a zero int rather than a zero double. */
+void abort (void);
+void exit (int);
+
double func (double d, int n)
{
if (n == 0)
dbr_schedule could do the next iteration's addition in the
branch delay slot, then subtract the value again if the branch
wasn't taken. This can lead to rounding errors. */
+void abort (void);
+void exit (int);
double x = -0x1.0p53;
double y = 1;
int
#include <ieeefp.h>
#endif
+void abort (void);
+void exit (int);
+
double d (unsigned long long k)
{
double x;
/* { dg-skip-if "strict reloc overflow checking" { msp430-*-* } { "*" } { "-mcpu=msp430" "-mlarge"} } */
+void abort (void);
+void exit (int);
+
int a[] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
/* Source: PR 321 modified for test suite by Neil Booth 14 Jan 2001. */
+void abort (void);
+void exit (int);
+
typedef unsigned long long uint64;
unsigned long pars;
+void abort (void);
+void exit (int);
+
main ()
{
int i, j, k[3];
/* Reduced from PR optimization/5076, PR optimization/2847 */
+void abort (void);
+
static int count = 0;
static void
+void abort (void);
+
static int a[199];
static void
/* PR opt/7130 */
+void abort (void);
#define TYPE long
void
+void abort (void);
+void exit (int);
+
int a3[3];
void f(int *a)
/* Bombed with a segfault on powerpc-linux. doloop.c generated wrong
loop count. */
+void abort (void);
+
void
foo (unsigned long *start, unsigned long *end)
{
#include <limits.h>
+void abort (void);
+void exit (int);
+
int a[2];
f (int i)
+void abort (void);
+
void f (int *p, int **q)
{
int i;
+void abort (void);
+void exit (int);
+
int
f()
{
+void abort (void);
+void exit (int);
+
int
f()
{
+void abort (void);
+void exit (int);
+
static int ap(int i);
static void testit(void){
int ir[4] = {0,1,2,3};
+void abort (void);
+void exit (int);
+
main()
{
char c;
+void abort (void);
+void exit (int);
+
void foo (unsigned int n)
{
int i, j = -1;
+void abort (void);
+void exit (int);
+
double a[3] = { 0.0, 1.0, 2.0 };
void bar (int x, double *y)
#include <string.h>
+void abort (void);
+void exit (int);
+
#if defined (STACK_SIZE)
#define MEMCPY_SIZE (STACK_SIZE / 3)
#else
#include <string.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
/* Test builtin-memcpy (which may emit different code for different N). */
#include <string.h>
+void abort (void);
+
#define TESTSIZE 80
char src[TESTSIZE] __attribute__ ((aligned));
#include <string.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
Written by Roger Sayle, April 22, 2002. */
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
Written by Roger Sayle, July 22, 2002. */
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
/* PR target/9348 */
+void abort (void);
+
#define u_l_l unsigned long long
#define l_l long long
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
#ifdef STACK_SIZE
/* We need to be careful that we don't blow our stack. Function f, in the
worst case, needs to fit on the stack:
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
main ()
{
double f (int x, ...)
/* { dg-require-effective-target trampolines } */
+void abort (void);
+void exit (int);
+
int
g (int a, int b, int (*gi) (int, int))
{
/* { dg-require-effective-target trampolines } */
+void abort (void);
+void exit (int);
+
extern int foo (int, int, int (*) (int, int, int, int, int, int, int));
int z;
/* { dg-require-effective-target trampolines } */
+void abort (void);
+void exit (int);
+
extern long foo (long, long, long (*) (long, long));
extern long use (long (*) (long, long), long, long);
functions without parameters that each need at least one "long"
preserved. Exposed problems related to the MMIX port. */
+void abort (void);
+void exit (int);
+
long level = 0;
extern long foo (void);
extern long bar (void);
+void abort (void);
+void exit (int);
+
short x1 = 17;
struct
+void abort (void);
+void exit (int);
void dummy (x, y)
int *x;
However, if there are no common symbols between P and Q, TBAA will
currently miss their alias relationship altogether. */
+
+void abort (void);
+
struct A
{
int t;
being taken in function foo(). Without IPA, by only looking inside
foo() we cannot tell for certain whether 'q' and 'b' alias each
other. */
+
+void abort (void);
+
struct A
{
int t;
/* We used to mis-compile this testcase as we did not know that
&a+offsetof(b,a) was the same as &a.b */
+
+void abort (void);
+
struct A
{
int t;
fall-through code, while that register held a pointer used in code at
the branch target. */
+void abort (void);
+void exit (int);
+
typedef __INTPTR_TYPE__ intptr_t;
typedef intptr_t W;
union u0
/* PR 17252. When a char * pointer P takes its own address, storing
into *P changes P itself. */
+void abort (void);
+
char *a;
main ()
Bug in code emitted by "return" pattern on CRIS: missing pop of
forced return address on stack. */
/* { dg-require-effective-target return_address } */
+void abort (void);
+void exit (int);
+
int calls = 0;
void *f (int) __attribute__ ((__noinline__));
that does not preserve the semantics of the original computation.
Make sure that won't happen. */
+void abort (void);
+void exit (int);
+
signed char a = -4;
int
+void abort (void);
+void exit (int);
+
void
foo (int n, int m)
{
+void exit (int);
int *x;
static void bar (char a[2][(*x)++]) {}
int
+void abort (void);
+void exit (int);
+
void
bar (int N)
{
/* { dg-skip-if "requires alloca" { ! alloca } { "-O0" } { "" } } */
+void abort (void);
+void exit (int);
+
void
bar (int N)
{
/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+void abort (void);
+void exit (int);
+
struct s1
{
int __attribute__ ((aligned (8))) a;
+void abort (void);
+void exit (int);
+
void __attribute__((noinline))
foo (int *p, int d1, int d2, int d3,
short count, int s1, int s2, int s3, int s4, int s5)
+void exit (int);
+
int f(unsigned number_of_digits_to_use)
{
if (number_of_digits_to_use >1294)
+void abort (void);
+void exit (int);
+
typedef unsigned long long ull;
int global;
+void abort (void);
+void exit (int);
+
void put_field (unsigned int start, unsigned int len)
{
int cur_bitshift = ((start + len) % 8) - 8;
+void abort (void);
+
__complex__ float
__attribute__ ((noinline)) foo (__complex__ float x)
{
/* Verify that that Thumb-1 epilogue size optimization does not clobber the
return value. */
+void abort (void);
+void exit (int);
+
long long v = 0x123456789abc;
__attribute__((noinline)) void bar (int *x)
#include <stdarg.h>
+void abort (void);
+
int fails = 0;
struct S { float a[3]; };
struct S a[5];
/* { dg-require-effective-target int32plus } */
#include <stdio.h>
+
+void abort (void);
+void exit (int);
+
typedef struct { int x; int y;} S;
extern int foo(S*);
int hi = 0, lo = 0;
+void exit (int);
+
int a, b, c, d = 1, e;
static signed char
+void exit (int);
+
int a;
int
main ()
+void abort (void);
+void exit (int);
+
char *
f (char *s, unsigned int i)
{
+void abort (void);
+void exit (int);
+
long double C = 5;
long double U = 1;
long double Y2 = 11;
+void abort (void);
+void exit (int);
+
int v = 3;
f ()
regardless of if the target has SIMD instructions.
*/
+void abort (void);
+void exit (int);
+
typedef int __attribute__((mode(SI))) __attribute__((vector_size (16))) vecint;
typedef int __attribute__((mode(SI))) siint;
regardless of if the target has SIMD instructions.
*/
+void abort (void);
+void exit (int);
+
typedef short __attribute__((vector_size (16))) vecint;
vecint i = { 150, 100, 150, 200, 0, 0, 0, 0 };
/* { dg-require-effective-target stdint_types } */
#include <stdint.h>
+
+void abort (void);
+
typedef int32_t __attribute__((vector_size(8))) v2si;
int64_t s64;
/* Test saving and restoring of SIMD registers. */
+void abort (void);
+
typedef short Q __attribute__((vector_size(8)));
Q q1 = {1, 2}, q2 = {3, 4}, q3 = {5, 6}, q4 = {7, 8};
#include <string.h>
#include <stddef.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
#include <string.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
+void abort (void);
+void exit (int);
+
typedef struct
{
short s __attribute__ ((aligned(2), packed));
+void abort (void);
+void exit (int);
+
typedef struct
{
short a __attribute__ ((aligned (2),packed));
+void abort (void);
+void exit (int);
+
typedef struct
{
unsigned char a __attribute__((packed));
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct tiny
{
char c;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
struct s { int x, y; };
f (int attr, ...)
#include <string.h>
#include <stddef.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
#include <string.h>
#include <stddef.h>
+void abort (void);
+void exit (int);
+
#ifndef MAX_OFFSET
#define MAX_OFFSET (sizeof (long long))
#endif
+void abort (void);
+void exit (int);
+
struct S
{
char f1;
+void abort (void);
+void exit (int);
+
struct {
int a:4;
int :4;
+void abort (void);
+void exit (int);
+
struct
{
unsigned int f1:1, f2:1, f3:3, f4:3, f5:2, f6:1, f7:1;
+void abort (void);
+void exit (int);
+
struct s {
int a[3];
int c[3];
#include <stdio.h>
#include <string.h>
+void abort (void);
+void exit (int);
+
char out[100];
typedef struct { double d; int i[3]; } B;
+void abort (void);
+void exit (int);
+
typedef struct
{
unsigned char a __attribute__ ((packed));
/* { dg-require-effective-target int32plus } */
+void abort (void);
+void exit (int);
+
int __attribute__ ((noinline)) foo (short x, unsigned short y)
{
return x * y;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef unsigned long L;
f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...)
{
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
#ifndef va_copy
#define va_copy __va_copy
#endif
side effect is used. */
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
static int
foo (int a, ...)
{
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
/*typedef unsigned long L;*/
typedef double L;
void f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...)
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef struct {
void *stream;
va_list ap;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
va_list global;
void vat(va_list param, ...)
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
void vafunction (char *dummy, ...)
{
double darg;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef double TYPE;
void vafunction (TYPE dummy1, TYPE dummy2, ...)
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef double TYPE;
void vafunction (char *dummy, ...)
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef double L;
void f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...)
{
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef int TYPE;
void vafunction (char *dummy, ...)
#include <stdarg.h>
+extern void abort (void);
+extern void exit (int);
extern __SIZE_TYPE__ strlen ();
int
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
void foo(va_list v)
{
unsigned long long x = va_arg (v, unsigned long long);
#include <stdarg.h>
+void abort(void);
+
struct two { long x, y; };
void foo(int a, int b, int c, int d, int e, struct two f, int g, ...)
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
double f (float f1, float f2, float f3, float f4,
float f5, float f6, ...)
{
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
typedef struct {
char a[32];
} big;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
va_double (int n, ...)
{
va_list args;
#include <stdarg.h>
+void abort (void);
+void exit (int);
+
f (int n, ...)
{
va_list args;
#include <stdarg.h>
+extern void abort (void);
+extern void exit (int);
extern __SIZE_TYPE__ strlen (const char *);
int
+void abort(void);
+void exit(int);
+
#define C L'\400'
#if C
#include <stddef.h>
+void abort(void);
+void exit(int);
+
const wchar_t ws[] = L"foo";
int