gcc/ada/xoscons.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                          GNAT SYSTEM UTILITIES                           --
   4 --                                                                          --
   5 --                              X O S C O N S                               --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 2008-2016, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 --  The base name of the template file is given by Argument (1). This program
  27 --  generates the spec for this specified unit (let's call it UNIT_NAME).
  28
  29 --  It works in conjunction with a C template file which must be pre-processed
  30 --  and compiled using the cross compiler. Two input files are used:
  31 --    - the preprocessed C file: UNIT_NAME-tmplt.i
  32 --    - the generated assembly file: UNIT_NAME-tmplt.s
  33
  34 --  The generated files are UNIT_NAME.ads and UNIT_NAME.h
  35
  36 with Ada.Characters.Handling;    use Ada.Characters.Handling;
  37 with Ada.Command_Line;           use Ada.Command_Line;
  38 with Ada.Exceptions;             use Ada.Exceptions;
  39 with Ada.Streams.Stream_IO;      use Ada.Streams.Stream_IO;
  40 with Ada.Strings.Fixed;          use Ada.Strings.Fixed;
  41 with Ada.Strings.Maps;           use Ada.Strings.Maps;
  42 with Ada.Strings.Maps.Constants; use Ada.Strings.Maps.Constants;
  43 with Ada.Text_IO;                use Ada.Text_IO;
  44
  45 pragma Warnings (Off);
  46 --  System.Unsigned_Types is an internal GNAT unit
  47 with System.Unsigned_Types;   use System.Unsigned_Types;
  48 pragma Warnings (On);
  49
  50 with GNAT.OS_Lib;
  51 with GNAT.String_Split; use GNAT.String_Split;
  52 with GNAT.Table;
  53
  54 with XUtil; use XUtil;
  55
  56 procedure XOSCons is
  57
  58    use Ada.Strings;
  59
  60    Unit_Name : constant String := Argument (1);
  61    Tmpl_Name : constant String := Unit_Name & "-tmplt";
  62
  63    -------------------------------------------------
  64    -- Information retrieved from assembly listing --
  65    -------------------------------------------------
  66
  67    type String_Access is access all String;
  68    --  Note: we can't use GNAT.Strings for this definition, since that unit
  69    --  is not available in older base compilers.
  70
  71    --  We need to deal with integer values that can be signed or unsigned, so
  72    --  we need to accommodate the maximum range of both cases.
  73
  74    type Int_Value_Type is record
  75       Positive  : Boolean;
  76       Abs_Value : Long_Unsigned := 0;
  77    end record;
  78
  79    function ">" (V1, V2 : Int_Value_Type) return Boolean;
  80    function "<" (V1, V2 : Int_Value_Type) return Boolean;
  81
  82    type Asm_Info_Kind is
  83      (CND,     --  Named number (decimal)
  84       CNU,     --  Named number (decimal, unsigned)
  85       CNS,     --  Named number (freeform text)
  86       C,       --  Constant object
  87       SUB,     --  Subtype
  88       TXT);    --  Literal text
  89    --  Recognized markers found in assembly file. These markers are produced by
  90    --  the same-named macros from the C template.
  91
  92    subtype Asm_Int_Kind is Asm_Info_Kind range CND .. CNU;
  93    --  Asm_Info_Kind values with int values in input
  94
  95    subtype Named_Number is Asm_Info_Kind range CND .. CNS;
  96    --  Asm_Info_Kind values with named numbers in output
  97
  98    type Asm_Info (Kind : Asm_Info_Kind := TXT) is record
  99       Line_Number   : Integer;
 100       --  Line number in C source file
 101
 102       Constant_Name : String_Access;
 103       --  Name of constant to be defined
 104
 105       Constant_Type : String_Access;
 106       --  Type of constant (case of Kind = C)
 107
 108       Value_Len     : Natural := 0;
 109       --  Length of text representation of constant's value
 110
 111       Text_Value    : String_Access;
 112       --  Value for CNS / C constant
 113
 114       Int_Value     : Int_Value_Type;
 115       --  Value for CND / CNU constant
 116
 117       Comment       : String_Access;
 118       --  Additional descriptive comment for constant, or free-form text (TXT)
 119    end record;
 120
 121    package Asm_Infos is new GNAT.Table
 122      (Table_Component_Type => Asm_Info,
 123       Table_Index_Type     => Integer,
 124       Table_Low_Bound      => 1,
 125       Table_Initial        => 100,
 126       Table_Increment      => 10);
 127
 128    Max_Constant_Name_Len  : Natural := 0;
 129    Max_Constant_Value_Len : Natural := 0;
 130    Max_Constant_Type_Len  : Natural := 0;
 131    --  Lengths of longest name and longest value
 132
 133    Size_Of_Unsigned_Int : Integer := 0;
 134    --  Size of unsigned int on target
 135
 136    type Language is (Lang_Ada, Lang_C);
 137
 138    function Parse_Int (S : String; K : Asm_Int_Kind) return Int_Value_Type;
 139    --  Parse a decimal number, preceded by an optional '$' or '#' character,
 140    --  and return its value.
 141
 142    procedure Output_Info
 143      (Lang       : Language;
 144       OFile      : Sfile;
 145       Info_Index : Integer);
 146    --  Output information from the indicated asm info line
 147
 148    procedure Parse_Asm_Line (Line : String);
 149    --  Parse one information line from the assembly source
 150
 151    function Contains_Template_Name (S : String) return Boolean;
 152    --  True if S contains Tmpl_Name, possibly with different casing
 153
 154    function Spaces (Count : Integer) return String;
 155    --  If Count is positive, return a string of Count spaces, else return an
 156    --  empty string.
 157
 158    ---------
 159    -- ">" --
 160    ---------
 161
 162    function ">" (V1, V2 : Int_Value_Type) return Boolean is
 163       P1 : Boolean renames V1.Positive;
 164       P2 : Boolean renames V2.Positive;
 165       A1 : Long_Unsigned renames V1.Abs_Value;
 166       A2 : Long_Unsigned renames V2.Abs_Value;
 167    begin
 168       return (P1 and then not P2)
 169         or else (P1 and then P2 and then A1 > A2)
 170         or else (not P1 and then not P2 and then A1 < A2);
 171    end ">";
 172
 173    ---------
 174    -- "<" --
 175    ---------
 176
 177    function "<" (V1, V2 : Int_Value_Type) return Boolean is
 178    begin
 179       return not (V1 > V2) and then not (V1 = V2);
 180    end "<";
 181
 182    ----------------------------
 183    -- Contains_Template_Name --
 184    ----------------------------
 185
 186    function Contains_Template_Name (S : String) return Boolean is
 187    begin
 188       if Index (Source => To_Lower (S), Pattern => Tmpl_Name) > 0 then
 189          return True;
 190       else
 191          return False;
 192       end if;
 193    end Contains_Template_Name;
 194
 195    -----------------
 196    -- Output_Info --
 197    -----------------
 198
 199    procedure Output_Info
 200      (Lang       : Language;
 201       OFile      : Sfile;
 202       Info_Index : Integer)
 203    is
 204       Info : Asm_Info renames Asm_Infos.Table (Info_Index);
 205
 206       procedure Put (S : String);
 207       --  Write S to OFile
 208
 209       ---------
 210       -- Put --
 211       ---------
 212
 213       procedure Put (S : String) is
 214       begin
 215          Put (OFile, S);
 216       end Put;
 217
 218    --  Start of processing for Output_Info
 219
 220    begin
 221       case Info.Kind is
 222          when TXT =>
 223
 224             --  Handled in the common code for comments below
 225
 226             null;
 227
 228          when SUB =>
 229             case Lang is
 230                when Lang_Ada =>
 231                   Put ("   subtype " & Info.Constant_Name.all
 232                        & " is Interfaces.C."
 233                        & Info.Text_Value.all & ";");
 234                when Lang_C =>
 235                   Put ("#define " & Info.Constant_Name.all & " "
 236                        & Info.Text_Value.all);
 237             end case;
 238
 239          when others =>
 240
 241             --  All named number cases
 242
 243             case Lang is
 244                when Lang_Ada =>
 245                   Put ("   " & Info.Constant_Name.all);
 246                   Put (Spaces (Max_Constant_Name_Len
 247                                  - Info.Constant_Name'Length));
 248
 249                   if Info.Kind in Named_Number then
 250                      Put (" : constant := ");
 251                   else
 252                      Put (" : constant " & Info.Constant_Type.all);
 253                      Put (Spaces (Max_Constant_Type_Len
 254                                     - Info.Constant_Type'Length));
 255                      Put (" := ");
 256                   end if;
 257
 258                when Lang_C =>
 259                   Put ("#define " & Info.Constant_Name.all & " ");
 260                   Put (Spaces (Max_Constant_Name_Len
 261                                  - Info.Constant_Name'Length));
 262             end case;
 263
 264             if Info.Kind in Asm_Int_Kind then
 265                if not Info.Int_Value.Positive then
 266                   Put ("-");
 267                end if;
 268
 269                Put (Trim (Info.Int_Value.Abs_Value'Img, Side => Left));
 270
 271             else
 272                declare
 273                   Is_String : constant Boolean :=
 274                                 Info.Kind = C
 275                                   and then Info.Constant_Type.all = "String";
 276
 277                begin
 278                   if Is_String then
 279                      Put ("""");
 280                   end if;
 281
 282                   Put (Info.Text_Value.all);
 283
 284                   if Is_String then
 285                      Put ("""");
 286                   end if;
 287                end;
 288             end if;
 289
 290             if Lang = Lang_Ada then
 291                Put (";");
 292
 293                if Info.Comment'Length > 0 then
 294                   Put (Spaces (Max_Constant_Value_Len - Info.Value_Len));
 295                   Put (" --  ");
 296                end if;
 297             end if;
 298       end case;
 299
 300       if Lang = Lang_Ada then
 301          Put (Info.Comment.all);
 302       end if;
 303
 304       New_Line (OFile);
 305    end Output_Info;
 306
 307    --------------------
 308    -- Parse_Asm_Line --
 309    --------------------
 310
 311    procedure Parse_Asm_Line (Line : String) is
 312       Index1, Index2 : Integer := Line'First;
 313
 314       function Field_Alloc return String_Access;
 315       --  Allocate and return a copy of Line (Index1 .. Index2 - 1)
 316
 317       procedure Find_Colon (Index : in out Integer);
 318       --  Increment Index until the next colon in Line
 319
 320       -----------------
 321       -- Field_Alloc --
 322       -----------------
 323
 324       function Field_Alloc return String_Access is
 325       begin
 326          return new String'(Line (Index1 .. Index2 - 1));
 327       end Field_Alloc;
 328
 329       ----------------
 330       -- Find_Colon --
 331       ----------------
 332
 333       procedure Find_Colon (Index : in out Integer) is
 334       begin
 335          loop
 336             Index := Index + 1;
 337             exit when Index > Line'Last or else Line (Index) = ':';
 338          end loop;
 339       end Find_Colon;
 340
 341    --  Start of processing for Parse_Asm_Line
 342
 343    begin
 344       Find_Colon (Index2);
 345
 346       declare
 347          Info : Asm_Info (Kind => Asm_Info_Kind'Value
 348                                     (Line (Line'First .. Index2 - 1)));
 349       begin
 350          Index1 := Index2 + 1;
 351          Find_Colon (Index2);
 352
 353          Info.Line_Number :=
 354            Integer (Parse_Int (Line (Index1 .. Index2 - 1), CNU).Abs_Value);
 355
 356          case Info.Kind is
 357             when C
 358                | CND
 359                | CNS
 360                | CNU
 361                | SUB
 362             =>
 363                Index1 := Index2 + 1;
 364                Find_Colon (Index2);
 365
 366                Info.Constant_Name := Field_Alloc;
 367
 368                if Info.Kind /= SUB
 369                     and then
 370                   Info.Constant_Name'Length > Max_Constant_Name_Len
 371                then
 372                   Max_Constant_Name_Len := Info.Constant_Name'Length;
 373                end if;
 374
 375                Index1 := Index2 + 1;
 376                Find_Colon (Index2);
 377
 378                if Info.Kind = C then
 379                   Info.Constant_Type := Field_Alloc;
 380
 381                   if Info.Constant_Type'Length > Max_Constant_Type_Len then
 382                      Max_Constant_Type_Len := Info.Constant_Type'Length;
 383                   end if;
 384
 385                   Index1 := Index2 + 1;
 386                   Find_Colon (Index2);
 387                end if;
 388
 389                if Info.Kind = CND or else Info.Kind = CNU then
 390                   Info.Int_Value :=
 391                     Parse_Int (Line (Index1 .. Index2 - 1), Info.Kind);
 392                   Info.Value_Len := Info.Int_Value.Abs_Value'Img'Length - 1;
 393
 394                   if not Info.Int_Value.Positive then
 395                      Info.Value_Len := Info.Value_Len + 1;
 396                   end if;
 397
 398                else
 399                   Info.Text_Value := Field_Alloc;
 400                   Info.Value_Len  := Info.Text_Value'Length;
 401                end if;
 402
 403                if Info.Constant_Name.all = "SIZEOF_unsigned_int" then
 404                   Size_Of_Unsigned_Int :=
 405                     8 * Integer (Info.Int_Value.Abs_Value);
 406                end if;
 407
 408             when others =>
 409                null;
 410          end case;
 411
 412          Index1 := Index2 + 1;
 413          Index2 := Line'Last + 1;
 414          Info.Comment := Field_Alloc;
 415
 416          if Info.Kind = TXT then
 417             Info.Text_Value := Info.Comment;
 418
 419          --  Update Max_Constant_Value_Len, but only if this constant has a
 420          --  comment (else the value is allowed to be longer).
 421
 422          elsif Info.Comment'Length > 0 then
 423             if Info.Value_Len > Max_Constant_Value_Len then
 424                Max_Constant_Value_Len := Info.Value_Len;
 425             end if;
 426          end if;
 427
 428          Asm_Infos.Append (Info);
 429       end;
 430
 431    exception
 432       when E : others =>
 433          Put_Line
 434            (Standard_Error, "can't parse " & Line);
 435          Put_Line
 436            (Standard_Error, "exception raised: " & Exception_Information (E));
 437    end Parse_Asm_Line;
 438
 439    ----------------
 440    -- Parse_Cond --
 441    ----------------
 442
 443    procedure Parse_Cond
 444      (If_Line            : String;
 445       Cond               : Boolean;
 446       Tmpl_File          : Ada.Text_IO.File_Type;
 447       Ada_Ofile, C_Ofile : Sfile;
 448       Current_Line       : in out Integer)
 449    is
 450       function Get_Value (Name : String) return Int_Value_Type;
 451       --  Returns the value of the variable Name
 452
 453       ---------------
 454       -- Get_Value --
 455       ---------------
 456
 457       function Get_Value (Name : String) return Int_Value_Type is
 458       begin
 459          if Is_Subset (To_Set (Name), Decimal_Digit_Set) then
 460             return Parse_Int (Name, CND);
 461
 462          else
 463             for K in 1 .. Asm_Infos.Last loop
 464                if Asm_Infos.Table (K).Constant_Name /= null then
 465                   if Name = Asm_Infos.Table (K).Constant_Name.all then
 466                      return Asm_Infos.Table (K).Int_Value;
 467                   end if;
 468                end if;
 469             end loop;
 470
 471             --  Not found returns 0
 472
 473             return (True, 0);
 474          end if;
 475       end Get_Value;
 476
 477       --  Local variables
 478
 479       Sline  : Slice_Set;
 480       Line   : String (1 .. 256);
 481       Last   : Integer;
 482       Value1 : Int_Value_Type;
 483       Value2 : Int_Value_Type;
 484       Res    : Boolean;
 485
 486    --  Start of processing for Parse_Cond
 487
 488    begin
 489       Create (Sline, If_Line, " ");
 490
 491       if Slice_Count (Sline) /= 4 then
 492          Put_Line (Standard_Error, "can't parse " & If_Line);
 493       end if;
 494
 495       Value1 := Get_Value (Slice (Sline, 2));
 496       Value2 := Get_Value (Slice (Sline, 4));
 497
 498       if Slice (Sline, 3) = ">" then
 499          Res := Cond and (Value1 > Value2);
 500
 501       elsif Slice (Sline, 3) = "<" then
 502          Res := Cond and (Value1 < Value2);
 503
 504       elsif Slice (Sline, 3) = "=" then
 505          Res := Cond and (Value1 = Value2);
 506
 507       elsif Slice (Sline, 3) = "/=" then
 508          Res := Cond and (Value1 /= Value2);
 509
 510       else
 511          --  No other operator can be used
 512
 513          Put_Line (Standard_Error, "unknown operator in " & If_Line);
 514          Res := False;
 515       end if;
 516
 517       Current_Line := Current_Line + 1;
 518
 519       loop
 520          Get_Line (Tmpl_File, Line, Last);
 521          Current_Line := Current_Line + 1;
 522          exit when Line (1 .. Last) = "@END_IF";
 523
 524          if Last > 4 and then Line (1 .. 4) = "@IF " then
 525             Parse_Cond
 526               (Line (1 .. Last), Res,
 527                Tmpl_File, Ada_Ofile, C_Ofile, Current_Line);
 528
 529          elsif Line (1 .. Last) = "@ELSE" then
 530             Res := Cond and not Res;
 531
 532          elsif Res then
 533             Put_Line (Ada_OFile, Line (1 .. Last));
 534             Put_Line (C_OFile, Line (1 .. Last));
 535          end if;
 536       end loop;
 537    end Parse_Cond;
 538
 539    ---------------
 540    -- Parse_Int --
 541    ---------------
 542
 543    function Parse_Int
 544      (S : String;
 545       K : Asm_Int_Kind) return Int_Value_Type
 546    is
 547       First  : Integer := S'First;
 548       Result : Int_Value_Type;
 549
 550    begin
 551       --  On some platforms, immediate integer values are prefixed with
 552       --  a $ or # character in assembly output.
 553
 554       if S (First) = '$' or else S (First) = '#' then
 555          First := First + 1;
 556       end if;
 557
 558       if S (First) = '-' then
 559          Result.Positive := False;
 560          First := First + 1;
 561       else
 562          Result.Positive := True;
 563       end if;
 564
 565       Result.Abs_Value := Long_Unsigned'Value (S (First .. S'Last));
 566
 567       if not Result.Positive and then K = CNU then
 568
 569          --  Negative value, but unsigned expected: take 2's complement
 570          --  reciprocical value.
 571
 572          Result.Abs_Value := ((not Result.Abs_Value) + 1)
 573                                and
 574                              (Shift_Left (1, Size_Of_Unsigned_Int) - 1);
 575          Result.Positive  := True;
 576       end if;
 577
 578       return Result;
 579
 580    exception
 581       when others =>
 582          Put_Line (Standard_Error, "can't parse decimal value: " & S);
 583          raise;
 584    end Parse_Int;
 585
 586    ------------
 587    -- Spaces --
 588    ------------
 589
 590    function Spaces (Count : Integer) return String is
 591    begin
 592       if Count <= 0 then
 593          return "";
 594       else
 595          return (1 .. Count => ' ');
 596       end if;
 597    end Spaces;
 598
 599    --  Local declarations
 600
 601    --  Input files
 602
 603    Tmpl_File_Name : constant String := Tmpl_Name & ".i";
 604    Asm_File_Name  : constant String := Tmpl_Name & ".s";
 605
 606    --  Output files
 607
 608    Ada_File_Name : constant String := Unit_Name & ".ads";
 609    C_File_Name   : constant String := Unit_Name & ".h";
 610
 611    Asm_File  : Ada.Text_IO.File_Type;
 612    Tmpl_File : Ada.Text_IO.File_Type;
 613    Ada_OFile : Sfile;
 614    C_OFile   : Sfile;
 615
 616    Line : String (1 .. 256);
 617    Last : Integer;
 618    --  Line being processed
 619
 620    Current_Line : Integer;
 621    Current_Info : Integer;
 622    In_Comment   : Boolean;
 623    In_Template  : Boolean;
 624
 625 --  Start of processing for XOSCons
 626
 627 begin
 628    --  Load values from assembly file
 629
 630    Open (Asm_File, In_File, Asm_File_Name);
 631    while not End_Of_File (Asm_File) loop
 632       Get_Line (Asm_File, Line, Last);
 633       if Last > 2 and then Line (1 .. 2) = "->" then
 634          Parse_Asm_Line (Line (3 .. Last));
 635       end if;
 636    end loop;
 637
 638    Close (Asm_File);
 639
 640    --  Load C template and output definitions
 641
 642    Open   (Tmpl_File, In_File,  Tmpl_File_Name);
 643    Create (Ada_OFile, Out_File, Ada_File_Name);
 644    Create (C_OFile,   Out_File, C_File_Name);
 645
 646    Current_Line := 0;
 647    Current_Info := Asm_Infos.First;
 648    In_Comment   := False;
 649
 650    while not End_Of_File (Tmpl_File) loop
 651       <<Get_One_Line>>
 652       Get_Line (Tmpl_File, Line, Last);
 653
 654       if Last >= 2 and then Line (1 .. 2) = "# " then
 655          declare
 656             Index : Integer;
 657
 658          begin
 659             Index := 3;
 660             while Index <= Last and then Line (Index) in '0' .. '9' loop
 661                Index := Index + 1;
 662             end loop;
 663
 664             if Contains_Template_Name (Line (Index + 1 .. Last)) then
 665                Current_Line := Integer'Value (Line (3 .. Index - 1));
 666                In_Template  := True;
 667                goto Get_One_Line;
 668             else
 669                In_Template := False;
 670             end if;
 671          end;
 672
 673       elsif In_Template then
 674          if In_Comment then
 675             if Line (1 .. Last) = "*/" then
 676                Put_Line (C_OFile, Line (1 .. Last));
 677                In_Comment := False;
 678
 679             elsif Last > 4 and then Line (1 .. 4) = "@IF " then
 680                Parse_Cond
 681                  (Line (1 .. Last), True,
 682                   Tmpl_File, Ada_Ofile, C_Ofile, Current_Line);
 683
 684             else
 685                Put_Line (Ada_OFile, Line (1 .. Last));
 686                Put_Line (C_OFile, Line (1 .. Last));
 687             end if;
 688
 689          elsif Line (1 .. Last) = "/*" then
 690             Put_Line (C_OFile, Line (1 .. Last));
 691             In_Comment := True;
 692
 693          elsif Asm_Infos.Table (Current_Info).Line_Number = Current_Line then
 694             if Fixed.Index (Line, "/*NOGEN*/") = 0 then
 695                Output_Info (Lang_Ada, Ada_OFile, Current_Info);
 696                Output_Info (Lang_C,   C_OFile,   Current_Info);
 697             end if;
 698
 699             Current_Info := Current_Info + 1;
 700          end if;
 701
 702          Current_Line := Current_Line + 1;
 703       end if;
 704    end loop;
 705
 706    Close (Tmpl_File);
 707
 708 exception
 709    when E : others =>
 710       Put_Line ("raised " & Ada.Exceptions.Exception_Information (E));
 711       GNAT.OS_Lib.OS_Exit (1);
 712 end XOSCons;