/cp
2018-05-21 Paolo Carlini <paolo.carlini@oracle.com>
PR c++/84588
* parser.c (cp_parser_maybe_commit_to_declaration,
cp_parser_check_condition_declarator): New.
(cp_parser_simple_declaration): Use the first above.
(cp_parser_condition): Use both the above; enforce
[stmt.stmt]/2 about the declarator not specifying
a function or an array; improve error-recovery.
/testsuite
2018-05-21 Paolo Carlini <paolo.carlini@oracle.com>
PR c++/84588
* g++.dg/cpp0x/cond1.C: New.
* g++.dg/cpp1y/pr84588-1.C: Likewise.
* g++.dg/cpp1y/pr84588-2.C: Likewise.
* g++.dg/cpp1y/pr84588-3.C: Likewise.
* g++.dg/parse/cond6.C: Likewise.
* g++.dg/parse/cond7.C: Likewise.
* g++.dg/parse/cond8.C: Likewise.
* g++.dg/cpp1z/decomp16.C: Update.
* g++.old-deja/g++.jason/cond.C: Likewise.
From-SVN: r260482
2018-05-21 Steven G. Kargl <kargl@gcc.gnu.org>
ChangeLog for r260480
* gfortran.dg/graphite/block-2.f: Adjust testcase for new gfortran
warnings for deleted and obsolescent features.
* gfortran.dg/graphite/id-19.f: Ditto.
* gfortran.dg/graphite/id-20.f: Ditto.
* gfortran.dg/graphite/id-27.f90: Ditto.
* gfortran.dg/graphite/pr82449.f: Ditto.
From-SVN: r260481
This recently-committed test fails the INS scan for tiny and large memory models.
That is because instead of the:
make_vector:
adrp x1, a
adrp x0, b
movi v0.4s, 0
ldr s2, [x1, #:lo12:a]
ldr s1, [x0, #:lo12:b]
ins v0.s[2], v2.s[0]
ins v0.s[3], v1.s[0]
ret
That we generate for the default small model, we end up with a simple register
addressing mode with no addend/offset for the lane load:
make_vector:
movi v0.4s, 0
adr x1, a
adr x0, b
ld1 {v0.s}[2], [x1]
ld1 {v0.s}[3], [x0]
ret
and
make_vector:
movi v0.4s, 0
adrp x0, .LC0
ldr x1, [x0, #:lo12:.LC0]
adrp x0, .LC1
ldr x0, [x0, #:lo12:.LC1]
ld1 {v0.s}[2], [x1]
ld1 {v0.s}[3], [x0]
ret
So we end up merging the load and the lane insert.
This patch adjusts the testcase to scan for the right thing accordingly.
Checked that the testcase passes with -mcmodel=tiny, -mcmodel=small, -mcmodel=large.
* gcc.target/aarch64/vec_init_1.c: Scan for LD1 instead of INS for
tiny and large memory models.
From-SVN: r260474
The compiler warns on an object declaration with default initialization
and an address clause, to indicate that the overlay implied by the address
clause might affect a value elsewhere. The warning is suppressed if the type
carries the Suppress_Initialization aspect. With this patch the compiler
also inhibits the warning if the aspect is specified for the object itself.
2018-05-21 Ed Schonberg <schonberg@adacore.com>
gcc/ada/
* freeze.adb (Warn_Overlay): Do not emit a wawrning on an object
declaration with an explicit address clause and a type with default
initialization, if the declaration carries an aspect
Suppress_Initialization.
gcc/testsuite/
* gnat.dg/suppress_initialization.adb,
gnat.dg/suppress_initialization_pkg.ads: New testcase.
From-SVN: r260471
This patch ensures that aspect specifications which appear on package,
protected, and task body stubs are properly analyzed.
------------
-- Source --
------------
-- pack.ads
package Pack
with SPARK_Mode,
Abstract_State => State
is
-------------------------------------
-- Refined_Depends, Refined_Global --
-------------------------------------
procedure Proc_1;
procedure Proc_2
with Global => (In_Out => State),
Depends => (State => State);
task Task_Obj_1;
task Task_Obj_2
with Global => (In_Out => State),
Depends => (State => State);
------------------
-- Refined_Post --
------------------
function Func_1 (Formal : Integer) return Integer;
function Func_2 (Formal : Integer) return Integer
with Post => Func_2'Result > Formal;
-------------------
-- Refined_State --
-------------------
package Pack_1 is end Pack_1;
package Pack_2 with Abstract_State => State_2 is end Pack_2;
----------------
-- SPARK_Mode --
----------------
package Pack_3 with SPARK_Mode => Off is end Pack_3;
package Pack_4 with SPARK_Mode => Off is end Pack_4;
package Pack_5 is end Pack_5;
protected type Prot_Typ_1 with SPARK_Mode => Off is end Prot_Typ_1;
protected type Prot_Typ_2 with SPARK_Mode => Off is end Prot_Typ_2;
protected type Prot_Typ_3 is end Prot_Typ_3;
procedure Proc_3 with SPARK_Mode => Off;
procedure Proc_4 with SPARK_Mode => Off;
procedure Proc_5;
task type Task_Typ_1 with SPARK_Mode => Off;
task type Task_Typ_2 with SPARK_Mode => Off;
task type Task_Typ_3;
end Pack;
-- pack.adb
package body Pack
with SPARK_Mode,
Refined_State => (State => Constit)
is
Constit : Integer := 0;
-------------------------------------
-- Refined_Depends, Refined_Global --
-------------------------------------
procedure Proc_1 is separate
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit); -- Error
procedure Proc_2 is separate
with Refined_Global => (In_Out => Constit), -- OK
Refined_Depends => (Constit => Constit); -- OK
task body Task_Obj_1 is separate
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit); -- Error
task body Task_Obj_2 is separate
with Refined_Global => (In_Out => Constit), -- OK
Refined_Depends => (Constit => Constit); -- OK
------------------
-- Refined_Post --
------------------
function Func_1 (Formal : Integer) return Integer is separate
with Refined_Post => Func_1'Result > Formal; -- OK
function Func_2 (Formal : Integer) return Integer is separate
with Refined_Post => Func_2'Result > Formal; -- OK
-------------------
-- Refined_State --
-------------------
package body Pack_1 is separate
with Refined_State => (State_1 => Constit_1); -- Error
package body Pack_2 is separate
with Refined_State => (State_2 => Constit_2); -- Error
----------------
-- SPARK_Mode --
----------------
package body Pack_3 is separate with SPARK_Mode => On; -- Error
package body Pack_4 is separate;
package body Pack_5 is separate with SPARK_Mode => Off; -- Error
protected body Prot_Typ_1 is separate with SPARK_Mode => On; -- Error
protected body Prot_Typ_2 is separate;
protected body Prot_Typ_3 is separate with SPARK_Mode => Off; -- Error
procedure Proc_3 is separate with SPARK_Mode => On; -- Error
procedure Proc_4 is separate;
procedure Proc_5 is separate with SPARK_Mode => Off; -- Error
task body Task_Typ_1 is separate with SPARK_Mode => On; -- Error
task body Task_Typ_2 is separate;
task body Task_Typ_3 is separate with SPARK_Mode => Off; -- Error
end Pack;
-- pack-func_1.adb
separate (Pack)
function Func_1 (Formal : Integer) return Integer
with Refined_Post => Func_1'Result > Formal -- Error
is
begin
return Formal * 10;
end Func_1;
-- pack-func_2.adb
separate (Pack)
function Func_2 (Formal : Integer) return Integer
with Refined_Post => Func_2'Result > Formal -- Error
is
begin
return Formal * 10;
end Func_2;
-- pack-pack_1.adb
separate (Pack)
package body Pack_1
with SPARK_Mode,
Refined_State => (State_1 => Constit_1) -- Error
is
Constit_1 : Integer := 1;
end Pack_1;
-- pack-pack_2.adb
separate (Pack)
package body Pack_2
with SPARK_Mode,
Refined_State => (State_2 => Constit_2) -- OK
is
Constit_2 : Integer := 2;
end Pack_2;
-- pack-pack_3.adb
separate (Pack)
package body Pack_3 is end Pack_3;
-- pack-pack_4.adb
separate (Pack)
package body Pack_4 with SPARK_Mode => On is end Pack_4; -- OK
-- pack-pack_5.adb
separate (Pack)
package body Pack_5 with SPARK_Mode => On is end Pack_5; -- OK
-- pack-proc_1.adb
separate (Pack)
procedure Proc_1
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit) -- Error
is begin null; end Proc_1;
-- pack-proc_2.adb
separate (Pack)
procedure Proc_2
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit) -- Error
is begin null; end Proc_2;
-- pack-proc_3.adb
separate (Pack)
procedure Proc_3 is begin null; end Proc_3;
-- pack-proc_4.adb
separate (Pack)
procedure Proc_4 with SPARK_Mode => On is begin null; end Proc_4; -- OK
-- pack-proc_5.adb
separate (Pack)
procedure Proc_5 with SPARK_Mode => On is begin null; end Proc_5; -- OK
-- pack-prot_typ_1.adb
separate (Pack)
protected body Prot_Typ_1 is end Prot_Typ_1;
-- pack-prot_typ_2.adb
separate (Pack)
protected body Prot_Typ_2 with SPARK_Mode => On is end Prot_Typ_2; -- OK
-- pack-prot_typ_3.adb
separate (Pack)
protected body Prot_Typ_3 with SPARK_Mode => On is end Prot_Typ_3; -- OK
-- pack-task_obj_1.adb
separate (Pack)
task body Task_Obj_1
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit) -- Error
is begin null; end Task_Obj_1;
-- pack-task_obj_2.adb
separate (Pack)
task body Task_Obj_2
with Refined_Global => (In_Out => Constit), -- Error
Refined_Depends => (Constit => Constit) -- Error
is begin null; end Task_Obj_2;
-- pack-task_typ_1.adb
separate (Pack)
task body Task_Typ_1 is begin null; end Task_Typ_1;
-- pack-task_typ_2.adb
separate (Pack)
task body Task_Typ_2 with SPARK_Mode => On is -- OK
begin null; end Task_Typ_2;
-- pack-task_typ_3.adb
separate (Pack)
task body Task_Typ_3 with SPARK_Mode => On is -- OK
begin null; end Task_Typ_3;
----------------------------
-- Compilation and output --
----------------------------
$ gcc -c pack.adb
pack.adb:12:11: useless refinement, declaration of subprogram "Proc_1" lacks
aspect or pragma Global
pack.adb:13:11: useless refinement, declaration of subprogram "Proc_1" lacks
aspect or pragma Depends
pack.adb:20:11: useless refinement, declaration of task type "Task_Obj_1" lacks
aspect or pragma Global
pack.adb:21:11: useless refinement, declaration of task type "Task_Obj_1" lacks
aspect or pragma Depends
pack.adb:42:11: aspect "Refined_State" must apply to a package body
pack.adb:45:11: aspect "Refined_State" must apply to a package body
pack.adb:51:41: incorrect placement of aspect "Spark_Mode"
pack.adb:53:41: incorrect placement of aspect "Spark_Mode"
pack.adb:55:47: incorrect placement of aspect "Spark_Mode"
pack.adb:57:47: incorrect placement of aspect "Spark_Mode"
pack.adb:59:38: incorrect placement of aspect "Spark_Mode"
pack.adb:61:38: incorrect placement of aspect "Spark_Mode"
pack.adb:63:42: incorrect placement of aspect "Spark_Mode"
pack.adb:65:42: incorrect placement of aspect "Spark_Mode"
pack-proc_1.adb:4:08: aspect "Refined_Global" cannot apply to a subunit
pack-proc_1.adb:5:08: aspect "Refined_Depends" cannot apply to a subunit
pack-proc_2.adb:4:08: aspect "Refined_Global" cannot apply to a subunit
pack-proc_2.adb:5:08: aspect "Refined_Depends" cannot apply to a subunit
pack-task_obj_1.adb:4:08: aspect "Refined_Global" cannot apply to a subunit
pack-task_obj_1.adb:5:08: aspect "Refined_Depends" cannot apply to a subunit
pack-task_obj_2.adb:4:08: aspect "Refined_Global" cannot apply to a subunit
pack-task_obj_2.adb:5:08: aspect "Refined_Depends" cannot apply to a subunit
pack-func_1.adb:4:08: aspect "Refined_Post" cannot apply to a subunit
pack-func_2.adb:4:08: aspect "Refined_Post" cannot apply to a subunit
pack-pack_1.adb:3:14: body of package "Pack_1" has unused hidden states
pack-pack_1.adb:3:14: variable "Constit_1" defined at line 7
pack-pack_1.adb:5:08: useless refinement, package "Pack_1" does not define
abstract states
pack-pack_1.adb:5:26: "State_1" is undefined
pack-pack_3.adb:3:01: incorrect use of SPARK_Mode at pack.adb:2
pack-pack_3.adb:3:01: value Off was set for SPARK_Mode on "Pack_3" at
pack.ads:38
pack-pack_4.adb:3:01: incorrect use of SPARK_Mode at pack.adb:2
pack-pack_4.adb:3:01: value Off was set for SPARK_Mode on "Pack_4" at
pack.ads:39
pack-pack_4.adb:3:26: incorrect use of SPARK_Mode
pack-pack_4.adb:3:26: value Off was set for SPARK_Mode on "Pack_4" at
pack.ads:39
pack-prot_typ_2.adb:3:32: incorrect use of SPARK_Mode
pack-prot_typ_2.adb:3:32: value Off was set for SPARK_Mode on "Prot_Typ_2" at
pack.ads:43
pack-proc_3.adb:3:01: incorrect use of SPARK_Mode at pack.adb:2
pack-proc_3.adb:3:01: value Off was set for SPARK_Mode on "Proc_3" at
pack.ads:46
pack-proc_4.adb:3:01: incorrect use of SPARK_Mode at pack.adb:2
pack-proc_4.adb:3:01: value Off was set for SPARK_Mode on "Proc_4" at
pack.ads:47
pack-proc_4.adb:3:23: incorrect use of SPARK_Mode
pack-proc_4.adb:3:23: value Off was set for SPARK_Mode on "Proc_4" at
pack.ads:47
pack-task_typ_2.adb:3:27: incorrect use of SPARK_Mode
pack-task_typ_2.adb:3:27: value Off was set for SPARK_Mode on "Task_Typ_2" at
pack.ads:51
2018-05-21 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* sem_ch6.adb (Analyze_Generic_Subprogram_Body): Rename the call to
Analyze_Aspect_Specifications_On_Body_Or_Stub.
(Analyze_Subprogram_Body_Helper): Rename the calls to
Analyze_Aspect_Specifications_On_Body_Or_Stub.
* sem_ch9.adb (Analyze_Entry_Body): Rename the call to
Analyze_Aspect_Specifications_On_Body_Or_Stub.
* sem_ch10.adb: Add with and use clause for Sem_Ch13.
(Analyze_Package_Body_Stub): Add constant Id. Decorate the package stub
prior to analyzing its aspects.
(Analyze_Protected_Body_Stub): Add constant Id. Decorate the package
stub prior to analyzing its aspects. Save and restore the configuration
switches.
(Analyze_Task_Body_Stub): Add constant Id. Decorate the package stub
prior to analyzing its aspects.
* sem_ch13.adb (Analyze_Aspect_Specifications_On_Body_Or_Stub): Renamed
to Analyze_Aspects_On_Subprogram_Body_Or_Stub.
* sem_ch13.ads (Analyze_Aspect_Specifications_On_Body_Or_Stub): Renamed
to Analyze_Aspects_On_Subprogram_Body_Or_Stub.
* sem_prag.adb: Code reformatting.
(Analyze_Refined_Depends_Global_Post): Consider task body stubs.
From-SVN: r260469
This properly links with libsocket when needed by the user code.
2018-05-21 Jerome Lambourg <lambourg@adacore.com>
gcc/ada/
* gcc-interface/Makefile.in: Add g-soliop__qnx.ads to the runtime build
for QNX.
From-SVN: r260468
This patch corrects the part of the access-before-elaboration mechanism which
ensures that the freeze node of a tagged type is within the early call region
of all its overriding bodies to ignore predefined primitives.
------------
-- Source --
------------
-- pack.ads
package Pack with SPARK_Mode is
type Parent_Typ is tagged null record;
procedure Prim (Obj : Parent_Typ);
type Deriv_Typ is new Parent_Typ with private;
overriding procedure Prim (Obj : Deriv_Typ);
private
type Deriv_Typ is new Parent_Typ with null record;
end Pack;
-----------------
-- Compilation --
-----------------
$ gcc -c pack.ads
2018-05-21 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* exp_cg.adb: Remove with and use clause for Exp_Disp.
* exp_ch9.adb: Remove with and use clause for Exp_Disp.
* exp_disp.adb (Is_Predefined_Dispatching_Operation): Moved to Sem_Util.
(Is_Predefined_Interface_Primitive): Moved to Sem_Util.
(Is_Predefined_Internal_Operation): Moved to Sem_Util.
* exp_disp.ads (Is_Predefined_Dispatching_Operation): Moved to Sem_Util.
(Is_Predefined_Interface_Primitive): Moved to Sem_Util.
(Is_Predefined_Internal_Operation): Moved to Sem_Util.
* exp_dist.adb: Remove with and use clause for Exp_Disp.
* freeze.adb: Remove with and use clause for Exp_Disp.
* sem_cat.adb: Remove with and use clause for Exp_Disp.
* sem_ch6.adb: Remove with and use clause for Exp_Disp.
* sem_ch12.adb: Remove with and use clause for Exp_Disp.
* sem_elab.adb (Check_Overriding_Primitive): Do not process predefined
primitives.
* sem_util.adb: Remove with and use clause for Exp_Disp.
(Is_Predefined_Dispatching_Operation): Moved from Exp_Disp.
(Is_Predefined_Interface_Primitive): Moved from Exp_Disp.
(Is_Predefined_Internal_Operation): Moved from Exp_Disp.
* sem_util.ads (Is_Predefined_Dispatching_Operation): Moved from
Exp_Disp.
(Is_Predefined_Interface_Primitive): Moved from Exp_Disp.
(Is_Predefined_Internal_Operation): Moved from Exp_Disp.
From-SVN: r260467
A type conversion may be illegal if the expression in the conversion has a
limited view of a type. This patch expands the error report to indicate the
presence of a limited view, and when the context is a package body it suggests
the addition of a regular with-clause to make the full view available.
Compiling client.adb must yield:
client.adb:6:16: invalid conversion, not compatible with limited view
of type "Map_Type" defined at maps.ads:2
client.adb:6:16: add with_clause for "Maps" to current unit
----
package Maps is
type Map_Type is null record;
end;
----
limited with Maps;
package Payloads is
function Get_Map return access Maps.Map_Type;
end;
----
with Maps;
package Maps2 is
type New_Map_Type is new Maps.Map_Type;
end;
----
with Maps2;
package Client is
procedure Foo (Map : Maps2.New_Map_Type) is null;
procedure Bar;
end;
----
with Payloads;
package body Client is
procedure Bar is
begin
Foo (Maps2.New_Map_Type (Payloads.Get_Map.all));
end;
end;
2018-05-21 Ed Schonberg <schonberg@adacore.com>
gcc/ada/
* sem_res.adb (Valid_Conversion): Improve error message on an illegal
type conversion whose expression has a limited view of a type.
From-SVN: r260466
This patch fixes an omission in the expansion of loops over GNAT-specific
iterable objects. If the source includes an explicit name for the loop,
that name has to be preserved in the expanded code to allow exit statements
to mention it.
2018-05-21 Ed Schonberg <schonberg@adacore.com>
gcc/ada/
* exp_ch5.adb (Build_Formal_Container_Iteration): If source has
explicit name for iterator loop, preserve that name in expanded
construct, for possible use in exit statements.
gcc/testsuite/
* gnat.dg/exit1.adb: New testcase.
From-SVN: r260465
2018-05-21 Javier Miranda <miranda@adacore.com>
gcc/ada/
* sem_ch4.adb (Analyze_Membership_Op): Avoid compiler crash when the
spec of a unit has Ada 2012 membership tests with multiple choices and
the unit body is not compiled under Ada 2012 mode.
From-SVN: r260464
2018-05-21 Doug Rupp <rupp@adacore.com>
gcc/ada/
* sigtramp-vxworks-target.inc: Set cfa_reg properly from sigcontext
pregs.
(CFI_COMMON_REGS): Restore LR jic probed from prologue.
(REGNO_PC_OFFSET): Change to correct value for Aarch64.
From-SVN: r260463
This patch refines the handling of the well-known syntactic ambiguity created
by a function with defaulted parameters that returns an array, so that F (X)
may designate a call to the function, or an indexing of a parameterless call.
This patch handles the case where such a call is itself the prefix of another
call, and the function is a primitive operation invoked in prefix form.
2018-05-21 Ed Schonberg <schonberg@adacore.com>
gcc/ada/
* sem_ch4.adb (Analyze_One_Call): Recognize complex cases where an
indexed call originally in prefix forn is itself the prefix of a
further call.
gcc/testsuite/
* gnat.dg/array30.adb: New testcase.
From-SVN: r260461
2018-05-21 Piotr Trojanek <trojanek@adacore.com>
gcc/ada/
* sem_eval.adb (Is_Null_Range): Clarify access to the full view of a
type.
(Not_Null_Range): Same as above.
From-SVN: r260460
In the frontend inlining used in GNATprove, inlining of a return statement
was using an unchecked type conversion, which could cause a necessary
run-time check on the conversion to be skipped. Now fixed.
There is no impact on compilation.
2018-05-21 Yannick Moy <moy@adacore.com>
gcc/ada/
* inline.adb (Expand_Inlined_Call.Process_Formals): Use a type
conversion instead of an unchecked type conversion when inlining a
return statement, unless type qualification is required (for character
and string literal) or no check can result from the conversion (for
access types).
* opt.ads: Update comment.
From-SVN: r260458
This patch modifies the semantics of pragma Elaboration_Checks. The pragma
was intended to be a configuration pragma, however its placement was never
verified until now.
The pragma may appear in the following contexts:
* Configuration pragmas file
* Prior to the context clauses of a compilation unit's initial declaration
Any other placement of the pragma will result in a warning and the effects of
the offending pragma will be ignored.
------------
-- Source --
------------
-- elab_checks_1.adc
pragma Elaboration_Checks (Dynamic);
-- elab_checks_2.adc
pragma Elaboration_Checks (Dynamic);
pragma Elaboration_Checks (Static); -- Error
-- pack_1.ads
pragma Elaboration_Checks (Static); -- OK
package Pack_1 is
end Pack_1;
-- pack_2.ads
pragma Elaboration_Checks (Static); -- OK
pragma Elaboration_Checks (Static); -- Error
package Pack_2 is
end Pack_2;
-- pack_3.ads
package Pack_3 is
procedure Proc;
end Pack_3;
-- pack_3.adb
pragma Elaboration_Checks (Static); -- Error
package body Pack_3 is
procedure Proc is begin null; end Proc;
end Pack_3;
-- pack_4.ads
package Pack_4 is
procedure Proc;
end Pack_4;
-- pack_4.adb
package body Pack_4 is
procedure Proc is separate;
end Pack_4;
-- pack_4-proc.adb
pragma Elaboration_Checks (Static); -- Error
separate (Pack_4)
procedure Proc is begin null; end Proc;
-- gen.ads
generic
with function Called_At_Elaboration return Boolean;
package Gen is
procedure Proc;
end Gen;
-- gen.adb
package body Gen is
procedure Proc is
Obj : constant Boolean := Called_At_Elaboration;
begin null; end Proc;
begin
Proc;
end Gen;
-- abe_static.ads
pragma Elaboration_Checks (Static);
with Gen;
package ABE_Static is
function ABE return Boolean;
package Inst_1 is new Gen (ABE);
end ABE_Static;
-- abe_static.adb
package body ABE_Static is
package Inst_2 is new Gen (ABE);
package Subunit is
end Subunit;
package body Subunit is separate;
function ABE return Boolean is
begin
return True;
end ABE;
end ABE_Static;
-- abe_static-subunit.adb
separate (ABE_Static)
package body Subunit is
package Inst_3 is new Gen (ABE);
package Nested_Subunit is
end Nested_Subunit;
package body Nested_Subunit is separate;
end Subunit;
-- abe_static-subunit-nested_subunit.adb
separate (ABE_Static.Subunit)
package body Nested_Subunit is
package Inst_4 is new Gen (ABE);
end Nested_Subunit;
-- abe_static_main.adb
with ABE_Static;
procedure ABE_Static_Main is begin null; end ABE_Static_Main;
----------------------------
-- Compilation and output --
----------------------------
$ gcc -c pack_1.ads -gnatec=elab_checks_1.adc
$ gcc -c pack_1.ads -gnatec=elab_checks_2.adc
$ gcc -c pack_1.ads
$ gcc -c pack_2.ads
$ gcc -c pack_3.adb
$ gcc -c pack_4.adb
$ gnatmake -q -gnatE abe_static_main.adb
elab_checks_2.adc:2:01: pragma "Elaboration_Checks" duplicates pragma declared
at line 1
pack_2.ads:2:01: pragma "Elaboration_Checks" duplicates pragma declared at line
1
pack_3.adb:1:01: warning: effects of pragma "Elaboration_Checks" are ignored
pack_3.adb:1:01: warning: place pragma on initial declaration of library unit
pack_4-proc.adb:1:01: warning: effects of pragma "Elaboration_Checks" are
ignored
pack_4-proc.adb:1:01: warning: place pragma on initial declaration of library
unit
abe_static.adb:2:04: warning: in instantiation at gen.adb:3
abe_static.adb:2:04: warning: cannot call "ABE" before body seen
abe_static.adb:2:04: warning: Program_Error may be raised at run time
abe_static.adb:2:04: warning: body of unit "ABE_Static" elaborated
abe_static.adb:2:04: warning: procedure "Proc" called at gen.adb:6, instance
at line 2
abe_static.adb:2:04: warning: function "ABE" called at gen.adb:3, instance at
line 2
abe_static.ads:8:04: warning: in instantiation at gen.adb:3
abe_static.ads:8:04: warning: cannot call "ABE" before body seen
abe_static.ads:8:04: warning: Program_Error may be raised at run time
abe_static.ads:8:04: warning: spec of unit "ABE_Static" elaborated
abe_static.ads:8:04: warning: procedure "Proc" called at gen.adb:6, instance
at line 8
abe_static.ads:8:04: warning: function "ABE" called at gen.adb:3, instance at
line 8
abe_static-subunit.adb:4:04: warning: in instantiation at gen.adb:3
abe_static-subunit.adb:4:04: warning: cannot call "ABE" before body seen
abe_static-subunit.adb:4:04: warning: Program_Error may be raised at run time
abe_static-subunit.adb:4:04: warning: body of unit "ABE_Static" elaborated
abe_static-subunit.adb:4:04: warning: procedure "Proc" called at gen.adb:6,
instance at line 4
abe_static-subunit.adb:4:04: warning: function "ABE" called at gen.adb:3,
instance at line 4
abe_static-subunit-nested_subunit.adb:4:04: warning: in instantiation at
gen.adb:3
abe_static-subunit-nested_subunit.adb:4:04: warning: cannot call "ABE" before
body seen
abe_static-subunit-nested_subunit.adb:4:04: warning: Program_Error may be
raised at run time
abe_static-subunit-nested_subunit.adb:4:04: warning: body of unit
"ABE_Static" elaborated
abe_static-subunit-nested_subunit.adb:4:04: warning: procedure "Proc" called
at gen.adb:6, instance at line 4
abe_static-subunit-nested_subunit.adb:4:04: warning: function "ABE" called at
gen.adb:3, instance at line 4
warning: "abe_static_main.adb" has dynamic elaboration checks and with's
warning: "abe_static.ads" which has static elaboration checks
2018-05-21 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Install the elaboration
model of the compilation unit spec, if any.
* sem_ch7.adb (Analyze_Package_Body_Helper): Install the elaboration
model of the compilation unit spec, if any.
* sem_ch10.adb (Analyze_Subunit): Install the elaboration model of the
parent compilation unit spec, if any.
* sem_elab.adb (Check_Elaboration_Scenarios): Restore the elaboration
model of the main unit.
(Is_Same_Unit): The routine now uses Unit_Entity.
(Is_Subunit): Removed.
(Normalize_Unit): Removed.
(Unit_Entity): New routine.
* sem_prag.adb (Analyze_Pragma): Reimplement the handling of pragma
Elaboration_Checks. The analysis now ensures that the pragma appears at
the configuration level, and on the initial declaration of a unit.
Other placements are either flagged as illegal, or ignored.
(Check_Duplicate_Elaboration_Checks_Pragma): New routine.
(Ignore_Elaboration_Checks_Pragma): New routine.
* sem_util.adb (Install_Elaboration_Model): New routine.
* sem_util.ads (Install_Elaboration_Model): New routine.
* doc/gnat_rm/implementation_defined_pragmas.rst: Update the
documentation of pragma Elaboration_Checks.
* gnat_rm.texi: Regenerate.
From-SVN: r260457
Any program calling Gnat.Traceback.Symbolic.Enable_Cache for
dwarf based symbolization fails with a segmentation violation
when spawned with an inaccurate argv[0] such that it couldn't
be found on PATH.
argv[0] is most often found on PATH. One plausible case where
it isn't is when argv[0] is a mere file name and . isn't on PATH,
which might happen out of imprecise exec calls.
This change robustifies the Traceback.Symbolic implementation
to work in this case as well, by just trying to work with argv[0]
untouched as the executable file to fetch dwarf info from.
2018-05-21 Olivier Hainque <hainque@adacore.com>
gcc/ada/
* libgnat/s-trasym__dwarf.adb (Executable_Name): Return argv[0] instead
of empty string when argv[0] couldn't be found on PATH.
(Enable_Cache): Raise Program_Error instead of attempting a null
pointer dereference when the Exec_Module initialization failed.
From-SVN: r260456
Explicit External aspect was an equivalant to an implicit default. It was only
needed as a workaround for a frontend bug. (If it meant to serve as
documentation, there should be explicit Effective_Reads and Effective_Writes
set to False too.)
No test, because these changes are semantically neutral.
2018-05-21 Piotr Trojanek <trojanek@adacore.com>
gcc/ada/
* libgnarl/a-reatim.ads (Clock_Time): Remove External aspect.
* libgnarl/a-taside.ads (Tasking_State): Likewise.
* libgnat/a-calend.ads (Clock_Time): Likewise.
From-SVN: r260455
During the special inlining done in GNATprove mode, a call in prefix
notation leads to a spurious error. Now fixed.
2018-05-21 Yannick Moy <moy@adacore.com>
gcc/ada/
* sem_ch6.adb (Analyze_Procedure_Call): Refine test to recognize prefix
call notation in inlined call in GNATprove mode.
From-SVN: r260454
This patch ensures that an abstract state declared with simple option
"synchronous" is automatically considered "external".
2018-05-21 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* einfo.adb (Is_External_State): An abstract state is also external
when it is declared with option "synchronous".
* einfo.ads: Update the documentation of synthesized attribute
Is_External_State.
* sem_util.adb (Find_Simple_Properties): New routine.
(Is_Enabled_External_Property): New routine.
(State_Has_Enabled_Property): Reimplemented. The two flavors of option
External have precedence over option Synchronous when determining
whether a property is in effect.
gcc/testsuite/
* gnat.dg/sync2.adb, gnat.dg/sync2.ads: New testcase.
From-SVN: r260453
In some cases, the inlining performed in GNATprove mode leads to a crash,
when inlining a call where a return statement of the inlined function
returns a string literal. Now fixed.
2018-05-21 Yannick Moy <moy@adacore.com>
gcc/ada/
* sem_eval.adb (Static_Length): Take into account case of variable of
subtype string literal.
From-SVN: r260452
Symbolization of traceback entries from dwarf info was
failing in some cases with shared libraries on ELF targets,
from unexpected overlapping of what we believed were code
regions for distinct modules.
This is caused by the inclusion of all SHF_ALLOC sections in
the set of sections of possible relevance to determine the span
of possible code addresses for a module.
This change renames the Get_memory_Bound subprogram to better
convey that we really care about sections hosting executable code
in particular, matching what the spec comments already claims.
It also renames the boolean flag conveying the info of relevance
in the Object_Section record, and adjusts the ELF implementation
of Get_Section to feed this flag from SHF_EXECINSTR instead of
SHF_ALLOC.
2018-05-21 Olivier Hainque <hainque@adacore.com>
gcc/ada/
* libgnat/s-objrea.ads (Get_Memory_Bounds): Rename as Get_Xcode_Bounds.
(Object_Section): Rename Flag_Alloc component as Flag_Xcode.
* libgnat/s-objrea.adb (Get_Xcode_Bounds): Adjust to new subprogram and
component name.
(Get_Section, ELF case): Set Flag_Xcode from SHF_EXECINSTR.
* libgnat/s-dwalin.adb (Open): Adjust to the Get_Memory_Bounds name
change.
From-SVN: r260451
Symbolization of traceback entries from dwarf info is
failing in multiple cases for addresses originating from
shared libraries.
Part of the problem is a confusion across different functions
regarding the kind of "address" at hand, sometimes full process
runtime addresses (e.g. in traceback entries), sometimes module
relative (e.g. in dwarf info segments).
This change fixes this by introducing the use of distinct types
for the two kinds of addresses, resorting to System.Address
for runtime addresses and to Storage_Elements.Storage_Offset
for module relative values. The accompanying code changes
tidy a few places where we can now use standard operators
to combine offets & addresses, and include a few corrections
of consistency problems at spots where comparisons were done
between runtime addresses and relative offsets.
2018-05-21 Olivier Hainque <hainque@adacore.com>
gcc/ada/
* libgnat/s-dwalin.ads (Dwarf_Context): Change type of Load_Address to
Address, and type of Low, High to Storage_Offset.
(Low): Rename as Low_Address and convey that the return value is a
runtime reference accounting for a load address.
* libgnat/s-dwalin.adb (Read_Aranges_Entry): Adjust to the
address/offset type changes.
(Aranges_Lookup): Likewise.
(Symbolic_Address): Likewise.
(Symbolic_Traceback): Likewise.
(Dump_Cache): Likewise.
(Is_Inside): Likewise.
(Open): Likewise.
(Set_Load_Address): Likewise.
(Low_Address): Likewise, and account for C.Load_Address.
* libgnat/s-trasym__dwarf.adb (Lt): Use Low_Address instead of Low.
(Multi_Module_Symbolic_Traceback): Compare address in traceback
with module Low_Address instead of Low.
From-SVN: r260450
Load_Address is just more consistent with the overall use of the component.
2018-05-21 Olivier Hainque <hainque@adacore.com>
gcc/ada/
* libgnat/s-dwalin.ads (Dwarf_Context): Rename Load_Slide as
Load_Address.
* libgnat/s-dwalin.adb (Is_Inside): Adjust accordingly.
(Set_Load_Address): Likewise.
(Symbolic_Traceback): Likewise.
From-SVN: r260449
Symbolization of traceback addresses through shared libraries
requires information on the shared libraries load addresses, which
was at hand on Linuxbut not propagated through the runtime when
caching is enabled. This change fixes this.
2018-05-21 Olivier Hainque <hainque@adacore.com>
gcc/ada/
* libgnat/s-trasym__dwarf.adb (Add_Module_To_Cache): Expect a
Load_Address argument and pass it down to Init_Module.
* libgnat/s-tsmona__linux.adb (Build_Cache_For_All_Modules): Pass
lm.l_addr as the Load_Address to Add_Module_To_Cache.
From-SVN: r260448
This patch enforces what the comment for Has_Discriminant says:
-- Has_Discriminants (Flag5)
-- Defined in all types and subtypes.
to avoid semantically undefined calls on non-type entities. It also adapts
other routines to respect this comment.
No user-visible impact.
2018-05-21 Piotr Trojanek <trojanek@adacore.com>
gcc/ada/
* einfo.adb (Has_Discriminants): Stronger assertion.
(Set_Has_Discriminants): Stronger assertion.
* sem_ch13.adb (Push_Scope_And_Install_Discriminants): Adapt to respect
the stronger assertion on Has_Discriminant.
(Uninstall_Discriminants_And_Pop_Scope): Same as above.
* sem_util.adb (New_Copy_Tree): Same as above.
* sem_ch7.adb (Generate_Parent_References): Prevent calls to
Has_Discriminant on non-type entities that might happen when the
compiled code has errors.
* sem_ch3.adb (Derived_Type_Declaration): Only call
Set_Has_Discriminant on type entities.
From-SVN: r260447
This patch extends the legality of the GNAT attribute Scalar_Storage_Order,
to apply to formal private types. Previously this extension applied only
in GNAT_Mode, to support instantiations of Ada.Sequential_IO, but it is more
generally useful.
The following must compile quietly:
----
with Memory_View_Generic;
procedure Main is
type T is array (1..10) of integer;
package OK is new Memory_View_Generic (T);
type T2 is new Long_Float;
package Wrong is new Memory_View_Generic (T2);
begin
null;
end;
----
with System;
generic
type Source_Type is private;
package Memory_View_Generic is
-- various declarations ...
SSO : System.Bit_Order := Source_Type'Scalar_Storage_Order;
end Memory_View_Generic;
2018-05-21 Ed Schonberg <schonberg@adacore.com>
gcc/ada/
* sem_attr.adb (Analyze_Attribute, case Scalar_Storage_Order): The
attribute reference is legal within a generic unit when the prefix is a
formal private type.
From-SVN: r260444
This patch modifies the creation of transient scopes to eliminate potential
premature secondary stack reclamations when there is no suitable transient
context and the scope was intended to manage the secondary stack. Instead,
the logic was changed to accommodate a special case where an assignment with
suppressed controlled actions that appears within a type initialization
procedure requires secondary stack reclamation.
The patch also corrects the handling of function calls which utilize the
secondary stack in loop parameter specifications. Previously the predicate
which determined whether the function will utilize the secondary stack was
not accurate enough, and in certain cases could lead to leaks.
------------
-- Source --
------------
-- iterators.ads
package Iterators is
type Iterator is limited interface;
type Iterator_Access is access all Iterator'Class;
function Next
(I : in out Iterator;
Element : out Character) return Boolean is abstract;
procedure Iterate
(I : in out Iterator'Class;
Proc : access procedure (Element : Character));
end Iterators;
-- iterators.adb
package body Iterators is
procedure Iterate
(I : in out Iterator'Class;
Proc : access procedure (Element : Character))
is
Element : Character;
begin
while I.Next (Element) loop
Proc (Element);
end loop;
end Iterate;
end Iterators;
-- base.ads
with Iterators; use Iterators;
package Base is
type String_Access is access all String;
type Node is tagged record
S : String_Access;
end record;
type Node_Access is access all Node'Class;
type Node_Array is array (Positive range <>) of Node_Access;
function As_Array (N : Node_Access) return Node_Array;
function Get_String (C : Character) return String;
type Node_Iterator is limited new Iterator with record
Node : Node_Access;
I : Positive;
end record;
overriding function Next
(It : in out Node_Iterator;
Element : out Character) return Boolean;
function Constructor_1 (N : Node_Access) return Node_Iterator;
function Constructor_2 (N : Node_Access) return Node_Iterator;
end Base;
-- base.adb
package body Base is
function As_Array (N : Node_Access) return Node_Array is
begin
return (1 => N);
end As_Array;
function Get_String (C : Character) return String is
begin
return (1 .. 40 => C);
end Get_String;
function Next
(It : in out Node_Iterator;
Element : out Character) return Boolean
is
begin
if It.I > It.Node.S'Last then
return False;
else
It.I := It.I + 1;
Element := It.Node.S (It.I - 1);
return True;
end if;
end Next;
function Constructor_1 (N : Node_Access) return Node_Iterator is
begin
return Node_Iterator'(N, 1);
end Constructor_1;
function Constructor_2 (N : Node_Access) return Node_Iterator is
begin
return Constructor_1 (As_Array (N) (1));
end Constructor_2;
end Base;
-- main.adb
with Ada.Text_IO; use Ada.Text_IO;
with Base; use Base;
with Iterators; use Iterators;
procedure Main is
N : constant Node_Access := new Node'(S => new String'("hello world"));
procedure Process (C : Character) is
begin
Put_Line (Get_String (C));
end Process;
C : Iterator'Class := Constructor_2 (N);
begin
C.Iterate (Process'Access);
end Main;
----------------------------
-- Compilation and output --
----------------------------
$ gnatmake -q main.adb
$ ./main
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
llllllllllllllllllllllllllllllllllllllll
llllllllllllllllllllllllllllllllllllllll
oooooooooooooooooooooooooooooooooooooooo
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
oooooooooooooooooooooooooooooooooooooooo
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
llllllllllllllllllllllllllllllllllllllll
dddddddddddddddddddddddddddddddddddddddd
2018-05-21 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* exp_ch7.adb (Establish_Transient_Scope): Code cleanup. Do not
delegate the secondary stack management when there is no suitable
transient context, and the transient scope was intended to manage the
secondary stack because this causes premature reclamation. Change the
transient scope creation logic by special casing assignment statements
of controlled components for type initialization procedures.
(Find_Node_To_Be_Wrapped): Renamed to Find_Transient_Context. Update
the comment on usage.
(Find_Transient_Context): Change the initinte loop into a while loop.
Iterations schemes and iterator specifications are not valid transient
contexts because they rely on special processing. Assignment statements
are now treated as a normal transient context, special cases are
handled by the caller. Add special processing for pragma Check.
(Is_OK_Construct): Removed. Its functionality has been merged in
routine Find_Transient_Context.
* sem_ch5.adb (Check_Call): Reimplemented. Add code to properly
retrieve the subprogram being invoked. Use a more accurate predicate
(Requires_Transient_Scope) to determine that the function will emply
the secondary stack.
From-SVN: r260443
* src/filesystem/std-ops.cc (absolute): Report an error for empty
paths.
(weakly_canonical(const path&)): Do not call canonical on empty path.
(weakly_canonical(const path&, error_code&)): Likewise.
* testsuite/27_io/filesystem/operations/absolute.cc: Check for errors.
From-SVN: r260441
This patch implements the usadv16qi and ssadv16qi standard names.
See the thread at on gcc@gcc.gnu.org [1] for background.
The V16QImode variant is important to get right as it is the most commonly used pattern:
reducing vectors of bytes into an int.
The midend expects the optab to compute the absolute differences of operands 1 and 2 and
reduce them while widening along the way up to SImode. So the inputs are V16QImode and
the output is V4SImode.
I've tried out a few different strategies for that, the one I settled with is to emit:
UABDL2 tmp.8h, op1.16b, op2.16b
UABAL tmp.8h, op1.16b, op2.16b
UADALP op3.4s, tmp.8h
To work through the semantics let's say operands 1 and 2 are:
op1 { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 }
op2 { b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 }
op3 { c0, c1, c2, c3 }
The UABDL2 takes the upper V8QI elements, computes their absolute differences, widens them and stores them into the V8HImode tmp:
tmp { ABS(a[8]-b[8]), ABS(a[9]-b[9]), ABS(a[10]-b[10]), ABS(a[11]-b[11]), ABS(a[12]-b[12]), ABS(a[13]-b[13]), ABS(a[14]-b[14]), ABS(a[15]-b[15]) }
The UABAL after that takes the lower V8QI elements, computes their absolute differences, widens them and accumulates them into the V8HImode tmp from the previous step:
tmp { ABS(a[8]-b[8])+ABS (a[0]-b[0]), ABS(a[9]-b[9])+ABS(a[1]-b[1]), ABS(a[10]-b[10])+ABS(a[2]-b[2]), ABS(a[11]-b[11])+ABS(a[3]-b[3]), ABS(a[12]-b[12])+ABS(a[4]-b[4]), ABS(a[13]-b[13])+ABS(a[5]-b[5]), ABS(a[14]-b[14])+ABS(a[6]-b[6]), ABS(a[15]-b[15])+ABS(a[7]-b[7]) }
Finally the UADALP does a pairwise widening reduction and accumulation into the V4SImode op3:
op3 { c0+ABS(a[8]-b[8])+ABS(a[0]-b[0])+ABS(a[9]-b[9])+ABS(a[1]-b[1]), c1+ABS(a[10]-b[10])+ABS(a[2]-b[2])+ABS(a[11]-b[11])+ABS(a[3]-b[3]), c2+ABS(a[12]-b[12])+ABS(a[4]-b[4])+ABS(a[13]-b[13])+ABS(a[5]-b[5]), c3+ABS(a[14]-b[14])+ABS(a[6]-b[6])+ABS(a[15]-b[15])+ABS(a[7]-b[7]) }
(sorry for the text dump)
Remember, according to [1] the exact reduction sequence doesn't matter (for integer arithmetic at least).
I've considered other sequences as well (thanks Wilco), for example
* UABD + UADDLP + UADALP
* UABLD2 + UABDL + UADALP + UADALP
I ended up settling in the sequence in this patch as it's short (3 instructions) and in the future we can potentially
look to optimise multiple occurrences of these into something even faster (for example accumulating into H registers for longer
before doing a single UADALP in the end to accumulate into the final S register).
If your microarchitecture has some some strong preferences for a particular sequence, please let me know or, even better, propose a patch
to parametrise the generation sequence by code (or the appropriate RTX cost).
This expansion allows the vectoriser to avoid unpacking the bytes in two steps and performing V4SI arithmetic on them.
So, for the code:
unsigned char pix1[N], pix2[N];
int foo (void)
{
int i_sum = 0;
int i;
for (i = 0; i < 16; i++)
i_sum += __builtin_abs (pix1[i] - pix2[i]);
return i_sum;
}
we now generate on aarch64:
foo:
adrp x1, pix1
add x1, x1, :lo12:pix1
movi v0.4s, 0
adrp x0, pix2
add x0, x0, :lo12:pix2
ldr q2, [x1]
ldr q3, [x0]
uabdl2 v1.8h, v2.16b, v3.16b
uabal v1.8h, v2.8b, v3.8b
uadalp v0.4s, v1.8h
addv s0, v0.4s
umov w0, v0.s[0]
ret
instead of:
foo:
adrp x1, pix1
adrp x0, pix2
add x1, x1, :lo12:pix1
add x0, x0, :lo12:pix2
ldr q0, [x1]
ldr q4, [x0]
ushll v1.8h, v0.8b, 0
ushll2 v0.8h, v0.16b, 0
ushll v2.8h, v4.8b, 0
ushll2 v4.8h, v4.16b, 0
usubl v3.4s, v1.4h, v2.4h
usubl2 v1.4s, v1.8h, v2.8h
usubl v2.4s, v0.4h, v4.4h
usubl2 v0.4s, v0.8h, v4.8h
abs v3.4s, v3.4s
abs v1.4s, v1.4s
abs v2.4s, v2.4s
abs v0.4s, v0.4s
add v1.4s, v3.4s, v1.4s
add v1.4s, v2.4s, v1.4s
add v0.4s, v0.4s, v1.4s
addv s0, v0.4s
umov w0, v0.s[0]
ret
So I expect this new expansion to be better than the status quo in any case.
Bootstrapped and tested on aarch64-none-linux-gnu.
This gives about 8% on 525.x264_r from SPEC2017 on a Cortex-A72.
* config/aarch64/aarch64.md ("unspec"): Define UNSPEC_SABAL,
UNSPEC_SABDL2, UNSPEC_SADALP, UNSPEC_UABAL, UNSPEC_UABDL2,
UNSPEC_UADALP values.
* config/aarch64/iterators.md (ABAL): New int iterator.
(ABDL2): Likewise.
(ADALP): Likewise.
(sur): Add mappings for the above.
* config/aarch64/aarch64-simd.md (aarch64_<sur>abdl2<mode>_3):
New define_insn.
(aarch64_<sur>abal<mode>_4): Likewise.
(aarch64_<sur>adalp<mode>_3): Likewise.
(<sur>sadv16qi): New define_expand.
* gcc.c-torture/execute/ssad-run.c: New test.
* gcc.c-torture/execute/usad-run.c: Likewise.
* gcc.target/aarch64/ssadv16qi.c: Likewise.
* gcc.target/aarch64/usadv16qi.c: Likewise.
From-SVN: r260437
We used to build baremetal (AKA Elf32) multilibbed toolchains for years
now but never made that for Linux targets since there were problems with
uClibc n multilib setup. Now with help of Crosstool-NG it is finally
possible to create uClibc-based multilibbed toolchains and so we add
relevant CPUs for multilib in case of configuration for "arc*-*-linux*".
This will be essentially useful for glibc-based multilibbbed toolchains
in the future.
gcc/
2018-05-16 Alexey Brodkin <abrodkin@synopsys.com>
* config.gcc: Add arc/t-multilib-linux to tmake_file for
arc*-*-linux*.
* config/arc/t-multilib-linux: Specify MULTILIB_OPTIONS and
MULTILIB_DIRNAMES
From-SVN: r260434
Janus Weil
Paolo Carlini
Vladimir Mezentsev
Steven G. Kargl
Jonathan Wakely
François Dumont
Kyrylo Tkachov
Pierre-Marie de Rodat
Ed Schonberg
Daniel Mercier
Hristian Kirtchev
Jerome Lambourg
Javier Miranda
Doug Rupp
Jose Ruiz
Piotr Trojanek
Yannick Moy
Olivier Hainque
Arnaud Charlet
Kyrylo Tkachov
Alexander Nesterovskiy
Tamar Christina
Alexey Brodkin
Jason Merrill
GCC Administrator