COMPILATION LISTING OF SEGMENT trace_entrypoints_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 05/01/86 0808.9 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 4* * * 5* *********************************************************** */ 6 7 8 /****^ HISTORY COMMENTS: 9* 1) change(86-03-13,GWMay), approve(86-04-16,MCR7373), 10* audit(86-04-29,LJAdams), install(86-05-01,MR12.0-1051): 11* Changed to reference entry_desc_info_version_2 constant. 12* END HISTORY COMMENTS */ 13 14 15 /* 16* This program converts entrypoint names into pointers and vice versa. 17* 18* Written: May 1984 by Jeffrey D. Ives. 19**/ 20 /* format: style2,ifthendo,^indnoniterdo,thendo,^inditerdo,indproc,ind2,dclind5,idind32 */ 21 22 23 trace_entrypoints_: 24 procedure (); 25 26 dcl (addr, addrel, baseno, before, bin, codeptr, index, maxlength, 27 null, pointer, rel, reverse, rtrim, search, substr, unspec) 28 builtin; 29 signal error; 30 31 32 get_path_name: 33 entry (entry_ptr_i) returns (char (256) var); 34 call hcs_$fs_get_path_name (pointer (entry_ptr_i, 0), pathname.dir, (0), pathname.ent, code); 35 if code ^= 0 36 then do; 37 call sub_err_ (code, trace_$me (), ACTION_DEFAULT_RESTART, null (), rv, "I could not get the path name of ^p.", 38 pointer (entry_ptr_i, 0)); 39 pathname.dir = "?"; 40 pathname.ent = "?"; 41 end; 42 return (rtrim (pathname.dir) || ">" || rtrim (pathname.ent)); 43 44 add_entrypoint: /* Called from trace_catch_. */ 45 entry (entry_ptr_i) returns (fixed bin); 46 entry_ptr = entry_ptr_i; 47 on any_other go to ADD_ENTRYPOINT_PUNT; 48 segment = SEGMENT (entry_ptr); 49 object = OBJECT (segment); 50 entry_ptr_offset = bin (rel (entry_ptr), 18); 51 if entry_ptr_offset < 2 | entry_ptr -> word (1) = ALM_TSP2_PR7_UP_38_STAR 52 then do; /* if alm then search definitions */ 53 definition = DEFINITION (object, object.defp); 54 do while (^(definition.section = "text" & definition.offset = entry_ptr_offset)); 55 if definition.section = "eof" 56 then go to ADD_ENTRYPOINT_PUNT; 57 definition = DEFINITION (object, definition.next_def); 58 end; 59 entry_name = ENTRY_NAME (object, definition); 60 end; 61 else do; /* assume standard entry sequence -> definition */ 62 defptr = addrel (object.defp, addrel (entry_ptr, -2) -> entry_sequence.def_relp); 63 entry_name = ENTRY_NAME (object, DEFINITION (object, defptr)); 64 end; 65 66 return ( 67 trace_tables_$add_entrypoint (entry_ptr, entry_name, TRANSLATOR_ID (entry_ptr, entry_name), FUNCTION (entry_ptr)) 68 ); 69 70 ADD_ENTRYPOINT_PUNT: 71 revert any_other; 72 call hcs_$fs_get_path_name (pointer (entry_ptr, 0), pathname.dir, (0), pathname.ent, code); 73 if code = 0 74 then entry_name = rtrim (pathname.ent) || "$" || OCTAL (rel (entry_ptr)); 75 else entry_name = OCTAL (baseno (entry_ptr)) || "$" || OCTAL (rel (entry_ptr)); 76 return (trace_tables_$add_entrypoint (entry_ptr, entry_name, -1, "0"b)); 77 78 specify_entrypoints: 79 entry (char256var_i, referencing_ptr_i); 80 81 if char256var_i = "*" 82 then do; 83 call trace_tables_$specify_all_entrypoints (); 84 return; 85 end; 86 87 desired = DESIRED (char256var_i); 88 89 entry_ptr = codeptr (cv_entry_ (desired.path, referencing_ptr_i, code)); 90 if code ^= 0 91 then 92 begin; /* try looking for seg name in trace table */ 93 dcl tt_count fixed bin; 94 dcl tt_idx fixed bin; 95 tt_count = trace_$num_entrypoints (); 96 do tt_idx = 0 by 1 while (code = error_table_$seg_not_found & tt_idx < tt_count); 97 if before (trace_$entrypoint_name (tt_idx), "$") = desired.segment_symbol 98 then do; 99 entry_ptr = pointer (trace_$entrypoint_ptr (tt_idx), 0); 100 code = 0; 101 end; 102 end; 103 if code ^= 0 104 then call sub_err_ (code, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", char256var_i); 105 end; 106 107 segment = SEGMENT (entry_ptr); 108 object = OBJECT (segment); 109 110 if desired.offset_symbol ^= "*" 111 then 112 begin; /* try get_definition_ first */ 113 dcl get_definition_ entry (ptr, char (*), char (*), ptr, fixed bin (35)); 114 call get_definition_ (object.defp, (desired.segment_symbol), (desired.offset_symbol), defptr, code); 115 if code = 0 116 then do; 117 definition = DEFINITION (object, defptr); 118 entry_ptr = addrel (object.textp, definition.offset); 119 entry_name = ENTRY_NAME (object, definition); 120 call trace_tables_$specify_entrypoint (entry_ptr, entry_name, TRANSLATOR_ID (entry_ptr, entry_name), 121 FUNCTION (entry_ptr)); 122 return; 123 end; 124 end; 125 126 definition = DEFINITION (object, object.defp); /* get primary or bind file name */ 127 do while (definition.flags.a_ignore & definition.section ^= "eof"); 128 definition = DEFINITION (object, definition.next_def); 129 end; 130 131 if definition.section ^= "segn" 132 then call sub_err_ (error_table_$no_ext_sym, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", char256var_i); 133 134 n_specified = 0; 135 if ^object.format.bound | substr (definition.symbol, 1, definition.symbol_lng) = desired.segment_symbol 136 then do; 137 definition = DEFINITION (object, definition.block_ptr); 138 do while (definition.section ^= "eof"); 139 if definition.section = "text" & definition.offset ^= 0 140 then do; 141 if desired.offset_symbol = "*" | substr (definition.symbol, 1, definition.symbol_lng) = desired.offset_symbol 142 then do; 143 entry_ptr = addrel (object.textp, definition.offset); 144 entry_name = ENTRY_NAME (object, definition); 145 call trace_tables_$specify_entrypoint (entry_ptr, entry_name, TRANSLATOR_ID (entry_ptr, entry_name), 146 FUNCTION (entry_ptr)); 147 n_specified = n_specified + 1; 148 end; 149 end; 150 definition = DEFINITION (object, definition.next_def); 151 end; 152 end; 153 else do; /* look for the component to trace */ 154 definition = DEFINITION (object, definition.next_def); 155 do while ( 156 ^(definition.section = "segn" & substr (definition.symbol, 1, definition.symbol_lng) = desired.segment_symbol)) 157 ; 158 if definition.section = "eof" 159 then call sub_err_ (ZERO, trace_$me (), ACTION_CANT_RESTART, null (), rv, 160 "The segment symbol ""^a"" was not found in the segment ""^a"".", desired.segment_symbol, desired.path); 161 definition = DEFINITION (object, definition.next_def); 162 end; 163 164 definition = DEFINITION (object, definition.block_ptr); 165 do while (^(definition.section = "segn" | definition.section = "eof")); 166 if definition.section = "text" & definition.offset ^= 0 167 then do; 168 if desired.offset_symbol = "*" | substr (definition.symbol, 1, definition.symbol_lng) = desired.offset_symbol 169 then do; 170 entry_ptr = addrel (object.textp, definition.offset); 171 entry_name = ENTRY_NAME (object, definition); 172 call trace_tables_$specify_entrypoint (entry_ptr, entry_name, TRANSLATOR_ID (entry_ptr, entry_name), 173 FUNCTION (entry_ptr)); 174 n_specified = n_specified + 1; 175 end; 176 end; 177 definition = DEFINITION (object, definition.next_def); 178 end; 179 end; 180 181 if n_specified = 0 182 then call sub_err_ (error_table_$no_ext_sym, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", char256var_i); 183 return; 184 185 /* SUBROUTINES */ 186 187 188 DESIRED: 189 proc (char256var_i) returns (1 like desired aligned); 190 dcl char256var_i char (256) var parm; 191 dcl jj fixed bin; 192 dcl kk fixed bin; 193 dcl 1 des like desired aligned; 194 195 des.path = char256var_i; 196 des.pathl = length (rtrim (des.path)); 197 des.segment_symbol = ""; 198 des.offset_symbol = ""; 199 200 if des.pathl = 0 201 then call sub_err_ (error_table_$smallarg, trace_$me (), ACTION_CANT_RESTART, null (), rv, """"""); 202 203 jj = search (reverse (substr (des.path, 1, des.pathl)), "<>"); 204 if jj = 1 205 then call sub_err_ (error_table_$badpath, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", des.path); 206 if jj = 0 /* point jj to first char in seg name */ 207 then jj = 1; 208 else jj = des.pathl - jj + 2; 209 210 kk = search (substr (des.path, jj, des.pathl - jj + 1), "$|"); 211 212 if kk = 1 | kk = des.pathl - jj + 1 /* shouldn't be first or last */ 213 then call sub_err_ (error_table_$bad_arg, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", des.path); 214 if kk = 0 215 then do; 216 if des.pathl - jj + 1 > maxlength (des.segment_symbol) | des.pathl - jj + 1 > maxlength (des.offset_symbol) 217 then call sub_err_ (error_table_$bigarg, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", des.path); 218 219 des.segment_symbol = substr (des.path, jj, des.pathl - jj + 1); 220 des.offset_symbol = substr (des.path, jj, des.pathl - jj + 1); 221 des.pathl = des.pathl + 2; 222 substr (des.path, des.pathl - 1, 2) = "$0"; /* for cv_entry_ */ 223 end; 224 else do; 225 if kk - 1 > maxlength (des.segment_symbol) | des.pathl - jj + 1 - kk > maxlength (des.offset_symbol) 226 then call sub_err_ (error_table_$bigarg, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", des.path); 227 des.segment_symbol = substr (des.path, jj, kk - 1); 228 des.offset_symbol = substr (des.path, jj + kk, des.pathl - jj + 1 - kk); 229 des.pathl = jj + kk; 230 substr (des.path, des.pathl) = "0"; 231 end; 232 233 if jj > 1 /* if there are "<>" characters */ 234 then substr (des.path, des.pathl - 1, 1) = "|"; 235 return (des); 236 end DESIRED; 237 238 239 SEGMENT: 240 proc (entry_ptr_i) returns (1 like segment aligned); 241 dcl entry_ptr_i ptr unal; 242 dcl 1 seg like segment aligned; 243 dcl hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)); 244 seg.base_ptr = pointer (entry_ptr, 0); 245 call hcs_$status_mins (seg.base_ptr, seg.entry_type, seg.bit_count, code); 246 if code ^= 0 247 then call sub_err_ (code, trace_$me (), ACTION_CANT_RESTART, null (), rv, "I could not get the status of ""^p"".", 248 seg.base_ptr); 249 if seg.entry_type ^= 1 /* 1 means segment. */ 250 then call sub_err_ (ZERO, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^p"" does not point to a segment.", 251 seg.base_ptr); 252 return (seg); 253 end SEGMENT; 254 255 256 OBJECT: 257 proc (segment_i) returns (1 like object_info aligned); 258 dcl 1 segment_i like segment aligned parm; 259 dcl 1 oi like object_info aligned; 260 dcl object_info_$brief entry (ptr, fixed bin (24), ptr, fixed bin (35)); 261 unspec (oi) = ""b; 262 oi.version_number = object_info_version_2; 263 call object_info_$brief (segment_i.base_ptr, segment_i.bit_count, addr (oi), code); 264 if code ^= 0 265 then call sub_err_ (code, trace_$me (), ACTION_CANT_RESTART, null (), rv, """^a""", 266 get_path_name ((segment.base_ptr))); 267 return (oi); 268 end OBJECT; 269 270 271 DEFINITION: 272 proc (object_i, defptr_i) returns (1 like definition aligned); 273 dcl defptr_i ptr parm; 274 dcl 1 object_i like object_info aligned; 275 dcl 1 def like definition aligned; 276 dcl decode_definition_$full entry (ptr, ptr, ptr) returns (bit aligned); 277 if decode_definition_$full ((defptr_i), addr (def), addr (object_i)) 278 then do; 279 unspec (def) = ""b; 280 def.next_def = null (); 281 def.last_def = null (); 282 def.block_ptr = null (); 283 def.section = "eof"; 284 def.descr_ptr = null (); 285 end; 286 else if def.section = "text" 287 then 288 begin; /* strip off component name if necessary */ 289 dcl kk fixed bin; 290 kk = index (substr (def.symbol, 1, def.symbol_lng), "$"); 291 if kk > 0 292 then do; 293 def.symbol_lng = def.symbol_lng - kk; 294 def.symbol = substr (def.symbol, kk + 1, def.symbol_lng); 295 end; 296 end; 297 return (def); 298 end DEFINITION; 299 300 301 ENTRY_NAME: 302 proc (object_i, offset_definition_i) returns (char (65) var); 303 dcl 1 object_i like object_info aligned parm; 304 dcl 1 offset_definition_i like definition aligned parm; 305 dcl 1 segment_definition like definition aligned; 306 segment_definition = DEFINITION (object_i, offset_definition_i.block_ptr); 307 if segment_definition.section = "eof" 308 then call sub_err_ (ZERO, trace_$me (), ACTION_CANT_RESTART, null (), rv, 309 "There seems to be something wrong with the definition of ^a.", 310 substr (offset_definition_i.symbol, 1, offset_definition_i.symbol_lng)); 311 return (substr (segment_definition.symbol, 1, segment_definition.symbol_lng) || "$" 312 || substr (offset_definition_i.symbol, 1, offset_definition_i.symbol_lng)); 313 end ENTRY_NAME; 314 315 316 OCTAL: 317 proc (half_word_i) returns (char (32) var); 318 dcl half_word_i bit (18) aligned parm; 319 dcl char32var char (32) var; 320 dcl dummy fixed bin; 321 call ioa_$rsnnl ("^o", char32var, dummy, half_word_i); 322 return (char32var); 323 end OCTAL; 324 325 326 FUNCTION: 327 proc (entry_ptr_i) returns (bit aligned); 328 dcl entry_ptr_i ptr unal parm; 329 dcl desc_ptrs (1) ptr; 330 dcl 1 edi like entry_desc_info aligned; 331 dcl get_entry_arg_descs_$info entry (ptr, fixed bin, (*) ptr, ptr, fixed bin (35)); 332 entry_desc_info_ptr = addr (edi); 333 unspec (entry_desc_info) = ""b; 334 entry_desc_info.version = entry_desc_info_version_2; 335 call get_entry_arg_descs_$info ((entry_ptr_i), (0), desc_ptrs, entry_desc_info_ptr, (0)); 336 return (entry_desc_info.flags.function); 1 1 /* START OF: entry_desc_info.incl.pl1 * * * * * * * * * * * * * * * * */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(84-11-29,Ranzenbach), approve(86-03-12,MCR7144), 1 7* audit(86-03-12,GWMay), install(86-05-01,MR12.0-1051): 1 8* for version 2. This version allows the caller to specify a pointer to 1 9* the beginning of the offset and its bit count. This allows the 1 10* processing of archive components. 1 11* 1 12* NOTICE: 1 13* All applications which use this structure should be converted to 1 14* use version 2. Version 1 can be retained by setting the version to 1 15* a value of 1. The constant entry_desc_info_version_1 has been 1 16* removed from the file. 1 17* END HISTORY COMMENTS */ 1 18 1 19 1 20 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 21 /* */ 1 22 /* Name: entry_desc_info.incl.pl1 */ 1 23 /* */ 1 24 /* This include file is used by get_entry_arg_desc_$info, $text_only_info and their */ 1 25 /* callers. It declares the flag bits obtained from the entry sequence of a procedure */ 1 26 /* entry point. */ 1 27 /* */ 1 28 /* Status */ 1 29 /* */ 1 30 /* 0) Created in May, 1979 by G. C. Dixon */ 1 31 /* */ 1 32 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 33 1 34 dcl 1 entry_desc_info aligned based(entry_desc_info_ptr), 1 35 2 version fixed bin, /* version number of this structure (= 2) */ 1 36 2 flags, 1 37 1 38 (3 basic_indicator, /* on if this is a BASIC program. */ 1 39 3 revision_1, /* on if program entry has stuff added after 5/75 */ 1 40 3 has_descriptors, /* on if entry point had valid parm. descriptors */ 1 41 3 variable, /* on if entry point takes undefined no. of args */ 1 42 3 function) /* on if entry point is a function */ 1 43 bit(1) unaligned, 1 44 3 pad bit(13) unaligned, 1 45 /* version 2 fields follow */ 1 46 2 object_ptr ptr, /* -> beginning of object segment... (INPUT) */ 1 47 2 bit_count fixed bin (24); /* bit count of object... (INPUT) */ 1 48 1 49 dcl entry_desc_info_version_2 fixed bin int static options(constant) init(2), 1 50 entry_desc_info_ptr ptr; 1 51 1 52 /* END OF: entry_desc_info.incl.pl1 * * * * * * * * * * * * * * * * */ 337 338 end FUNCTION; 339 340 341 TRANSLATOR_ID: 342 proc (entry_ptr_i, entry_name_i) returns (fixed bin); 343 dcl entry_ptr_i ptr unal parm; 344 dcl entry_name_i char (65) var parm; 345 dcl translator_id fixed bin; 346 dcl entry_name char (65); 347 dcl entry_ptr ptr; 348 dcl link_trap_caller_ entry (); 349 dcl unwind_stack_ entry (); 350 dcl unwinder_ entry (); 351 352 entry_name = entry_name_i; 353 entry_ptr = entry_ptr_i; 354 355 if entry_ptr -> word (1) = ALM_TSP2_PR7_UP_38_STAR 356 then translator_id = 1; 357 else translator_id = 0; 358 359 if (entry_ptr -> word (2) ^= PL1_FORTRAN_EPP2_PR7_UP_28_STAR & entry_ptr -> word (2) ^= COBOL_EPP2_PR7_UP_40_STAR 360 & entry_ptr -> word (1) ^= ALM_TSP2_PR7_UP_38_STAR) 361 | (entry_ptr -> word (1) = ALM_TSP2_PR7_UP_38_STAR 362 & (entry_name = "ssu_$standalone_invocation" | substr (entry_name, 1, 4) = "cu_$" 363 | substr (entry_name, 1, 9) = "formline_" | substr (entry_name, 1, 5) = "lisp_" 364 | substr (entry_name, 1, 15) = "nonlocal_goto_$" | substr (entry_name, 1, 11) = "condition_$")) 365 | entry_ptr = codeptr (link_trap_caller_) | entry_ptr = codeptr (unwind_stack_) 366 | entry_ptr = codeptr (unwinder_) | entry_name = "ssu_invocation_$create_standalone" 367 | substr (entry_name, 1, 11) = "pascal_io_$" | substr (entry_name, 1, 24) = "pascal_area_management_$" 368 | substr (entry_name, 1, 12) = "pascal_time$" | substr (entry_name, 1, 15) = "pascal_errors_$" 369 | substr (entry_name, 1, 5) = "probe" | substr (entry_name, 1, 10) = "cobol_rts_" 370 | substr (entry_name, 1, 11) = "fortran_io_" | substr (entry_name, 1, 14) = "cobol_control_" 371 then translator_id = -1; 372 373 return (translator_id); 374 end TRANSLATOR_ID; 375 376 /* START OF DECLARATIONS */ 377 /* format: ^insnl,^delnl */ 378 379 /* Parameters */ 380 381 dcl char256var_i char (256) var parm; 382 dcl entry_ptr_i ptr unal parm; 383 dcl referencing_ptr_i ptr parm; 384 385 386 /* Automatic */ 387 388 dcl code fixed bin (35); 389 dcl defptr ptr; 390 dcl entry_name char (65) var; 391 dcl entry_ptr ptr unal; 392 dcl entry_ptr_offset fixed bin (18); 393 dcl n_specified fixed bin; 394 dcl rv fixed bin (35); 395 396 dcl 1 desired aligned, 397 2 path char (300) unal, 398 2 pathl fixed bin, 399 2 segment_symbol char (32) var unal, 400 2 offset_symbol char (32) var unal; 401 402 dcl 1 pathname aligned, 403 2 dir char (168) unal, 404 2 ent char (32) unal; 405 406 dcl 1 segment aligned, 407 2 base_ptr ptr, 408 2 entry_type fixed bin (2), 409 2 bit_count fixed bin (24); 410 411 dcl 1 definition aligned, /* structure filled in by full entry */ 412 2 next_def ptr, /* ptr to next definition in list */ 413 2 last_def ptr, /* ptr to previous definition in list */ 414 2 block_ptr ptr, /* ptr to either defblock or segname block */ 415 2 section char (4), /* "text", "link", "symb" or "segn" */ 416 2 offset fixed bin (18), /* offset within class (if ^= "segn") */ 417 2 entrypoint fixed bin (18), /* value of entrypoint in text if ^= 0 */ 418 2 symbol char (256), /* the symbolic name of the definition */ 419 2 symbol_lng fixed bin, /* the actual length of symbol */ 420 2 flags, /* same flags as in std def */ 421 3 a_new_format bit unaligned, /* def is in new format */ 422 3 a_ignore bit unaligned, /* linker should ignore this def */ 423 3 a_entrypoint bit unaligned, /* def is for entrypoint */ 424 3 a_retain bit unaligned, 425 3 a_arg_count bit unaligned, /* there is an arg count for entry */ 426 3 a_descr_sw bit unaligned, /* there are valid descriptors for entry */ 427 3 unused bit (12) unaligned, 428 2 n_args fixed bin, /* # of args entry expects */ 429 2 descr_ptr ptr; /* ptr to array of rel ptrs to descriptors for entry */ 430 431 dcl 1 entry_sequence aligned based, 432 2 descr_relp_offset bit (18) unal, 433 2 reserved bit (18) unal, 434 2 def_relp bit (18) unal, 435 2 flags bit (18) unal; 436 437 dcl 1 object like object_info aligned; 438 439 440 /* Static */ 441 442 dcl ALM_TSP2_PR7_UP_38_STAR bit (36) aligned static options (constant) init ("700046272120"b3); 443 /* ALM entry point */ 444 dcl COBOL_EPP2_PR7_UP_40_STAR bit (36) aligned static options (constant) init ("700050352120"b3); 445 /* COBOL entry point */ 446 dcl PL1_FORTRAN_EPP2_PR7_UP_28_STAR bit (36) aligned static options (constant) init ("700034352120"b3); 447 /* PL/I or FORTRAN entry point */ 448 dcl ZERO fixed bin (35) static options (constant) init (0); 449 dcl length builtin; 450 451 452 /* Conditions */ 453 454 dcl any_other condition; 455 dcl error condition; 456 457 458 /* Based */ 459 460 dcl word (3) bit (36) aligned based; 461 462 463 /* External Variables */ 464 465 dcl error_table_$bad_arg fixed bin (35) ext; 466 dcl error_table_$badpath fixed bin (35) ext; 467 dcl error_table_$bigarg fixed bin (35) ext; 468 dcl error_table_$no_ext_sym fixed bin (35) ext; 469 dcl error_table_$seg_not_found fixed bin (35) ext; 470 dcl error_table_$smallarg fixed bin (35) ext; 471 472 473 /* External Entries */ 474 475 dcl cv_entry_ entry (char (*), ptr, fixed bin (35)) returns (entry); 476 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)); 477 dcl ioa_$rsnnl entry () options (variable); 478 dcl trace_tables_$add_entrypoint entry (ptr unal, char (65) var, fixed bin, bit aligned) returns (fixed bin); 479 dcl trace_tables_$specify_all_entrypoints entry (); 480 dcl trace_tables_$specify_entrypoint entry (ptr unal, char (65) var, fixed bin, bit aligned); 481 dcl sub_err_ entry () options (variable); 482 483 484 /* format: insnl,delnl */ 485 /* END OF DECLARATIONS */ 486 487 /* START OF INCLUDE FILES */ 488 489 2 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 2 2*coded February 8, 1972 by Michael J. Spier */ 2 3 /* modified May 26, 1972 by M. Weaver */ 2 4 /* modified 15 April, 1975 by M. Weaver */ 2 5 2 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 2 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 2 8 2 textp pointer, /* pointer to beginning of text section */ 2 9 2 defp pointer, /* pointer to beginning of definition section */ 2 10 2 linkp pointer, /* pointer to beginning of linkage section */ 2 11 2 statp pointer, /* pointer to beginning of static section */ 2 12 2 symbp pointer, /* pointer to beginning of symbol section */ 2 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 2 14 2 tlng fixed bin, /* length in words of text section */ 2 15 2 dlng fixed bin, /* length in words of definition section */ 2 16 2 llng fixed bin, /* length in words of linkage section */ 2 17 2 ilng fixed bin, /* length in words of static section */ 2 18 2 slng fixed bin, /* length in words of symbol section */ 2 19 2 blng fixed bin, /* length in words of break map */ 2 20 2 format, /* word containing bit flags about object type */ 2 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 2 22 3 bound bit(1) unaligned, /* on if segment is bound */ 2 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 2 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 2 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 2 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 2 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 2 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 2 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 2 30 3 pad bit(27) unaligned, 2 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 2 32 2 textlinkp pointer, /* ptr to first link in text */ 2 33 2 34 /* LIMIT OF BRIEF STRUCTURE */ 2 35 2 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 2 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 2 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 2 39 2 cvers aligned, /* generator version name in printable char string form */ 2 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 2 41 3 length bit(18) unaligned, /* length of name in characters */ 2 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 2 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 2 44 3 length bit(18) unaligned, /* length of comment in characters */ 2 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 2 46 2 47 /* LIMIT OF DISPLAY STRUCTURE */ 2 48 2 49 2 rel_text pointer, /* pointer to text section relocation info */ 2 50 2 rel_def pointer, /* pointer to definition section relocation info */ 2 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 2 52 2 rel_static pointer, /* pointer to static section relocation info */ 2 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 2 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 2 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 2 56 /* currently not used by system */ 2 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 2 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 2 59 2 60 declare object_info_version_2 fixed bin int static init(2); 2 61 2 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 490 491 492 493 3 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 3 2 /* format: style3 */ 3 3 3 4 /* These constants are to be used for the flags argument of sub_err_ */ 3 5 /* They are just "string (condition_info_header.action_flags)" */ 3 6 3 7 declare ( 3 8 ACTION_CAN_RESTART init (""b), 3 9 ACTION_CANT_RESTART init ("1"b), 3 10 ACTION_DEFAULT_RESTART 3 11 init ("01"b), 3 12 ACTION_QUIET_RESTART 3 13 init ("001"b), 3 14 ACTION_SUPPORT_SIGNAL 3 15 init ("0001"b) 3 16 ) bit (36) aligned internal static options (constant); 3 17 3 18 /* End include file */ 494 495 4 1 /* START OF: trace_interface.incl.pl1 * * * * * * * * * * * * * * * * */ 4 2 /* Written: May 1984 by Jeffrey D. Ives. */ 4 3 /* format: style2,^inddcls,^indnoniterdo,^inditerdo,dclind5,idind35 */ 4 4 4 5 /* IDENTIFICATION */ 4 6 4 7 dcl trace_$me entry () returns (char (32)); 4 8 dcl trace_$version entry () returns (char (32)); 4 9 4 10 /* TRANSACTIONS */ 4 11 4 12 dcl trace_$transaction_begin entry (fixed bin (71)) returns (bit aligned); 4 13 dcl trace_$transaction_begin_force entry (fixed bin (71)); 4 14 dcl trace_$transaction_end entry (fixed bin (71)) returns (bit aligned); 4 15 4 16 /* ACTIONS */ 4 17 4 18 dcl trace_$update_default_parms entry () returns (bit aligned); 4 19 dcl trace_$update_global_parms entry () returns (bit aligned); 4 20 dcl trace_$add_specified_eps entry (fixed bin, fixed bin); 4 21 dcl trace_$add_specified_locs entry (fixed bin, fixed bin); 4 22 dcl trace_$remove_specified_eps entry (fixed bin); 4 23 dcl trace_$remove_specified_locs entry (fixed bin); 4 24 dcl trace_$turn_on_specified_eps entry (fixed bin); 4 25 dcl trace_$turn_off_specified_eps entry (fixed bin); 4 26 4 27 /* CONVERSION */ 4 28 4 29 dcl trace_$cv_inout_to_bits entry (char (8) aligned) returns (bit (2) aligned); 4 30 dcl trace_$cv_bits_to_inout entry (bit (2) aligned) returns (char (8) aligned); 4 31 dcl trace_$cv_n_to_number entry (char (16)) returns (fixed bin (34)); 4 32 dcl trace_$cv_onoff_to_bit entry (char (8) aligned) returns (bit aligned); 4 33 dcl trace_$cv_bit_to_onoff entry (bit aligned) returns (char (8) aligned); 4 34 dcl trace_$cv_entry_name_to_spp entry (char (256) var, ptr) returns (1 like stop_proc aligned); 4 35 dcl trace_$cv_file_path_to_osw entry (char (256) var, ptr) returns (1 like output_switch aligned); 4 36 dcl trace_$cv_stream_name_to_osw entry (char (32) var) returns (1 like output_switch aligned); 4 37 4 38 /* METERS */ 4 39 4 40 dcl trace_$entrypoint_counts entry (fixed bin) returns (1 aligned like counts); 4 41 dcl trace_$entrypoint_global_meters entry (fixed bin) returns (1 like meters aligned); 4 42 dcl trace_$entrypoint_local_meters entry (fixed bin) returns (1 like meters aligned); 4 43 dcl trace_$metered entry () returns (1 like meters aligned); 4 44 dcl trace_$removed entry () returns (1 like meters aligned); 4 45 dcl trace_$reset_meters entry (); 4 46 4 47 /* ENTRYPOINTS */ 4 48 4 49 dcl trace_$entrypoint_index entry (ptr unal) returns (fixed bin); 4 50 dcl trace_$entrypoint_name entry (fixed bin) returns (char (65) var); 4 51 dcl trace_$entrypoint_ptr entry (fixed bin) returns (ptr); 4 52 dcl trace_$entrypoint_seg_path entry (fixed bin) returns (char (256) var); 4 53 dcl trace_$entrypoint_status entry (fixed bin) returns (char (32) var); 4 54 dcl trace_$function entry (fixed bin) returns (bit aligned); 4 55 dcl trace_$num_entrypoints entry () returns (fixed bin); 4 56 dcl trace_$num_specified_entrypoints entry () returns (fixed bin); 4 57 dcl trace_$specified_entrypoint_index entry (fixed bin) returns (fixed bin); 4 58 dcl trace_$specify_entrypoints entry (char (256) var, ptr); 4 59 dcl trace_$translator_id entry (fixed bin) returns (fixed bin); 4 60 4 61 /* LOCATIONS */ 4 62 4 63 dcl trace_$location_ptr entry (fixed bin) returns (ptr); 4 64 dcl trace_$location_seg_path entry (fixed bin) returns (char (256) var); 4 65 dcl trace_$location_values entry (fixed bin) returns (1 aligned like watch_values); 4 66 dcl trace_$num_locations entry () returns (fixed bin); 4 67 dcl trace_$num_specified_locations entry () returns (fixed bin); 4 68 dcl trace_$specified_location_index entry (fixed bin) returns (fixed bin); 4 69 dcl trace_$specify_locations entry (char (256) var); 4 70 dcl trace_$specify_changed_locations entry (); 4 71 4 72 /* EVENT BUFFER */ 4 73 4 74 dcl trace_$buffer_counts entry (fixed bin (34), fixed bin (34)); 4 75 dcl trace_$buffer_event entry (fixed bin (34), fixed bin, char (2), ptr unal, 1 like counts aligned, 1 like meters aligned); 4 76 dcl trace_$buffer_event_header entry (fixed bin (34)) returns (char (256) var); 4 77 dcl trace_$buffer_event_string entry (fixed bin (34)) returns (char (256) var); 4 78 dcl trace_$buffer_ptr entry () returns (ptr unal); 4 79 4 80 /* TRACE PARAMETERS */ 4 81 4 82 dcl trace_$arguments entry (fixed bin) returns (bit (2) aligned); 4 83 dcl trace_$set_arguments entry (bit (2) aligned); 4 84 dcl trace_$call entry (fixed bin) returns (char (256) var); 4 85 dcl trace_$set_call entry (char (256) var); 4 86 dcl trace_$every entry (fixed bin) returns (fixed bin (34)); 4 87 dcl trace_$set_every entry (fixed bin (34)); 4 88 dcl trace_$first entry (fixed bin) returns (fixed bin (34)); 4 89 dcl trace_$set_first entry (fixed bin (34)); 4 90 dcl trace_$high entry (fixed bin) returns (fixed bin (34)); 4 91 dcl trace_$set_high entry (fixed bin (34)); 4 92 dcl trace_$last entry (fixed bin) returns (fixed bin (34)); 4 93 dcl trace_$set_last entry (fixed bin (34)); 4 94 dcl trace_$low entry (fixed bin) returns (fixed bin (34)); 4 95 dcl trace_$set_low entry (fixed bin (34)); 4 96 dcl trace_$new_high entry (fixed bin) returns (bit aligned); 4 97 dcl trace_$set_new_high entry (bit aligned); 4 98 dcl trace_$parms_string entry (fixed bin, bit aligned) returns (char (256) var); 4 99 dcl trace_$parms_specified entry () returns (bit aligned); 4 100 dcl trace_$stop entry (fixed bin) returns (bit (2) aligned); 4 101 dcl trace_$set_stop entry (bit (2) aligned); 4 102 dcl trace_$stop_every entry (fixed bin) returns (fixed bin (34)); 4 103 dcl trace_$set_stop_every entry (fixed bin (34)); 4 104 dcl trace_$stop_low entry (fixed bin) returns (fixed bin (34)); 4 105 dcl trace_$set_stop_low entry (fixed bin (34)); 4 106 dcl trace_$trace entry (fixed bin) returns (bit (2) aligned); 4 107 dcl trace_$set_trace entry (bit (2) aligned); 4 108 4 109 /* GLOBAL PARAMETERS */ 4 110 4 111 dcl trace_$alm entry () returns (bit aligned); 4 112 dcl trace_$set_alm entry (bit aligned); 4 113 dcl trace_$automatic entry () returns (bit aligned); 4 114 dcl trace_$set_automatic entry (bit aligned); 4 115 dcl trace_$buffer entry () returns (bit aligned); 4 116 dcl trace_$set_buffer entry (bit aligned); 4 117 dcl trace_$calibrate entry () returns (bit aligned); 4 118 dcl trace_$set_calibrate entry (bit aligned); 4 119 dcl trace_$compensation entry (fixed bin) returns (1 aligned like compensation); 4 120 dcl trace_$set_compensation entry (fixed bin, 1 aligned like compensation); 4 121 dcl trace_$enabled entry () returns (bit aligned); 4 122 dcl trace_$set_enabled entry (bit aligned); 4 123 dcl trace_$global_parms_string entry () returns (char (256) var); 4 124 dcl trace_$long entry () returns (bit aligned); 4 125 dcl trace_$set_long entry (bit aligned); 4 126 dcl trace_$meter entry () returns (bit aligned); 4 127 dcl trace_$set_meter entry (bit aligned); 4 128 dcl trace_$output_switch entry () returns (1 like output_switch aligned); 4 129 dcl trace_$set_output_switch entry (1 like output_switch aligned); 4 130 dcl trace_$signals entry () returns (bit aligned); 4 131 dcl trace_$set_signals entry (bit aligned); 4 132 dcl trace_$stop_proc entry () returns (1 like stop_proc); 4 133 dcl trace_$set_stop_proc entry (1 like stop_proc); 4 134 dcl trace_$stop_routine entry () returns (entry); 4 135 dcl trace_$set_stop_routine entry (entry); 4 136 dcl trace_$trace_routine entry () returns (entry); 4 137 dcl trace_$set_trace_routine entry (entry); 4 138 dcl trace_$loud entry () returns (bit aligned); 4 139 dcl trace_$set_loud entry (bit aligned); 4 140 4 141 /* MISCELLANEOUS */ 4 142 4 143 dcl trace_$in_trace entry () returns (bit aligned); 4 144 4 145 /* STRUCTURES AND CONSTANTS */ 4 146 4 147 dcl 1 watch_values aligned, 4 148 2 old bit (36), 4 149 2 new bit (36); 4 150 4 151 dcl 1 counts aligned, 4 152 2 calls fixed bin (53), /* total number of calls */ 4 153 2 level fixed bin (34), /* current recursion level */ 4 154 2 max_level fixed bin (34); /* max ever recursion level */ 4 155 4 156 4 157 dcl 1 meters aligned, 4 158 2 real_time fixed bin (53), /* The total amount of real time metered. */ 4 159 2 vcpu_time fixed bin (53), /* The total amount of virtual cpu time metered. */ 4 160 2 page_faults fixed bin (34); /* The total number of page faults metered. */ 4 161 4 162 dcl 1 output_switch aligned based, 4 163 2 iocb_ptr ptr, 4 164 2 stream_name char (32) var, 4 165 2 file_path char (256) var; 4 166 4 167 dcl 1 stop_proc aligned based, 4 168 2 entry_value entry (), 4 169 2 entry_name char (256) var; 4 170 4 171 dcl 1 compensation aligned, 4 172 2 real_time fixed bin (53), 4 173 2 vcpu_time fixed bin (53); 4 174 4 175 dcl ( 4 176 COMPENSATION_FROM_ENTRY_TO_ENTRY init (1), 4 177 COMPENSATION_FROM_ENTRY_TO_RETURN init (2), 4 178 COMPENSATION_FROM_RETURN_TO_ENTRY init (3), 4 179 COMPENSATION_FROM_RETURN_TO_RETURN init (4) 4 180 ) static options (constant); 4 181 4 182 /* END OF: trace_interface.incl.pl1 * * * * * * * * * * * * * * * * */ 496 497 498 499 end trace_entrypoints_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/01/86 0805.9 trace_entrypoints_.pl1 >spec>install>1051>trace_entrypoints_.pl1 337 1 05/01/86 0807.8 entry_desc_info.incl.pl1 >spec>install>1051>entry_desc_info.incl.pl1 490 2 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.incl.pl1 494 3 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.incl.pl1 496 4 10/23/84 1349.5 trace_interface.incl.pl1 >ldd>include>trace_interface.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ACTION_CANT_RESTART 000001 constant bit(36) initial dcl 3-7 set ref 103* 131* 158* 181* 200* 204* 212* 216* 225* 246* 249* 264* 307* ACTION_DEFAULT_RESTART 000000 constant bit(36) initial dcl 3-7 set ref 37* ALM_TSP2_PR7_UP_38_STAR 000004 constant bit(36) initial dcl 442 ref 51 355 359 359 COBOL_EPP2_PR7_UP_40_STAR 000003 constant bit(36) initial dcl 444 ref 359 PL1_FORTRAN_EPP2_PR7_UP_28_STAR 000002 constant bit(36) initial dcl 446 ref 359 ZERO 000031 constant fixed bin(35,0) initial dcl 448 set ref 158* 249* 307* a_ignore 112(01) 000356 automatic bit(1) level 3 packed unaligned dcl 411 set ref 127 addr builtin function dcl 26 ref 263 263 277 277 277 277 332 addrel builtin function dcl 26 ref 62 62 118 143 170 any_other 000562 stack reference condition dcl 454 ref 47 70 base_ptr 000352 automatic pointer level 2 in structure "segment" dcl 406 in procedure "trace_entrypoints_" set ref 264 base_ptr parameter pointer level 2 in structure "segment_i" dcl 258 in procedure "OBJECT" set ref 263* base_ptr 000776 automatic pointer level 2 in structure "seg" dcl 242 in procedure "SEGMENT" set ref 244* 245* 246* 249* baseno builtin function dcl 26 ref 75 75 before builtin function dcl 26 ref 97 bin builtin function dcl 26 ref 50 bit_count 3 parameter fixed bin(24,0) level 2 in structure "segment_i" dcl 258 in procedure "OBJECT" set ref 263* bit_count 3 000776 automatic fixed bin(24,0) level 2 in structure "seg" dcl 242 in procedure "SEGMENT" set ref 245* block_ptr 4 parameter pointer level 2 in structure "offset_definition_i" dcl 304 in procedure "ENTRY_NAME" set ref 306* block_ptr 4 000356 automatic pointer level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" set ref 137* 164* block_ptr 4 001104 automatic pointer level 2 in structure "def" dcl 275 in procedure "DEFINITION" set ref 282* bound 24(01) 000474 automatic bit(1) level 3 packed unaligned dcl 437 set ref 135 char256var_i parameter varying char(256) dcl 381 in procedure "trace_entrypoints_" set ref 78 81 87* 103* 131* 181* char256var_i parameter varying char(256) dcl 190 in procedure "DESIRED" ref 188 195 char32var 001356 automatic varying char(32) dcl 319 set ref 321* 322 code 000100 automatic fixed bin(35,0) dcl 388 set ref 34* 35 37* 72* 73 89* 90 96 100* 103 103* 114* 115 245* 246 246* 263* 264 264* codeptr builtin function dcl 26 ref 89 359 359 359 compensation 000612 automatic structure level 1 dcl 4-171 counts 000600 automatic structure level 1 dcl 4-151 cv_entry_ 000024 constant entry external dcl 475 ref 89 decode_definition_$full 000060 constant entry external dcl 276 ref 277 def 001104 automatic structure level 1 dcl 275 set ref 277 277 279* 297 def_relp 1 based bit(18) level 2 packed unaligned dcl 431 ref 62 definition 000356 automatic structure level 1 dcl 411 set ref 53* 57* 59* 117* 119* 126* 128* 137* 144* 150* 154* 161* 164* 171* 177* defp 4 000474 automatic pointer level 2 dcl 437 set ref 53* 62 114* 126* defptr 000102 automatic pointer dcl 389 set ref 62* 63* 63* 114* 117* defptr_i parameter pointer dcl 273 ref 271 277 des 000632 automatic structure level 1 dcl 193 set ref 235 desc_ptrs 001376 automatic pointer array dcl 329 set ref 335* descr_ptr 114 001104 automatic pointer level 2 dcl 275 set ref 284* desired 000132 automatic structure level 1 dcl 396 set ref 87* dir 000270 automatic char(168) level 2 packed unaligned dcl 402 set ref 34* 39* 42 72* dummy 001367 automatic fixed bin(17,0) dcl 320 set ref 321* edi 001400 automatic structure level 1 dcl 330 set ref 332 ent 52 000270 automatic char(32) level 2 packed unaligned dcl 402 set ref 34* 40* 42 72* 73 entry_desc_info based structure level 1 dcl 1-34 set ref 333* entry_desc_info_ptr 001406 automatic pointer dcl 1-49 set ref 332* 333 334 335* 336 entry_desc_info_version_2 constant fixed bin(17,0) initial dcl 1-49 ref 334 entry_name 001417 automatic char(65) unaligned dcl 346 in procedure "TRANSLATOR_ID" set ref 352* 359 359 359 359 359 359 359 359 359 359 359 359 359 359 359 entry_name 000104 automatic varying char(65) dcl 390 in procedure "trace_entrypoints_" set ref 59* 63* 66* 66* 66* 73* 75* 76* 119* 120* 120* 120* 144* 145* 145* 145* 171* 172* 172* 172* entry_name_i parameter varying char(65) dcl 344 ref 341 352 entry_ptr 001440 automatic pointer dcl 347 in procedure "TRANSLATOR_ID" set ref 353* 355 359 359 359 359 359 359 359 entry_ptr 000126 automatic pointer unaligned dcl 391 in procedure "trace_entrypoints_" set ref 46* 48* 50 51 62 66* 66* 66* 66* 66* 72 72 73 73 75 75 75 75 76* 89* 99* 107* 118* 120* 120* 120* 120* 120* 143* 145* 145* 145* 145* 145* 170* 172* 172* 172* 172* 172* 244 entry_ptr_i parameter pointer unaligned dcl 382 in procedure "trace_entrypoints_" ref 32 34 34 37 37 44 46 entry_ptr_i parameter pointer unaligned dcl 241 in procedure "SEGMENT" ref 239 entry_ptr_i parameter pointer unaligned dcl 328 in procedure "FUNCTION" ref 326 335 entry_ptr_i parameter pointer unaligned dcl 343 in procedure "TRANSLATOR_ID" ref 341 353 entry_ptr_offset 000127 automatic fixed bin(18,0) dcl 392 set ref 50* 51 54 entry_sequence based structure level 1 dcl 431 entry_type 2 000776 automatic fixed bin(2,0) level 2 dcl 242 set ref 245* 249 error 000570 stack reference condition dcl 455 ref 29 error_table_$bad_arg 000010 external static fixed bin(35,0) dcl 465 set ref 212* error_table_$badpath 000012 external static fixed bin(35,0) dcl 466 set ref 204* error_table_$bigarg 000014 external static fixed bin(35,0) dcl 467 set ref 216* 225* error_table_$no_ext_sym 000016 external static fixed bin(35,0) dcl 468 set ref 131* 181* error_table_$seg_not_found 000020 external static fixed bin(35,0) dcl 469 ref 96 error_table_$smallarg 000022 external static fixed bin(35,0) dcl 470 set ref 200* flags 112 000356 automatic structure level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" flags 1 based structure level 2 in structure "entry_desc_info" dcl 1-34 in procedure "FUNCTION" format 24 000474 automatic structure level 2 dcl 437 function 1(04) based bit(1) level 3 packed unaligned dcl 1-34 set ref 336 get_definition_ 000052 constant entry external dcl 113 ref 114 get_entry_arg_descs_$info 000062 constant entry external dcl 331 ref 335 half_word_i parameter bit(18) dcl 318 set ref 316 321* hcs_$fs_get_path_name 000026 constant entry external dcl 476 ref 34 72 hcs_$status_mins 000054 constant entry external dcl 243 ref 245 index builtin function dcl 26 ref 290 ioa_$rsnnl 000030 constant entry external dcl 477 ref 321 jj 000630 automatic fixed bin(17,0) dcl 191 set ref 203* 204 206 206* 208* 208 210 210 212 216 216 219 219 220 220 225 227 228 228 229 233 kk 000631 automatic fixed bin(17,0) dcl 192 in procedure "DESIRED" set ref 210* 212 212 214 225 225 227 228 228 229 kk 001222 automatic fixed bin(17,0) dcl 289 in begin block on line 286 set ref 290* 291 293 294 last_def 2 001104 automatic pointer level 2 dcl 275 set ref 281* length builtin function dcl 449 ref 196 link_trap_caller_ 000064 constant entry external dcl 348 ref 359 maxlength builtin function dcl 26 ref 216 216 225 225 meters 000604 automatic structure level 1 dcl 4-157 n_specified 000130 automatic fixed bin(17,0) dcl 393 set ref 134* 147* 147 174* 174 181 next_def 000356 automatic pointer level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" set ref 57* 128* 150* 154* 161* 177* next_def 001104 automatic pointer level 2 in structure "def" dcl 275 in procedure "DEFINITION" set ref 280* null builtin function dcl 26 ref 37 37 103 103 131 131 158 158 181 181 200 200 204 204 212 212 216 216 225 225 246 246 249 249 264 264 280 281 282 284 307 307 object 000474 automatic structure level 1 dcl 437 set ref 49* 53* 57* 59* 63* 63* 63* 108* 117* 119* 126* 128* 137* 144* 150* 154* 161* 164* 171* 177* object_i parameter structure level 1 dcl 303 in procedure "ENTRY_NAME" set ref 301 306* object_i parameter structure level 1 dcl 274 in procedure "DEFINITION" set ref 271 277 277 object_info based structure level 1 dcl 2-6 object_info_$brief 000056 constant entry external dcl 260 ref 263 object_info_version_2 constant fixed bin(17,0) initial dcl 2-60 ref 262 offset 7 000356 automatic fixed bin(18,0) level 2 dcl 411 set ref 54 118 139 143 166 170 offset_definition_i parameter structure level 1 dcl 304 set ref 301 offset_symbol 125 000632 automatic varying char(32) level 2 in structure "des" dcl 193 in procedure "DESIRED" set ref 198* 216 220* 225 228* offset_symbol 125 000132 automatic varying char(32) level 2 in structure "desired" dcl 396 in procedure "trace_entrypoints_" set ref 110 114 141 141 168 168 oi 001010 automatic structure level 1 dcl 259 set ref 261* 263 263 267 output_switch based structure level 1 dcl 4-162 path 000632 automatic char(300) level 2 in structure "des" packed unaligned dcl 193 in procedure "DESIRED" set ref 195* 196 203 204* 210 212* 216* 219 220 222* 225* 227 228 230* 233* path 000132 automatic char(300) level 2 in structure "desired" packed unaligned dcl 396 in procedure "trace_entrypoints_" set ref 89* 158* pathl 113 000632 automatic fixed bin(17,0) level 2 dcl 193 set ref 196* 200 203 208 210 212 216 216 219 220 221* 221 222 225 228 229* 230 233 pathname 000270 automatic structure level 1 dcl 402 pointer builtin function dcl 26 ref 34 34 37 37 72 72 99 244 referencing_ptr_i parameter pointer dcl 383 set ref 78 89* rel builtin function dcl 26 ref 50 73 73 75 75 reverse builtin function dcl 26 ref 203 rtrim builtin function dcl 26 ref 42 42 73 196 rv 000131 automatic fixed bin(35,0) dcl 394 set ref 37* 103* 131* 158* 181* 200* 204* 212* 216* 225* 246* 249* 264* 307* search builtin function dcl 26 ref 203 210 section 6 001104 automatic char(4) level 2 in structure "def" dcl 275 in procedure "DEFINITION" set ref 283* 286 section 6 001232 automatic char(4) level 2 in structure "segment_definition" dcl 305 in procedure "ENTRY_NAME" set ref 307 section 6 000356 automatic char(4) level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" set ref 54 55 127 131 138 139 155 158 165 165 166 seg 000776 automatic structure level 1 dcl 242 set ref 252 segment 000352 automatic structure level 1 dcl 406 set ref 48* 49* 107* 108* segment_definition 001232 automatic structure level 1 dcl 305 set ref 306* segment_i parameter structure level 1 dcl 258 set ref 256 segment_symbol 114 000132 automatic varying char(32) level 2 in structure "desired" dcl 396 in procedure "trace_entrypoints_" set ref 97 114 135 155 158* segment_symbol 114 000632 automatic varying char(32) level 2 in structure "des" dcl 193 in procedure "DESIRED" set ref 197* 216 219* 225 227* stop_proc based structure level 1 dcl 4-167 sub_err_ 000040 constant entry external dcl 481 ref 37 103 131 158 181 200 204 212 216 225 246 249 264 307 substr builtin function dcl 26 set ref 135 141 155 168 203 210 219 220 222* 227 228 230* 233* 290 294 307 307 311 311 359 359 359 359 359 359 359 359 359 359 359 359 359 symbol 11 001232 automatic char(256) level 2 in structure "segment_definition" dcl 305 in procedure "ENTRY_NAME" set ref 311 symbol 11 001104 automatic char(256) level 2 in structure "def" dcl 275 in procedure "DEFINITION" set ref 290 294* 294 symbol 11 parameter char(256) level 2 in structure "offset_definition_i" dcl 304 in procedure "ENTRY_NAME" ref 307 307 311 symbol 11 000356 automatic char(256) level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" set ref 135 141 155 168 symbol_lng 111 000356 automatic fixed bin(17,0) level 2 in structure "definition" dcl 411 in procedure "trace_entrypoints_" set ref 135 141 155 168 symbol_lng 111 001104 automatic fixed bin(17,0) level 2 in structure "def" dcl 275 in procedure "DEFINITION" set ref 290 293* 293 294 symbol_lng 111 parameter fixed bin(17,0) level 2 in structure "offset_definition_i" dcl 304 in procedure "ENTRY_NAME" ref 307 307 311 symbol_lng 111 001232 automatic fixed bin(17,0) level 2 in structure "segment_definition" dcl 305 in procedure "ENTRY_NAME" set ref 311 textp 2 000474 automatic pointer level 2 dcl 437 set ref 118 143 170 trace_$entrypoint_name 000044 constant entry external dcl 4-50 ref 97 trace_$entrypoint_ptr 000046 constant entry external dcl 4-51 ref 99 trace_$me 000042 constant entry external dcl 4-7 ref 37 37 103 103 131 131 158 158 181 181 200 200 204 204 212 212 216 216 225 225 246 246 249 249 264 264 307 307 trace_$num_entrypoints 000050 constant entry external dcl 4-55 ref 95 trace_tables_$add_entrypoint 000032 constant entry external dcl 478 ref 66 76 trace_tables_$specify_all_entrypoints 000034 constant entry external dcl 479 ref 83 trace_tables_$specify_entrypoint 000036 constant entry external dcl 480 ref 120 145 172 translator_id 001416 automatic fixed bin(17,0) dcl 345 set ref 355* 357* 359* 373 tt_count 000617 automatic fixed bin(17,0) dcl 93 set ref 95* 96 tt_idx 000620 automatic fixed bin(17,0) dcl 94 set ref 96* 96* 97* 99* unspec builtin function dcl 26 set ref 261* 279* 333* unwind_stack_ 000066 constant entry external dcl 349 ref 359 unwinder_ 000070 constant entry external dcl 350 ref 359 version based fixed bin(17,0) level 2 dcl 1-34 set ref 334* version_number 001010 automatic fixed bin(17,0) level 2 dcl 259 set ref 262* watch_values 000576 automatic structure level 1 dcl 4-147 word based bit(36) array dcl 460 ref 51 355 359 359 359 359 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 3-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 3-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 3-7 COMPENSATION_FROM_ENTRY_TO_ENTRY internal static fixed bin(17,0) initial dcl 4-175 COMPENSATION_FROM_ENTRY_TO_RETURN internal static fixed bin(17,0) initial dcl 4-175 COMPENSATION_FROM_RETURN_TO_ENTRY internal static fixed bin(17,0) initial dcl 4-175 COMPENSATION_FROM_RETURN_TO_RETURN internal static fixed bin(17,0) initial dcl 4-175 trace_$add_specified_eps 000000 constant entry external dcl 4-20 trace_$add_specified_locs 000000 constant entry external dcl 4-21 trace_$alm 000000 constant entry external dcl 4-111 trace_$arguments 000000 constant entry external dcl 4-82 trace_$automatic 000000 constant entry external dcl 4-113 trace_$buffer 000000 constant entry external dcl 4-115 trace_$buffer_counts 000000 constant entry external dcl 4-74 trace_$buffer_event 000000 constant entry external dcl 4-75 trace_$buffer_event_header 000000 constant entry external dcl 4-76 trace_$buffer_event_string 000000 constant entry external dcl 4-77 trace_$buffer_ptr 000000 constant entry external dcl 4-78 trace_$calibrate 000000 constant entry external dcl 4-117 trace_$call 000000 constant entry external dcl 4-84 trace_$compensation 000000 constant entry external dcl 4-119 trace_$cv_bit_to_onoff 000000 constant entry external dcl 4-33 trace_$cv_bits_to_inout 000000 constant entry external dcl 4-30 trace_$cv_entry_name_to_spp 000000 constant entry external dcl 4-34 trace_$cv_file_path_to_osw 000000 constant entry external dcl 4-35 trace_$cv_inout_to_bits 000000 constant entry external dcl 4-29 trace_$cv_n_to_number 000000 constant entry external dcl 4-31 trace_$cv_onoff_to_bit 000000 constant entry external dcl 4-32 trace_$cv_stream_name_to_osw 000000 constant entry external dcl 4-36 trace_$enabled 000000 constant entry external dcl 4-121 trace_$entrypoint_counts 000000 constant entry external dcl 4-40 trace_$entrypoint_global_meters 000000 constant entry external dcl 4-41 trace_$entrypoint_index 000000 constant entry external dcl 4-49 trace_$entrypoint_local_meters 000000 constant entry external dcl 4-42 trace_$entrypoint_seg_path 000000 constant entry external dcl 4-52 trace_$entrypoint_status 000000 constant entry external dcl 4-53 trace_$every 000000 constant entry external dcl 4-86 trace_$first 000000 constant entry external dcl 4-88 trace_$function 000000 constant entry external dcl 4-54 trace_$global_parms_string 000000 constant entry external dcl 4-123 trace_$high 000000 constant entry external dcl 4-90 trace_$in_trace 000000 constant entry external dcl 4-143 trace_$last 000000 constant entry external dcl 4-92 trace_$location_ptr 000000 constant entry external dcl 4-63 trace_$location_seg_path 000000 constant entry external dcl 4-64 trace_$location_values 000000 constant entry external dcl 4-65 trace_$long 000000 constant entry external dcl 4-124 trace_$loud 000000 constant entry external dcl 4-138 trace_$low 000000 constant entry external dcl 4-94 trace_$meter 000000 constant entry external dcl 4-126 trace_$metered 000000 constant entry external dcl 4-43 trace_$new_high 000000 constant entry external dcl 4-96 trace_$num_locations 000000 constant entry external dcl 4-66 trace_$num_specified_entrypoints 000000 constant entry external dcl 4-56 trace_$num_specified_locations 000000 constant entry external dcl 4-67 trace_$output_switch 000000 constant entry external dcl 4-128 trace_$parms_specified 000000 constant entry external dcl 4-99 trace_$parms_string 000000 constant entry external dcl 4-98 trace_$remove_specified_eps 000000 constant entry external dcl 4-22 trace_$remove_specified_locs 000000 constant entry external dcl 4-23 trace_$removed 000000 constant entry external dcl 4-44 trace_$reset_meters 000000 constant entry external dcl 4-45 trace_$set_alm 000000 constant entry external dcl 4-112 trace_$set_arguments 000000 constant entry external dcl 4-83 trace_$set_automatic 000000 constant entry external dcl 4-114 trace_$set_buffer 000000 constant entry external dcl 4-116 trace_$set_calibrate 000000 constant entry external dcl 4-118 trace_$set_call 000000 constant entry external dcl 4-85 trace_$set_compensation 000000 constant entry external dcl 4-120 trace_$set_enabled 000000 constant entry external dcl 4-122 trace_$set_every 000000 constant entry external dcl 4-87 trace_$set_first 000000 constant entry external dcl 4-89 trace_$set_high 000000 constant entry external dcl 4-91 trace_$set_last 000000 constant entry external dcl 4-93 trace_$set_long 000000 constant entry external dcl 4-125 trace_$set_loud 000000 constant entry external dcl 4-139 trace_$set_low 000000 constant entry external dcl 4-95 trace_$set_meter 000000 constant entry external dcl 4-127 trace_$set_new_high 000000 constant entry external dcl 4-97 trace_$set_output_switch 000000 constant entry external dcl 4-129 trace_$set_signals 000000 constant entry external dcl 4-131 trace_$set_stop 000000 constant entry external dcl 4-101 trace_$set_stop_every 000000 constant entry external dcl 4-103 trace_$set_stop_low 000000 constant entry external dcl 4-105 trace_$set_stop_proc 000000 constant entry external dcl 4-133 trace_$set_stop_routine 000000 constant entry external dcl 4-135 trace_$set_trace 000000 constant entry external dcl 4-107 trace_$set_trace_routine 000000 constant entry external dcl 4-137 trace_$signals 000000 constant entry external dcl 4-130 trace_$specified_entrypoint_index 000000 constant entry external dcl 4-57 trace_$specified_location_index 000000 constant entry external dcl 4-68 trace_$specify_changed_locations 000000 constant entry external dcl 4-70 trace_$specify_entrypoints 000000 constant entry external dcl 4-58 trace_$specify_locations 000000 constant entry external dcl 4-69 trace_$stop 000000 constant entry external dcl 4-100 trace_$stop_every 000000 constant entry external dcl 4-102 trace_$stop_low 000000 constant entry external dcl 4-104 trace_$stop_proc 000000 constant entry external dcl 4-132 trace_$stop_routine 000000 constant entry external dcl 4-134 trace_$trace 000000 constant entry external dcl 4-106 trace_$trace_routine 000000 constant entry external dcl 4-136 trace_$transaction_begin 000000 constant entry external dcl 4-12 trace_$transaction_begin_force 000000 constant entry external dcl 4-13 trace_$transaction_end 000000 constant entry external dcl 4-14 trace_$translator_id 000000 constant entry external dcl 4-59 trace_$turn_off_specified_eps 000000 constant entry external dcl 4-25 trace_$turn_on_specified_eps 000000 constant entry external dcl 4-24 trace_$update_default_parms 000000 constant entry external dcl 4-18 trace_$update_global_parms 000000 constant entry external dcl 4-19 trace_$version 000000 constant entry external dcl 4-8 NAMES DECLARED BY EXPLICIT CONTEXT. ADD_ENTRYPOINT_PUNT 001110 constant label dcl 70 ref 47 55 DEFINITION 003564 constant entry internal dcl 271 ref 53 57 63 63 117 126 128 137 150 154 161 164 177 306 DESIRED 002464 constant entry internal dcl 188 ref 87 ENTRY_NAME 003667 constant entry internal dcl 301 ref 59 63 119 144 171 FUNCTION 004107 constant entry internal dcl 326 ref 66 66 120 120 145 145 172 172 OBJECT 003434 constant entry internal dcl 256 ref 49 108 OCTAL 004045 constant entry internal dcl 316 ref 73 75 75 SEGMENT 003243 constant entry internal dcl 239 ref 48 107 TRANSLATOR_ID 004167 constant entry internal dcl 341 ref 66 66 120 120 145 145 172 172 add_entrypoint 000705 constant entry external dcl 44 get_path_name 000427 constant entry external dcl 32 ref 264 specify_entrypoints 001352 constant entry external dcl 78 trace_entrypoints_ 000410 constant entry external dcl 23 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 5562 5654 5212 5572 Length 6206 5212 72 316 350 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME trace_entrypoints_ 1912 external procedure is an external procedure. on unit on line 47 64 on unit begin block on line 90 begin block shares stack frame of external procedure trace_entrypoints_. begin block on line 110 begin block shares stack frame of external procedure trace_entrypoints_. DESIRED internal procedure shares stack frame of external procedure trace_entrypoints_. SEGMENT internal procedure shares stack frame of external procedure trace_entrypoints_. OBJECT internal procedure shares stack frame of external procedure trace_entrypoints_. DEFINITION internal procedure shares stack frame of external procedure trace_entrypoints_. begin block on line 286 begin block shares stack frame of external procedure trace_entrypoints_. ENTRY_NAME internal procedure shares stack frame of external procedure trace_entrypoints_. OCTAL internal procedure shares stack frame of external procedure trace_entrypoints_. FUNCTION internal procedure shares stack frame of external procedure trace_entrypoints_. TRANSLATOR_ID internal procedure shares stack frame of external procedure trace_entrypoints_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME trace_entrypoints_ 000100 code trace_entrypoints_ 000102 defptr trace_entrypoints_ 000104 entry_name trace_entrypoints_ 000126 entry_ptr trace_entrypoints_ 000127 entry_ptr_offset trace_entrypoints_ 000130 n_specified trace_entrypoints_ 000131 rv trace_entrypoints_ 000132 desired trace_entrypoints_ 000270 pathname trace_entrypoints_ 000352 segment trace_entrypoints_ 000356 definition trace_entrypoints_ 000474 object trace_entrypoints_ 000576 watch_values trace_entrypoints_ 000600 counts trace_entrypoints_ 000604 meters trace_entrypoints_ 000612 compensation trace_entrypoints_ 000617 tt_count begin block on line 90 000620 tt_idx begin block on line 90 000630 jj DESIRED 000631 kk DESIRED 000632 des DESIRED 000776 seg SEGMENT 001010 oi OBJECT 001104 def DEFINITION 001222 kk begin block on line 286 001232 segment_definition ENTRY_NAME 001356 char32var OCTAL 001367 dummy OCTAL 001376 desc_ptrs FUNCTION 001400 edi FUNCTION 001406 entry_desc_info_ptr FUNCTION 001416 translator_id TRANSLATOR_ID 001417 entry_name TRANSLATOR_ID 001440 entry_ptr TRANSLATOR_ID THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a alloc_cs cat_realloc_cs call_ext_in call_ext_out_desc call_ext_out begin_return return tra_ext signal enable shorten_stack ext_entry int_entry any_to_any_tr THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cv_entry_ decode_definition_$full get_definition_ get_entry_arg_descs_$info hcs_$fs_get_path_name hcs_$status_mins ioa_$rsnnl link_trap_caller_ object_info_$brief sub_err_ trace_$entrypoint_name trace_$entrypoint_ptr trace_$me trace_$num_entrypoints trace_tables_$add_entrypoint trace_tables_$specify_all_entrypoints trace_tables_$specify_entrypoint unwind_stack_ unwinder_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$badpath error_table_$bigarg error_table_$no_ext_sym error_table_$seg_not_found error_table_$smallarg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 23 000407 29 000417 32 000422 34 000436 35 000501 37 000503 39 000567 40 000572 42 000575 44 000701 46 000713 47 000723 48 000742 49 000750 50 000755 51 000760 53 000767 54 000774 55 001002 57 001007 58 001014 59 001015 60 001017 62 001020 63 001026 66 001035 70 001110 72 001111 73 001147 75 001223 76 001272 78 001346 81 001361 83 001370 84 001375 87 001407 89 001422 90 001452 95 001455 96 001464 97 001475 99 001520 100 001533 101 001534 102 001535 103 001537 107 001614 108 001622 110 001627 114 001634 115 001704 117 001707 118 001714 119 001720 120 001723 122 001744 126 001760 127 001765 128 001776 129 002003 131 002004 134 002063 135 002064 137 002075 138 002102 139 002107 141 002114 143 002127 144 002132 145 002135 147 002156 150 002157 151 002164 152 002165 154 002166 155 002173 158 002205 161 002272 162 002277 164 002300 165 002305 166 002316 168 002323 170 002336 171 002341 172 002344 174 002365 177 002366 178 002373 181 002374 183 002452 188 002464 195 002466 196 002473 197 002505 198 002506 200 002507 203 002557 204 002572 206 002647 208 002654 210 002660 212 002677 214 002763 216 002765 219 003046 220 003057 221 003067 222 003071 223 003075 225 003076 227 003160 228 003172 229 003210 230 003213 233 003223 235 003232 239 003243 244 003245 245 003250 246 003266 249 003343 252 003421 256 003434 261 003436 262 003441 263 003443 264 003464 267 003553 271 003564 277 003566 279 003615 280 003620 281 003622 282 003623 283 003624 284 003626 285 003630 286 003631 290 003634 291 003646 293 003647 294 003651 297 003656 301 003667 306 003671 307 003710 311 004004 316 004045 321 004047 322 004077 326 004107 332 004111 333 004113 334 004116 335 004120 336 004160 341 004167 352 004171 353 004176 355 004204 357 004212 359 004213 373 004350 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved