Patchwork [Ada] Remove overzealous warnings about Asm statements

login
register
mail settings
Submitter Arnaud Charlet
Date Aug. 29, 2011, 8:33 a.m.
Message ID <20110829083305.GA31932@adacore.com>
Download mbox | patch
Permalink /patch/111976/
State New
Headers show

Comments

Arnaud Charlet - Aug. 29, 2011, 8:33 a.m.
Do not warn for multiple consecutive Asm statements. The warning was intended
to prevent a common case where users expect such consecutive statements to
be listed in order in the code as given, withotu specifying necessary input
and output constraints.

However, since we now warn about missing input and output parameters if no
explicit setting for Volatile is given, the warning for consecutive Asms
would mostly be given for uses that were in fact correct. The advice given
to make the asm statements volatile is misleading in that case, so it is
better to not give the warning altogether.

The following should compile silently on Alpha:

   pragma Extend_System (Aux_DEC);
   with Machine_Code; use Machine_Code;
   with System; use System;
   function Neg_F (X : F_Float) return F_Float is
      type S is digits 6;
      pragma Float_Representation (IEEE_Float, S);

      A, B : S;
      C    : F_Float;
   begin
      Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F_Float'Asm_Input ("m", X));
      Asm ("subf $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A));
      Asm ("stf %1,%0", F_Float'Asm_Output ("=m", C), S'Asm_Input ("f", B));
      return C;
   end Neg_F;

Tested on x86_64-pc-linux-gnu, committed on trunk

2011-08-29  Geert Bosch  <bosch@adacore.com>

	* sem_warn.adb (Check_Code_Statement): Remove check for consecutive Asm
	statements.
	* s-vaflop-vms-alpha.adb: Remove bogus Volatile => True arguments from
	Asm statements.

Patch

Index: sem_warn.adb
===================================================================
--- sem_warn.adb	(revision 178155)
+++ sem_warn.adb	(working copy)
@@ -211,18 +211,6 @@ 
            ("?code statement with no outputs should usually be Volatile!", N);
          return;
       end if;
-
-      --  Check multiple code statements in a row
-
-      if Is_List_Member (N)
-        and then Present (Prev (N))
-        and then Nkind (Prev (N)) = N_Code_Statement
-      then
-         Error_Msg_F
-           ("?code statements in sequence should usually be Volatile!", N);
-         Error_Msg_F
-           ("\?(suggest using template with multiple instructions)!", N);
-      end if;
    end Check_Code_Statement;
 
    ---------------------------------
Index: s-vaflop-vms-alpha.adb
===================================================================
--- s-vaflop-vms-alpha.adb	(revision 178155)
+++ s-vaflop-vms-alpha.adb	(working copy)
@@ -6,7 +6,7 @@ 
 --                                                                          --
 --                                 B o d y                                  --
 --                                                                          --
---          Copyright (C) 1997-2009, Free Software Foundation, Inc.         --
+--          Copyright (C) 1997-2011, Free Software Foundation, Inc.         --
 --                       (Version for Alpha OpenVMS)                        --
 --                                                                          --
 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
@@ -67,12 +67,9 @@ 
       A, B : T;
       C    : G;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), D'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtdg %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), D'Asm_Input ("m", X));
+      Asm ("cvtdg %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end D_To_G;
 
@@ -84,10 +81,8 @@ 
       A : T;
       B : G;
    begin
-      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end F_To_G;
 
@@ -103,8 +98,7 @@ 
       --  Because converting to a wider FP format is a no-op, we say
       --  A is 64-bit even though we are loading 32 bits into it.
 
-      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
+      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X));
 
       B := S (Cvt_G_T (A));
       return B;
@@ -118,12 +112,9 @@ 
       A, B : T;
       C    : D;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgd %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", D'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgd %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", D'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end G_To_D;
 
@@ -136,12 +127,9 @@ 
       B : S;
       C : F;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgf %1,%0", S'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgf %1,%0", S'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end G_To_F;
 
@@ -153,10 +141,8 @@ 
       A : T;
       B : Q;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgq %1,%0", Q'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgq %1,%0", Q'Asm_Output ("=f", B), T'Asm_Input ("f", A));
       return B;
    end G_To_Q;
 
@@ -167,8 +153,7 @@ 
    function G_To_T (X : G) return T is
       A, B : T;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
       B := Cvt_G_T (A);
       return B;
    end G_To_T;
@@ -190,10 +175,8 @@ 
       A : S;
       B : F;
    begin
-      Asm ("cvtqf %1,%0", S'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("cvtqf %1,%0", S'Asm_Output ("=f", A), Q'Asm_Input ("f", X));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A));
       return B;
    end Q_To_F;
 
@@ -205,10 +188,8 @@ 
       A : T;
       B : G;
    begin
-      Asm ("cvtqg %1,%0", T'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("cvtqg %1,%0", T'Asm_Output ("=f", A), Q'Asm_Input ("f", X));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end Q_To_G;
 
@@ -221,8 +202,7 @@ 
       B : F;
    begin
       A := Cvt_T_F (T (X));
-      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A));
       return B;
    end S_To_F;
 
@@ -244,8 +224,7 @@ 
       B : G;
    begin
       A := Cvt_T_G (X);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end T_To_G;
 
@@ -257,12 +236,9 @@ 
       A, B : S;
       C    : F;
    begin
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cpys $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X));
+      Asm ("cpys $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end Abs_F;
 
@@ -275,10 +251,8 @@ 
       C    : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
-      Asm ("cpys $f31,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpys $f31,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end Abs_G;
 
@@ -291,13 +265,10 @@ 
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("addf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Add_F;
 
@@ -310,13 +281,10 @@ 
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("addg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Add_G;
 
@@ -392,13 +360,10 @@ 
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("divf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Div_F;
 
@@ -411,13 +376,10 @@ 
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("divg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Div_G;
 
@@ -429,11 +391,9 @@ 
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Eq_F;
 
@@ -445,11 +405,9 @@ 
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Eq_G;
 
@@ -461,11 +419,9 @@ 
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgle %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Le_F;
 
@@ -477,11 +433,9 @@ 
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgle %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Le_G;
 
@@ -493,11 +447,9 @@ 
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpglt %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Lt_F;
 
@@ -509,11 +461,9 @@ 
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpglt %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Lt_G;
 
@@ -526,13 +476,10 @@ 
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("mulf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Mul_F;
 
@@ -545,13 +492,10 @@ 
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("mulg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Mul_G;
 
@@ -563,11 +507,9 @@ 
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R = 0.0;
    end Ne_F;
 
@@ -579,11 +521,9 @@ 
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R = 0.0;
    end Ne_G;
 
@@ -596,10 +536,8 @@ 
       C    : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X));
-      Asm ("cpysn %1,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpysn %1,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end Neg_F;
 
@@ -612,10 +550,8 @@ 
       C    : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
-      Asm ("cpysn %1,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpysn %1,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end Neg_G;
 
@@ -652,13 +588,11 @@ 
 
    function Return_D (X : D) return D is
       R : D;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("cvtdg $f0,$f0", Inputs => D'Asm_Input ("g", X), Clobber => "$f0",
-           Volatile => True);
+        Volatile => True);
       Asm ("stg $f0,%0", D'Asm_Output ("=m", R), Volatile => True);
       return R;
    end Return_D;
@@ -669,13 +603,11 @@ 
 
    function Return_F (X : F) return F is
       R : F;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("stf $f0,%0", F'Asm_Output ("=m", R), F'Asm_Input ("g", X),
-           Clobber => "$f0", Volatile => True);
+        Clobber => "$f0", Volatile => True);
       return R;
    end Return_F;
 
@@ -685,13 +617,11 @@ 
 
    function Return_G (X : G) return G is
       R : G;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("stg $f0,%0", G'Asm_Output ("=m", R), G'Asm_Input ("g", X),
-           Clobber => "$f0", Volatile => True);
+        Clobber => "$f0", Volatile => True);
       return R;
    end Return_G;
 
@@ -705,13 +635,10 @@ 
 
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("subf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Sub_F;
 
@@ -724,13 +651,10 @@ 
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("subg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Sub_G;