1/* Return line number information of CU. 2 Copyright (C) 2004-2010 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 Written by Ulrich Drepper <drepper@redhat.com>, 2004. 5 6 Red Hat elfutils is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by the 8 Free Software Foundation; version 2 of the License. 9 10 Red Hat elfutils is distributed in the hope that it will be useful, but 11 WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 You should have received a copy of the GNU General Public License along 16 with Red Hat elfutils; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 18 19 In addition, as a special exception, Red Hat, Inc. gives You the 20 additional right to link the code of Red Hat elfutils with code licensed 21 under any Open Source Initiative certified open source license 22 (http://www.opensource.org/licenses/index.php) which requires the 23 distribution of source code with any binary distribution and to 24 distribute linked combinations of the two. Non-GPL Code permitted under 25 this exception must only link to the code of Red Hat elfutils through 26 those well defined interfaces identified in the file named EXCEPTION 27 found in the source code files (the "Approved Interfaces"). The files 28 of Non-GPL Code may instantiate templates or use macros or inline 29 functions from the Approved Interfaces without causing the resulting 30 work to be covered by the GNU General Public License. Only Red Hat, 31 Inc. may make changes or additions to the list of Approved Interfaces. 32 Red Hat's grant of this exception is conditioned upon your not adding 33 any new exceptions. If you wish to add a new Approved Interface or 34 exception, please contact Red Hat. You must obey the GNU General Public 35 License in all respects for all of the Red Hat elfutils code and other 36 code used in conjunction with Red Hat elfutils except the Non-GPL Code 37 covered by this exception. If you modify this file, you may extend this 38 exception to your version of the file, but you are not obligated to do 39 so. If you do not wish to provide this exception without modification, 40 you must delete this exception statement from your version and license 41 this file solely under the GPL without exception. 42 43 Red Hat elfutils is an included package of the Open Invention Network. 44 An included package of the Open Invention Network is a package for which 45 Open Invention Network licensees cross-license their patents. No patent 46 license is granted, either expressly or impliedly, by designation as an 47 included package. Should you wish to participate in the Open Invention 48 Network licensing program, please visit www.openinventionnetwork.com 49 <http://www.openinventionnetwork.com>. */ 50 51#ifdef HAVE_CONFIG_H 52# include <config.h> 53#endif 54 55#include <assert.h> 56#include <stdlib.h> 57#include <string.h> 58#include "dwarf.h" 59#include "libdwP.h" 60 61 62struct filelist 63{ 64 Dwarf_Fileinfo info; 65 struct filelist *next; 66}; 67 68struct linelist 69{ 70 Dwarf_Line line; 71 struct linelist *next; 72}; 73 74 75/* Compare by Dwarf_Line.addr, given pointers into an array of pointers. */ 76static int 77compare_lines (const void *a, const void *b) 78{ 79 Dwarf_Line *const *p1 = a; 80 Dwarf_Line *const *p2 = b; 81 82 if ((*p1)->addr == (*p2)->addr) 83 /* An end_sequence marker precedes a normal record at the same address. */ 84 return (*p2)->end_sequence - (*p1)->end_sequence; 85 86 return (*p1)->addr - (*p2)->addr; 87} 88 89int 90dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines, size_t *nlines) 91{ 92 if (unlikely (cudie == NULL 93 || INTUSE(dwarf_tag) (cudie) != DW_TAG_compile_unit)) 94 return -1; 95 96 int res = -1; 97 98 /* Get the information if it is not already known. */ 99 struct Dwarf_CU *const cu = cudie->cu; 100 if (cu->lines == NULL) 101 { 102 /* Failsafe mode: no data found. */ 103 cu->lines = (void *) -1l; 104 cu->files = (void *) -1l; 105 106 /* The die must have a statement list associated. */ 107 Dwarf_Attribute stmt_list_mem; 108 Dwarf_Attribute *stmt_list = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, 109 &stmt_list_mem); 110 111 /* Get the offset into the .debug_line section. NB: this call 112 also checks whether the previous dwarf_attr call failed. */ 113 const unsigned char *lineendp; 114 const unsigned char *linep 115 = __libdw_formptr (stmt_list, IDX_debug_line, DWARF_E_NO_DEBUG_LINE, 116 (unsigned char **) &lineendp, NULL); 117 if (linep == NULL) 118 goto out; 119 120 /* Get the compilation directory. */ 121 Dwarf_Attribute compdir_attr_mem; 122 Dwarf_Attribute *compdir_attr = INTUSE(dwarf_attr) (cudie, 123 DW_AT_comp_dir, 124 &compdir_attr_mem); 125 const char *comp_dir = INTUSE(dwarf_formstring) (compdir_attr); 126 127 if (unlikely (linep + 4 > lineendp)) 128 { 129 invalid_data: 130 __libdw_seterrno (DWARF_E_INVALID_DEBUG_LINE); 131 goto out; 132 } 133 134 Dwarf *dbg = cu->dbg; 135 Dwarf_Word unit_length = read_4ubyte_unaligned_inc (dbg, linep); 136 unsigned int length = 4; 137 if (unlikely (unit_length == DWARF3_LENGTH_64_BIT)) 138 { 139 if (unlikely (linep + 8 > lineendp)) 140 goto invalid_data; 141 unit_length = read_8ubyte_unaligned_inc (dbg, linep); 142 length = 8; 143 } 144 145 /* Check whether we have enough room in the section. */ 146 if (unit_length < 2 + length + 5 * 1 147 || unlikely (linep + unit_length > lineendp)) 148 goto invalid_data; 149 lineendp = linep + unit_length; 150 151 /* The next element of the header is the version identifier. */ 152 uint_fast16_t version = read_2ubyte_unaligned_inc (dbg, linep); 153 if (unlikely (version < 2) || unlikely (version > 4)) 154 { 155 __libdw_seterrno (DWARF_E_VERSION); 156 goto out; 157 } 158 159 /* Next comes the header length. */ 160 Dwarf_Word header_length; 161 if (length == 4) 162 header_length = read_4ubyte_unaligned_inc (dbg, linep); 163 else 164 header_length = read_8ubyte_unaligned_inc (dbg, linep); 165 const unsigned char *header_start = linep; 166 167 /* Next the minimum instruction length. */ 168 uint_fast8_t minimum_instr_len = *linep++; 169 170 /* Next the maximum operations per instruction, in version 4 format. */ 171 uint_fast8_t max_ops_per_instr = 1; 172 if (version >= 4) 173 { 174 if (unlikely (lineendp - linep < 5)) 175 goto invalid_data; 176 max_ops_per_instr = *linep++; 177 if (unlikely (max_ops_per_instr == 0)) 178 goto invalid_data; 179 } 180 181 /* Then the flag determining the default value of the is_stmt 182 register. */ 183 uint_fast8_t default_is_stmt = *linep++; 184 185 /* Now the line base. */ 186 int_fast8_t line_base = (int8_t) *linep++; 187 188 /* And the line range. */ 189 uint_fast8_t line_range = *linep++; 190 191 /* The opcode base. */ 192 uint_fast8_t opcode_base = *linep++; 193 194 /* Remember array with the standard opcode length (-1 to account for 195 the opcode with value zero not being mentioned). */ 196 const uint8_t *standard_opcode_lengths = linep - 1; 197 if (unlikely (lineendp - linep < opcode_base - 1)) 198 goto invalid_data; 199 linep += opcode_base - 1; 200 201 /* First comes the list of directories. Add the compilation 202 directory first since the index zero is used for it. */ 203 struct dirlist 204 { 205 const char *dir; 206 size_t len; 207 struct dirlist *next; 208 } comp_dir_elem = 209 { 210 .dir = comp_dir, 211 .len = comp_dir ? strlen (comp_dir) : 0, 212 .next = NULL 213 }; 214 struct dirlist *dirlist = &comp_dir_elem; 215 unsigned int ndirlist = 1; 216 217 // XXX Directly construct array to conserve memory? 218 while (*linep != 0) 219 { 220 struct dirlist *new_dir = 221 (struct dirlist *) alloca (sizeof (*new_dir)); 222 223 new_dir->dir = (char *) linep; 224 uint8_t *endp = memchr (linep, '\0', lineendp - linep); 225 if (endp == NULL) 226 goto invalid_data; 227 new_dir->len = endp - linep; 228 new_dir->next = dirlist; 229 dirlist = new_dir; 230 ++ndirlist; 231 linep = endp + 1; 232 } 233 /* Skip the final NUL byte. */ 234 ++linep; 235 236 /* Rearrange the list in array form. */ 237 struct dirlist **dirarray 238 = (struct dirlist **) alloca (ndirlist * sizeof (*dirarray)); 239 for (unsigned int n = ndirlist; n-- > 0; dirlist = dirlist->next) 240 dirarray[n] = dirlist; 241 242 /* Now read the files. */ 243 struct filelist null_file = 244 { 245 .info = 246 { 247 .name = "???", 248 .mtime = 0, 249 .length = 0 250 }, 251 .next = NULL 252 }; 253 struct filelist *filelist = &null_file; 254 unsigned int nfilelist = 1; 255 256 if (unlikely (linep >= lineendp)) 257 goto invalid_data; 258 while (*linep != 0) 259 { 260 struct filelist *new_file = 261 (struct filelist *) alloca (sizeof (*new_file)); 262 263 /* First comes the file name. */ 264 char *fname = (char *) linep; 265 uint8_t *endp = memchr (fname, '\0', lineendp - linep); 266 if (endp == NULL) 267 goto invalid_data; 268 size_t fnamelen = endp - (uint8_t *) fname; 269 linep = endp + 1; 270 271 /* Then the index. */ 272 Dwarf_Word diridx; 273 get_uleb128 (diridx, linep); 274 if (unlikely (diridx >= ndirlist)) 275 { 276 __libdw_seterrno (DWARF_E_INVALID_DIR_IDX); 277 goto out; 278 } 279 280 if (*fname == '/') 281 /* It's an absolute path. */ 282 new_file->info.name = fname; 283 else 284 { 285 new_file->info.name = libdw_alloc (dbg, char, 1, 286 dirarray[diridx]->len + 1 287 + fnamelen + 1); 288 char *cp = new_file->info.name; 289 290 if (dirarray[diridx]->dir != NULL) 291 { 292 /* This value could be NULL in case the DW_AT_comp_dir 293 was not present. We cannot do much in this case. 294 The easiest thing is to convert the path in an 295 absolute path. */ 296 cp = stpcpy (cp, dirarray[diridx]->dir); 297 } 298 *cp++ = '/'; 299 strcpy (cp, fname); 300 assert (strlen (new_file->info.name) 301 < dirarray[diridx]->len + 1 + fnamelen + 1); 302 } 303 304 /* Next comes the modification time. */ 305 get_uleb128 (new_file->info.mtime, linep); 306 307 /* Finally the length of the file. */ 308 get_uleb128 (new_file->info.length, linep); 309 310 new_file->next = filelist; 311 filelist = new_file; 312 ++nfilelist; 313 } 314 /* Skip the final NUL byte. */ 315 ++linep; 316 317 /* Consistency check. */ 318 if (unlikely (linep != header_start + header_length)) 319 { 320 __libdw_seterrno (DWARF_E_INVALID_DWARF); 321 goto out; 322 } 323 324 /* We are about to process the statement program. Initialize the 325 state machine registers (see 6.2.2 in the v2.1 specification). */ 326 Dwarf_Word addr = 0; 327 unsigned int op_index = 0; 328 unsigned int file = 1; 329 int line = 1; 330 unsigned int column = 0; 331 uint_fast8_t is_stmt = default_is_stmt; 332 bool basic_block = false; 333 bool prologue_end = false; 334 bool epilogue_begin = false; 335 unsigned int isa = 0; 336 unsigned int discriminator = 0; 337 338 /* Apply the "operation advance" from a special opcode 339 or DW_LNS_advance_pc (as per DWARF4 6.2.5.1). */ 340 inline void advance_pc (unsigned int op_advance) 341 { 342 addr += minimum_instr_len * ((op_index + op_advance) 343 / max_ops_per_instr); 344 op_index = (op_index + op_advance) % max_ops_per_instr; 345 } 346 347 /* Process the instructions. */ 348 struct linelist *linelist = NULL; 349 unsigned int nlinelist = 0; 350 351 /* Adds a new line to the matrix. 352 We cannot simply define a function because we want to use alloca. */ 353#define NEW_LINE(end_seq) \ 354 do { \ 355 if (unlikely (add_new_line (alloca (sizeof (struct linelist)), \ 356 end_seq))) \ 357 goto invalid_data; \ 358 } while (0) 359 360 inline bool add_new_line (struct linelist *new_line, bool end_sequence) 361 { 362 /* Set the line information. For some fields we use bitfields, 363 so we would lose information if the encoded values are too large. 364 Check just for paranoia, and call the data "invalid" if it 365 violates our assumptions on reasonable limits for the values. */ 366#define SET(field) \ 367 do { \ 368 new_line->line.field = field; \ 369 if (unlikely (new_line->line.field != field)) \ 370 return true; \ 371 } while (0) 372 373 SET (addr); 374 SET (op_index); 375 SET (file); 376 SET (line); 377 SET (column); 378 SET (is_stmt); 379 SET (basic_block); 380 SET (end_sequence); 381 SET (prologue_end); 382 SET (epilogue_begin); 383 SET (isa); 384 SET (discriminator); 385 386#undef SET 387 388 new_line->next = linelist; 389 linelist = new_line; 390 ++nlinelist; 391 392 return false; 393 } 394 395 while (linep < lineendp) 396 { 397 unsigned int opcode; 398 unsigned int u128; 399 int s128; 400 401 /* Read the opcode. */ 402 opcode = *linep++; 403 404 /* Is this a special opcode? */ 405 if (likely (opcode >= opcode_base)) 406 { 407 /* Yes. Handling this is quite easy since the opcode value 408 is computed with 409 410 opcode = (desired line increment - line_base) 411 + (line_range * address advance) + opcode_base 412 */ 413 int line_increment = (line_base 414 + (opcode - opcode_base) % line_range); 415 416 /* Perform the increments. */ 417 line += line_increment; 418 advance_pc ((opcode - opcode_base) / line_range); 419 420 /* Add a new line with the current state machine values. */ 421 NEW_LINE (0); 422 423 /* Reset the flags. */ 424 basic_block = false; 425 prologue_end = false; 426 epilogue_begin = false; 427 discriminator = 0; 428 } 429 else if (opcode == 0) 430 { 431 /* This an extended opcode. */ 432 if (unlikely (lineendp - linep < 2)) 433 goto invalid_data; 434 435 /* The length. */ 436 uint_fast8_t len = *linep++; 437 438 if (unlikely ((size_t) (lineendp - linep) < len)) 439 goto invalid_data; 440 441 /* The sub-opcode. */ 442 opcode = *linep++; 443 444 switch (opcode) 445 { 446 case DW_LNE_end_sequence: 447 /* Add a new line with the current state machine values. 448 The is the end of the sequence. */ 449 NEW_LINE (1); 450 451 /* Reset the registers. */ 452 addr = 0; 453 op_index = 0; 454 file = 1; 455 line = 1; 456 column = 0; 457 is_stmt = default_is_stmt; 458 basic_block = false; 459 prologue_end = false; 460 epilogue_begin = false; 461 isa = 0; 462 discriminator = 0; 463 break; 464 465 case DW_LNE_set_address: 466 /* The value is an address. The size is defined as 467 apporiate for the target machine. We use the 468 address size field from the CU header. */ 469 op_index = 0; 470 if (unlikely (lineendp - linep < cu->address_size)) 471 goto invalid_data; 472 if (__libdw_read_address_inc (dbg, IDX_debug_line, &linep, 473 cu->address_size, &addr)) 474 goto out; 475 break; 476 477 case DW_LNE_define_file: 478 { 479 char *fname = (char *) linep; 480 uint8_t *endp = memchr (linep, '\0', lineendp - linep); 481 if (endp == NULL) 482 goto invalid_data; 483 size_t fnamelen = endp - linep; 484 linep = endp + 1; 485 486 unsigned int diridx; 487 get_uleb128 (diridx, linep); 488 Dwarf_Word mtime; 489 get_uleb128 (mtime, linep); 490 Dwarf_Word filelength; 491 get_uleb128 (filelength, linep); 492 493 struct filelist *new_file = 494 (struct filelist *) alloca (sizeof (*new_file)); 495 if (fname[0] == '/') 496 new_file->info.name = fname; 497 else 498 { 499 new_file->info.name = 500 libdw_alloc (dbg, char, 1, (dirarray[diridx]->len + 1 501 + fnamelen + 1)); 502 char *cp = new_file->info.name; 503 504 if (dirarray[diridx]->dir != NULL) 505 /* This value could be NULL in case the 506 DW_AT_comp_dir was not present. We 507 cannot do much in this case. The easiest 508 thing is to convert the path in an 509 absolute path. */ 510 cp = stpcpy (cp, dirarray[diridx]->dir); 511 *cp++ = '/'; 512 strcpy (cp, fname); 513 } 514 515 new_file->info.mtime = mtime; 516 new_file->info.length = filelength; 517 new_file->next = filelist; 518 filelist = new_file; 519 ++nfilelist; 520 } 521 break; 522 523 case DW_LNE_set_discriminator: 524 /* Takes one ULEB128 parameter, the discriminator. */ 525 if (unlikely (standard_opcode_lengths[opcode] != 1)) 526 goto invalid_data; 527 528 get_uleb128 (discriminator, linep); 529 break; 530 531 default: 532 /* Unknown, ignore it. */ 533 if (unlikely ((size_t) (lineendp - (linep - 1)) < len)) 534 goto invalid_data; 535 linep += len - 1; 536 break; 537 } 538 } 539 else if (opcode <= DW_LNS_set_isa) 540 { 541 /* This is a known standard opcode. */ 542 switch (opcode) 543 { 544 case DW_LNS_copy: 545 /* Takes no argument. */ 546 if (unlikely (standard_opcode_lengths[opcode] != 0)) 547 goto invalid_data; 548 549 /* Add a new line with the current state machine values. */ 550 NEW_LINE (0); 551 552 /* Reset the flags. */ 553 basic_block = false; 554 prologue_end = false; 555 epilogue_begin = false; 556 discriminator = 0; 557 break; 558 559 case DW_LNS_advance_pc: 560 /* Takes one uleb128 parameter which is added to the 561 address. */ 562 if (unlikely (standard_opcode_lengths[opcode] != 1)) 563 goto invalid_data; 564 565 get_uleb128 (u128, linep); 566 advance_pc (u128); 567 break; 568 569 case DW_LNS_advance_line: 570 /* Takes one sleb128 parameter which is added to the 571 line. */ 572 if (unlikely (standard_opcode_lengths[opcode] != 1)) 573 goto invalid_data; 574 575 get_sleb128 (s128, linep); 576 line += s128; 577 break; 578 579 case DW_LNS_set_file: 580 /* Takes one uleb128 parameter which is stored in file. */ 581 if (unlikely (standard_opcode_lengths[opcode] != 1)) 582 goto invalid_data; 583 584 get_uleb128 (u128, linep); 585 file = u128; 586 break; 587 588 case DW_LNS_set_column: 589 /* Takes one uleb128 parameter which is stored in column. */ 590 if (unlikely (standard_opcode_lengths[opcode] != 1)) 591 goto invalid_data; 592 593 get_uleb128 (u128, linep); 594 column = u128; 595 break; 596 597 case DW_LNS_negate_stmt: 598 /* Takes no argument. */ 599 if (unlikely (standard_opcode_lengths[opcode] != 0)) 600 goto invalid_data; 601 602 is_stmt = 1 - is_stmt; 603 break; 604 605 case DW_LNS_set_basic_block: 606 /* Takes no argument. */ 607 if (unlikely (standard_opcode_lengths[opcode] != 0)) 608 goto invalid_data; 609 610 basic_block = true; 611 break; 612 613 case DW_LNS_const_add_pc: 614 /* Takes no argument. */ 615 if (unlikely (standard_opcode_lengths[opcode] != 0)) 616 goto invalid_data; 617 618 advance_pc ((255 - opcode_base) / line_range); 619 break; 620 621 case DW_LNS_fixed_advance_pc: 622 /* Takes one 16 bit parameter which is added to the 623 address. */ 624 if (unlikely (standard_opcode_lengths[opcode] != 1) 625 || unlikely (lineendp - linep < 2)) 626 goto invalid_data; 627 628 addr += read_2ubyte_unaligned_inc (dbg, linep); 629 op_index = 0; 630 break; 631 632 case DW_LNS_set_prologue_end: 633 /* Takes no argument. */ 634 if (unlikely (standard_opcode_lengths[opcode] != 0)) 635 goto invalid_data; 636 637 prologue_end = true; 638 break; 639 640 case DW_LNS_set_epilogue_begin: 641 /* Takes no argument. */ 642 if (unlikely (standard_opcode_lengths[opcode] != 0)) 643 goto invalid_data; 644 645 epilogue_begin = true; 646 break; 647 648 case DW_LNS_set_isa: 649 /* Takes one uleb128 parameter which is stored in isa. */ 650 if (unlikely (standard_opcode_lengths[opcode] != 1)) 651 goto invalid_data; 652 653 get_uleb128 (isa, linep); 654 break; 655 } 656 } 657 else 658 { 659 /* This is a new opcode the generator but not we know about. 660 Read the parameters associated with it but then discard 661 everything. Read all the parameters for this opcode. */ 662 for (int n = standard_opcode_lengths[opcode]; n > 0; --n) 663 get_uleb128 (u128, linep); 664 665 /* Next round, ignore this opcode. */ 666 continue; 667 } 668 } 669 670 /* Put all the files in an array. */ 671 Dwarf_Files *files = libdw_alloc (dbg, Dwarf_Files, 672 sizeof (Dwarf_Files) 673 + nfilelist * sizeof (Dwarf_Fileinfo) 674 + (ndirlist + 1) * sizeof (char *), 675 1); 676 const char **dirs = (void *) &files->info[nfilelist]; 677 678 files->nfiles = nfilelist; 679 while (nfilelist-- > 0) 680 { 681 files->info[nfilelist] = filelist->info; 682 filelist = filelist->next; 683 } 684 assert (filelist == NULL); 685 686 /* Put all the directory strings in an array. */ 687 files->ndirs = ndirlist; 688 for (unsigned int i = 0; i < ndirlist; ++i) 689 dirs[i] = dirarray[i]->dir; 690 dirs[ndirlist] = NULL; 691 692 /* Remember the referring CU. */ 693 files->cu = cu; 694 695 /* Make the file data structure available through the CU. */ 696 cu->files = files; 697 698 void *buf = libdw_alloc (dbg, Dwarf_Lines, (sizeof (Dwarf_Lines) 699 + (sizeof (Dwarf_Line) 700 * nlinelist)), 1); 701 702 /* First use the buffer for the pointers, and sort the entries. 703 We'll write the pointers in the end of the buffer, and then 704 copy into the buffer from the beginning so the overlap works. */ 705 assert (sizeof (Dwarf_Line) >= sizeof (Dwarf_Line *)); 706 Dwarf_Line **sortlines = (buf + sizeof (Dwarf_Lines) 707 + ((sizeof (Dwarf_Line) 708 - sizeof (Dwarf_Line *)) * nlinelist)); 709 710 /* The list is in LIFO order and usually they come in clumps with 711 ascending addresses. So fill from the back to probably start with 712 runs already in order before we sort. */ 713 unsigned int i = nlinelist; 714 while (i-- > 0) 715 { 716 sortlines[i] = &linelist->line; 717 linelist = linelist->next; 718 } 719 assert (linelist == NULL); 720 721 /* Sort by ascending address. */ 722 qsort (sortlines, nlinelist, sizeof sortlines[0], &compare_lines); 723 724 /* Now that they are sorted, put them in the final array. 725 The buffers overlap, so we've clobbered the early elements 726 of SORTLINES by the time we're reading the later ones. */ 727 cu->lines = buf; 728 cu->lines->nlines = nlinelist; 729 for (i = 0; i < nlinelist; ++i) 730 { 731 cu->lines->info[i] = *sortlines[i]; 732 cu->lines->info[i].files = files; 733 } 734 735 /* Success. */ 736 res = 0; 737 } 738 else if (cu->lines != (void *) -1l) 739 /* We already have the information. */ 740 res = 0; 741 742 if (likely (res == 0)) 743 { 744 *lines = cu->lines; 745 *nlines = cu->lines->nlines; 746 } 747 out: 748 749 // XXX Eventually: unlocking here. 750 751 return res; 752} 753INTDEF(dwarf_getsrclines) 754