1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- V X A D D R 2 L I N E --
9 -- Copyright (C) 2002-2018, AdaCore --
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. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- This program is meant to be used with vxworks to compute symbolic
27 -- backtraces on the host from non-symbolic backtraces obtained on the target.
29 -- The basic idea is to automate the computation of the necessary address
30 -- adjustments prior to calling addr2line when the application has only been
31 -- partially linked on the host.
33 -- Variants for various targets are supported, and the command line should
36 -- <target>-addr2line [-a <target_arch>] <exe_file> <ref_address>
37 -- <backtrace addresses>
41 -- selects the target architecture. In the absence of this parameter the
42 -- default variant is chosen based on the Detect_Arch result. Generally,
43 -- this parameter will only be used if vxaddr2line is recompiled manually.
44 -- Otherwise, the command name will always be of the form:
45 -- <target>-vxaddr2line
46 -- where there is no ambiguity on the target's architecture.
49 -- The name of the partially linked binary file for the application.
52 -- Runtime address (on the target) of a reference symbol you choose. This
53 -- name must match the value of the Ref_Symbol variable declared below.
54 -- A symbol with a small offset from the beginning of the text segment is
55 -- better, so "adainit" is a good choice.
57 -- <backtrace addresses> :
58 -- The call chain addresses you obtained at run time on the target and
59 -- for which you want a symbolic association.
61 -- TO ADD A NEW ARCHITECTURE add an appropriate value to Architecture type
62 -- (in a format <host>_<target>), and then an appropriate value to Config_List
65 with Ada
.Text_IO
; use Ada
.Text_IO
;
66 with Ada
.Command_Line
; use Ada
.Command_Line
;
67 with Ada
.Strings
.Fixed
; use Ada
.Strings
.Fixed
;
68 with Interfaces
; use Interfaces
;
70 with GNAT
.OS_Lib
; use GNAT
.OS_Lib
;
71 with GNAT
.Directory_Operations
; use GNAT
.Directory_Operations
;
72 with GNAT
.Expect
; use GNAT
.Expect
;
73 with GNAT
.Regpat
; use GNAT
.Regpat
;
75 procedure VxAddr2Line
is
77 package Unsigned_64_IO
is new Modular_IO
(Unsigned_64
);
78 -- Instantiate Modular_IO to have Put
80 Ref_Symbol
: constant String := "adainit";
81 -- This is the name of the reference symbol whose runtime address must
82 -- be provided as the <ref_address> argument.
84 -- All supported architectures
101 type Arch_Record
is record
102 Addr2line_Binary
: String_Access
;
103 -- Name of the addr2line utility to use
105 Nm_Binary
: String_Access
;
106 -- Name of the host nm utility, which will be used to find out the
107 -- offset of the reference symbol in the text segment of the partially
108 -- linked executable.
110 Addr_Digits_To_Skip
: Integer;
111 -- When addresses such as 0xfffffc0001dfed50 are provided, for instance
112 -- on ALPHA, indicate the number of leading digits that can be ignored,
113 -- which will avoid computational overflows. Typically only useful when
114 -- 64bit addresses are provided.
116 Bt_Offset_From_Call
: Unsigned_64
;
117 -- Offset from a backtrace address to the address of the corresponding
118 -- call instruction. This should always be 0, except on platforms where
119 -- the backtrace addresses actually correspond to return and not call
120 -- points. In such cases, a negative value is most likely.
123 -- Configuration for each of the architectures
124 Arch_List
: array (Architecture
'Range) of Arch_Record
:=
126 (Addr2line_Binary
=> null,
128 Addr_Digits_To_Skip
=> 0,
129 Bt_Offset_From_Call
=> -2),
131 (Addr2line_Binary
=> null,
133 Addr_Digits_To_Skip
=> 0,
134 Bt_Offset_From_Call
=> -2),
136 (Addr2line_Binary
=> null,
138 Addr_Digits_To_Skip
=> 0,
139 Bt_Offset_From_Call
=> -4),
141 (Addr2line_Binary
=> null,
143 Addr_Digits_To_Skip
=> 0,
144 Bt_Offset_From_Call
=> -2),
146 (Addr2line_Binary
=> null,
148 Addr_Digits_To_Skip
=> 0,
149 Bt_Offset_From_Call
=> -4),
151 (Addr2line_Binary
=> null,
153 Addr_Digits_To_Skip
=> 0,
154 Bt_Offset_From_Call
=> -4),
156 (Addr2line_Binary
=> null,
158 Addr_Digits_To_Skip
=> 0,
159 Bt_Offset_From_Call
=> -2),
161 (Addr2line_Binary
=> null,
163 Addr_Digits_To_Skip
=> 0,
164 Bt_Offset_From_Call
=> -2),
166 (Addr2line_Binary
=> null,
168 Addr_Digits_To_Skip
=> 0,
169 Bt_Offset_From_Call
=> -2),
171 (Addr2line_Binary
=> null,
173 Addr_Digits_To_Skip
=> 0,
174 Bt_Offset_From_Call
=> -4),
176 (Addr2line_Binary
=> null,
178 Addr_Digits_To_Skip
=> 0,
179 Bt_Offset_From_Call
=> -2),
181 (Addr2line_Binary
=> null,
183 Addr_Digits_To_Skip
=> 0,
184 Bt_Offset_From_Call
=> -4),
186 (Addr2line_Binary
=> null,
188 Addr_Digits_To_Skip
=> 0,
189 Bt_Offset_From_Call
=> -4),
191 (Addr2line_Binary
=> null,
193 Addr_Digits_To_Skip
=> 0,
194 Bt_Offset_From_Call
=> -2)
197 -- Current architecture
198 Cur_Arch
: Architecture
;
200 -- State of architecture detection
201 Detect_Success
: Boolean := False;
203 -----------------------
204 -- Local subprograms --
205 -----------------------
207 procedure Error
(Msg
: String);
208 pragma No_Return
(Error
);
209 -- Prints the message and then terminates the program
212 pragma No_Return
(Usage
);
213 -- Displays the short help message and then terminates the program
215 function Get_Reference_Offset
return Unsigned_64
;
216 -- Computes the static offset of the reference symbol by calling nm
218 function Get_Value_From_Hex_Arg
(Arg
: Natural) return Unsigned_64
;
219 -- Threats the argument number Arg as a C-style hexadecimal literal
220 -- and returns its integer value
222 function Hex_Image
(Value
: Unsigned_64
) return String_Access
;
223 -- Returns access to a string that contains hexadecimal image of Value
225 -- Separate functions that provide build-time customization:
227 procedure Detect_Arch
;
228 -- Saves in Cur_Arch the current architecture, based on the name of
229 -- vxaddr2line instance and properties of the host. Detect_Success is False
230 -- if detection fails
236 procedure Detect_Arch
is
237 Name
: constant String := Base_Name
(Command_Name
);
238 Proc
: constant String :=
239 Name
(Name
'First .. Index
(Name
, "-") - 1);
240 Target
: constant String :=
241 Name
(Name
'First .. Index
(Name
, "vxaddr2line") - 1);
244 Detect_Success
:= False;
250 -- Let's detect a Linux or Windows host.
251 if Directory_Separator
= '/' then
252 Cur_Arch
:= Architecture
'Value ("linux_" & Proc
);
254 Cur_Arch
:= Architecture
'Value ("windows_" & Proc
);
257 if Arch_List
(Cur_Arch
).Addr2line_Binary
= null then
258 Arch_List
(Cur_Arch
).Addr2line_Binary
:= new String'
259 (Target & "addr2line");
261 if Arch_List (Cur_Arch).Nm_Binary = null then
262 Arch_List (Cur_Arch).Nm_Binary := new String'
266 Detect_Success
:= True;
277 procedure Error
(Msg
: String) is
284 --------------------------
285 -- Get_Reference_Offset --
286 --------------------------
288 function Get_Reference_Offset
return Unsigned_64
is
289 Nm_Cmd
: constant String_Access
:=
290 Locate_Exec_On_Path
(Arch_List
(Cur_Arch
).Nm_Binary
.all);
292 Nm_Args
: constant Argument_List
:=
294 new String'(Argument
(1)));
296 Forever
: aliased String := "^@@@@";
297 Reference
: aliased String := Ref_Symbol
& "\s+\S\s+([\da-fA-F]+)";
299 Pd
: Process_Descriptor
;
300 Result
: Expect_Match
;
303 -- If Nm is not found, abort
305 if Nm_Cmd
= null then
306 Error
("Couldn't find " & Arch_List
(Cur_Arch
).Nm_Binary
.all);
310 (Pd
, Nm_Cmd
.all, Nm_Args
, Buffer_Size
=> 0, Err_To_Out
=> True);
312 -- Expect a string containing the reference symbol
315 Regexp_Array
'(1 => Reference'Unchecked_Access),
318 -- If we are here, the pattern was matched successfully
321 Match_String : constant String := Expect_Out_Match (Pd);
322 Matches : Match_Array (0 .. 1);
323 Value : Unsigned_64 := 0;
326 Match (Reference, Match_String, Matches);
327 Value := Unsigned_64'Value
329 & Match_String (Matches (1).First .. Matches (1).Last) & "#");
331 -- Expect a string that will never be emitted, so that the
332 -- process can be correctly terminated (with Process_Died)
335 Regexp_Array'(1 => Forever
'Unchecked_Access),
343 -- We cannot get here
348 when Invalid_Process
=>
349 Error
("Could not spawn a process " & Nm_Cmd
.all);
353 -- The process died without matching the reference symbol or the
354 -- format wasn't recognized.
356 Error
("Unexpected output from " & Nm_Cmd
.all);
357 end Get_Reference_Offset
;
359 ----------------------------
360 -- Get_Value_From_Hex_Arg --
361 ----------------------------
363 function Get_Value_From_Hex_Arg
(Arg
: Natural) return Unsigned_64
is
364 Cur_Arg
: constant String := Argument
(Arg
);
368 -- Skip "0x" prefix if present
370 if Cur_Arg
'Length > 2 and then Cur_Arg
(1 .. 2) = "0x" then
376 -- Add architecture-specific offset
378 Offset
:= Offset
+ Arch_List
(Cur_Arch
).Addr_Digits_To_Skip
;
382 return Unsigned_64
'Value
383 ("16#" & Cur_Arg
(Offset
.. Cur_Arg
'Last) & "#");
386 when Constraint_Error
=>
388 Error
("Can't parse backtrace address '" & Cur_Arg
& "'");
390 end Get_Value_From_Hex_Arg
;
396 function Hex_Image
(Value
: Unsigned_64
) return String_Access
is
397 Result
: String (1 .. 20);
401 Unsigned_64_IO
.Put
(Result
, Value
, 16);
402 Start_Pos
:= Index
(Result
, "16#") + 3;
403 return new String'(Result (Start_Pos .. Result'Last - 1));
412 Put_Line ("Usage : " & Base_Name (Command_Name)
414 & Ref_Symbol & " offset on target> <addr1> ...");
419 Ref_Static_Offset, Ref_Runtime_Address, Bt_Address : Unsigned_64;
421 Addr2line_Cmd : String_Access;
423 Addr2line_Args : Argument_List (1 .. 501);
424 -- We expect that there won't be more than 500 backtrace frames
426 Addr2line_Args_Count : Natural;
430 -- Start of processing for VxAddr2Line
436 -- There should be at least two arguments
438 if Argument_Count < 2 then
442 -- Enforce HARD LIMIT There should be at most 501 arguments. Why 501???
444 if Argument_Count > 501 then
445 Error ("Too many backtrace frames");
448 -- Do we have a valid architecture?
450 if not Detect_Success then
451 Put_Line ("Couldn't detect the architecture");
456 Locate_Exec_On_Path (Arch_List (Cur_Arch).Addr2line_Binary.all);
458 -- If Addr2line is not found, abort
460 if Addr2line_Cmd = null then
461 Error ("Couldn't find " & Arch_List (Cur_Arch).Addr2line_Binary.all);
464 -- The first argument specifies the image file. Check if it exists
466 if not Is_Regular_File (Argument (1)) then
467 Error ("Couldn't find the executable " & Argument (1));
470 -- The second argument specifies the reference symbol runtime address.
471 -- Let's parse and store it
473 Ref_Runtime_Address := Get_Value_From_Hex_Arg (2);
475 -- Run nm command to get the reference symbol static offset
477 Ref_Static_Offset := Get_Reference_Offset;
479 -- Build addr2line parameters. First, the standard part
481 Addr2line_Args (1) := new String'("--exe=" & Argument
(1));
482 Addr2line_Args_Count
:= 1;
484 -- Now, append to this the adjusted backtraces in arguments 4 and further
486 for J
in 3 .. Argument_Count
loop
488 -- Basically, for each address in the runtime backtrace ...
490 -- o We compute its offset relatively to the runtime address of the
495 -- o We add this offset to the static one for the reference symbol in
496 -- the executable to find the executable offset corresponding to the
497 -- backtrace address.
499 Bt_Address
:= Get_Value_From_Hex_Arg
(J
);
502 Bt_Address
- Ref_Runtime_Address
504 + Arch_List
(Cur_Arch
).Bt_Offset_From_Call
;
506 Addr2line_Args_Count
:= Addr2line_Args_Count
+ 1;
507 Addr2line_Args
(Addr2line_Args_Count
) := Hex_Image
(Bt_Address
);
510 -- Run the resulting command
512 Spawn
(Addr2line_Cmd
.all,
513 Addr2line_Args
(1 .. Addr2line_Args_Count
), Success
);
516 Error
("Couldn't spawn " & Addr2line_Cmd
.all);
522 -- Mask all exceptions