1 /*- 2 * Copyright (c) 2009,2011 Kai Wang 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include "_libdwarf.h" 28 29 ELFTC_VCSID("$Id: dwarf_frame.c 3106 2014-12-19 16:00:58Z kaiwang27 $"); 30 31 int 32 dwarf_get_fde_list(Dwarf_Debug dbg, Dwarf_Cie **cie_list, 33 Dwarf_Signed *cie_count, Dwarf_Fde **fde_list, Dwarf_Signed *fde_count, 34 Dwarf_Error *error) 35 { 36 37 if (dbg == NULL || cie_list == NULL || cie_count == NULL || 38 fde_list == NULL || fde_count == NULL) { 39 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 40 return (DW_DLV_ERROR); 41 } 42 43 if (dbg->dbg_internal_reg_table == NULL) { 44 if (_dwarf_frame_interal_table_init(dbg, error) != DW_DLE_NONE) 45 return (DW_DLV_ERROR); 46 } 47 48 if (dbg->dbg_frame == NULL) { 49 if (_dwarf_frame_section_load(dbg, error) != DW_DLE_NONE) 50 return (DW_DLV_ERROR); 51 if (dbg->dbg_frame == NULL) { 52 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 53 return (DW_DLV_NO_ENTRY); 54 } 55 } 56 57 if (dbg->dbg_frame->fs_ciearray == NULL || 58 dbg->dbg_frame->fs_fdearray == NULL) { 59 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 60 return (DW_DLV_NO_ENTRY); 61 } 62 63 *cie_list = dbg->dbg_frame->fs_ciearray; 64 *cie_count = dbg->dbg_frame->fs_cielen; 65 *fde_list = dbg->dbg_frame->fs_fdearray; 66 *fde_count = dbg->dbg_frame->fs_fdelen; 67 68 return (DW_DLV_OK); 69 } 70 71 int 72 dwarf_get_fde_list_eh(Dwarf_Debug dbg, Dwarf_Cie **cie_list, 73 Dwarf_Signed *cie_count, Dwarf_Fde **fde_list, Dwarf_Signed *fde_count, 74 Dwarf_Error *error) 75 { 76 77 if (dbg == NULL || cie_list == NULL || cie_count == NULL || 78 fde_list == NULL || fde_count == NULL) { 79 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 80 return (DW_DLV_ERROR); 81 } 82 83 if (dbg->dbg_internal_reg_table == NULL) { 84 if (_dwarf_frame_interal_table_init(dbg, error) != DW_DLE_NONE) 85 return (DW_DLV_ERROR); 86 } 87 88 if (dbg->dbg_eh_frame == NULL) { 89 if (_dwarf_frame_section_load_eh(dbg, error) != DW_DLE_NONE) 90 return (DW_DLV_ERROR); 91 if (dbg->dbg_eh_frame == NULL) { 92 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 93 return (DW_DLV_NO_ENTRY); 94 } 95 } 96 97 if (dbg->dbg_eh_frame->fs_ciearray == NULL || 98 dbg->dbg_eh_frame->fs_fdearray == NULL) { 99 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 100 return (DW_DLV_NO_ENTRY); 101 } 102 103 *cie_list = dbg->dbg_eh_frame->fs_ciearray; 104 *cie_count = dbg->dbg_eh_frame->fs_cielen; 105 *fde_list = dbg->dbg_eh_frame->fs_fdearray; 106 *fde_count = dbg->dbg_eh_frame->fs_fdelen; 107 108 return (DW_DLV_OK); 109 } 110 111 int 112 dwarf_get_fde_n(Dwarf_Fde *fdelist, Dwarf_Unsigned fde_index, 113 Dwarf_Fde *ret_fde, Dwarf_Error *error) 114 { 115 Dwarf_FrameSec fs; 116 Dwarf_Debug dbg; 117 118 dbg = fdelist != NULL ? (*fdelist)->fde_dbg : NULL; 119 120 if (fdelist == NULL || ret_fde == NULL) { 121 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 122 return (DW_DLV_ERROR); 123 } 124 125 fs = fdelist[0]->fde_fs; 126 assert(fs != NULL); 127 128 if (fde_index >= fs->fs_fdelen) { 129 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 130 return (DW_DLV_NO_ENTRY); 131 } 132 133 *ret_fde = fdelist[fde_index]; 134 135 return (DW_DLV_OK); 136 } 137 138 int 139 dwarf_get_fde_at_pc(Dwarf_Fde *fdelist, Dwarf_Addr pc, Dwarf_Fde *ret_fde, 140 Dwarf_Addr *lopc, Dwarf_Addr *hipc, Dwarf_Error *error) 141 { 142 Dwarf_FrameSec fs; 143 Dwarf_Debug dbg; 144 Dwarf_Fde fde; 145 int i; 146 147 dbg = fdelist != NULL ? (*fdelist)->fde_dbg : NULL; 148 149 if (fdelist == NULL || ret_fde == NULL || lopc == NULL || 150 hipc == NULL) { 151 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 152 return (DW_DLV_ERROR); 153 } 154 155 fs = fdelist[0]->fde_fs; 156 assert(fs != NULL); 157 158 for (i = 0; (Dwarf_Unsigned)i < fs->fs_fdelen; i++) { 159 fde = fdelist[i]; 160 if (pc >= fde->fde_initloc && pc < fde->fde_initloc + 161 fde->fde_adrange) { 162 *ret_fde = fde; 163 *lopc = fde->fde_initloc; 164 *hipc = fde->fde_initloc + fde->fde_adrange - 1; 165 return (DW_DLV_OK); 166 } 167 } 168 169 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY); 170 return (DW_DLV_NO_ENTRY); 171 } 172 173 int 174 dwarf_get_cie_of_fde(Dwarf_Fde fde, Dwarf_Cie *ret_cie, Dwarf_Error *error) 175 { 176 Dwarf_Debug dbg; 177 178 dbg = fde != NULL ? fde->fde_dbg : NULL; 179 180 if (fde == NULL || ret_cie == NULL) { 181 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 182 return (DW_DLV_ERROR); 183 } 184 185 *ret_cie = fde->fde_cie; 186 187 return (DW_DLV_OK); 188 } 189 190 int 191 dwarf_get_fde_range(Dwarf_Fde fde, Dwarf_Addr *low_pc, Dwarf_Unsigned *func_len, 192 Dwarf_Ptr *fde_bytes, Dwarf_Unsigned *fde_byte_len, Dwarf_Off *cie_offset, 193 Dwarf_Signed *cie_index, Dwarf_Off *fde_offset, Dwarf_Error *error) 194 { 195 Dwarf_Debug dbg; 196 197 dbg = fde != NULL ? fde->fde_dbg : NULL; 198 199 if (fde == NULL || low_pc == NULL || func_len == NULL || 200 fde_bytes == NULL || fde_byte_len == NULL || cie_offset == NULL || 201 cie_index == NULL || fde_offset == NULL) { 202 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 203 return (DW_DLV_ERROR); 204 } 205 206 *low_pc = fde->fde_initloc; 207 *func_len = fde->fde_adrange; 208 *fde_bytes = fde->fde_addr; 209 *fde_byte_len = fde->fde_length; 210 *cie_offset = fde->fde_cieoff; 211 *cie_index = fde->fde_cie->cie_index; 212 *fde_offset = fde->fde_offset; 213 214 return (DW_DLV_OK); 215 } 216 217 int 218 dwarf_get_cie_info(Dwarf_Cie cie, Dwarf_Unsigned *bytes_in_cie, 219 Dwarf_Small *version, char **augmenter, Dwarf_Unsigned *caf, 220 Dwarf_Unsigned *daf, Dwarf_Half *ra, Dwarf_Ptr *initinst, 221 Dwarf_Unsigned *inst_len, Dwarf_Error *error) 222 { 223 224 if (cie == NULL || bytes_in_cie == NULL || version == NULL || 225 augmenter == NULL || caf == NULL || daf == NULL || ra == NULL || 226 initinst == NULL || inst_len == NULL) { 227 DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT); 228 return (DW_DLV_ERROR); 229 } 230 231 *bytes_in_cie = cie->cie_length; 232 *version = cie->cie_version; 233 *augmenter = (char *) cie->cie_augment; 234 *caf = cie->cie_caf; 235 *daf = cie->cie_daf; 236 *ra = cie->cie_ra; 237 *initinst = cie->cie_initinst; 238 *inst_len = cie->cie_instlen; 239 240 return (DW_DLV_OK); 241 } 242 243 int 244 dwarf_get_cie_index(Dwarf_Cie cie, Dwarf_Signed *cie_index, Dwarf_Error *error) 245 { 246 247 if (cie == NULL || cie_index == NULL) { 248 DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT); 249 return (DW_DLV_ERROR); 250 } 251 252 *cie_index = cie->cie_index; 253 254 return (DW_DLV_OK); 255 } 256 257 int 258 dwarf_get_fde_instr_bytes(Dwarf_Fde fde, Dwarf_Ptr *ret_inst, 259 Dwarf_Unsigned *ret_len, Dwarf_Error *error) 260 { 261 Dwarf_Debug dbg; 262 263 dbg = fde != NULL ? fde->fde_dbg : NULL; 264 265 if (fde == NULL || ret_inst == NULL || ret_len == NULL) { 266 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 267 return (DW_DLV_ERROR); 268 } 269 270 *ret_inst = fde->fde_inst; 271 *ret_len = fde->fde_instlen; 272 273 return (DW_DLV_OK); 274 } 275 276 #define RL rt->rt3_rules[table_column] 277 #define CFA rt->rt3_cfa_rule 278 279 int 280 dwarf_get_fde_info_for_reg(Dwarf_Fde fde, Dwarf_Half table_column, 281 Dwarf_Addr pc_requested, Dwarf_Signed *offset_relevant, 282 Dwarf_Signed *register_num, Dwarf_Signed *offset, Dwarf_Addr *row_pc, 283 Dwarf_Error *error) 284 { 285 Dwarf_Regtable3 *rt; 286 Dwarf_Debug dbg; 287 Dwarf_Addr pc; 288 int ret; 289 290 dbg = fde != NULL ? fde->fde_dbg : NULL; 291 292 if (fde == NULL || offset_relevant == NULL || register_num == NULL || 293 offset == NULL || row_pc == NULL) { 294 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 295 return (DW_DLV_ERROR); 296 } 297 298 if (pc_requested < fde->fde_initloc || 299 pc_requested >= fde->fde_initloc + fde->fde_adrange) { 300 DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE); 301 return (DW_DLV_ERROR); 302 } 303 304 ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc, 305 error); 306 if (ret != DW_DLE_NONE) 307 return (DW_DLV_ERROR); 308 309 if (table_column == dbg->dbg_frame_cfa_value) { 310 /* Application ask for CFA. */ 311 *offset_relevant = CFA.dw_offset_relevant; 312 *register_num = CFA.dw_regnum; 313 *offset = CFA.dw_offset_or_block_len; 314 } else { 315 /* Application ask for normal registers. */ 316 if (table_column >= dbg->dbg_frame_rule_table_size || 317 table_column >= DW_REG_TABLE_SIZE) { 318 DWARF_SET_ERROR(dbg, error, DW_DLE_FRAME_TABLE_COL_BAD); 319 return (DW_DLV_ERROR); 320 } 321 322 *offset_relevant = RL.dw_offset_relevant; 323 *register_num = RL.dw_regnum; 324 *offset = RL.dw_offset_or_block_len; 325 } 326 327 *row_pc = pc; 328 329 return (DW_DLV_OK); 330 } 331 332 int 333 dwarf_get_fde_info_for_all_regs(Dwarf_Fde fde, Dwarf_Addr pc_requested, 334 Dwarf_Regtable *reg_table, Dwarf_Addr *row_pc, Dwarf_Error *error) 335 { 336 Dwarf_Debug dbg; 337 Dwarf_Regtable3 *rt; 338 Dwarf_Addr pc; 339 Dwarf_Half cfa; 340 int i, ret; 341 342 dbg = fde != NULL ? fde->fde_dbg : NULL; 343 344 if (fde == NULL || reg_table == NULL || row_pc == NULL) { 345 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 346 return (DW_DLV_ERROR); 347 } 348 349 assert(dbg != NULL); 350 351 if (pc_requested < fde->fde_initloc || 352 pc_requested >= fde->fde_initloc + fde->fde_adrange) { 353 DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE); 354 return (DW_DLV_ERROR); 355 } 356 357 ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc, 358 error); 359 if (ret != DW_DLE_NONE) 360 return (DW_DLV_ERROR); 361 362 /* 363 * Copy the CFA rule to the column intended for holding the CFA, 364 * if it's within the range of regtable. 365 */ 366 cfa = dbg->dbg_frame_cfa_value; 367 if (cfa < DW_REG_TABLE_SIZE) { 368 reg_table->rules[cfa].dw_offset_relevant = 369 CFA.dw_offset_relevant; 370 reg_table->rules[cfa].dw_regnum = CFA.dw_regnum; 371 reg_table->rules[cfa].dw_offset = CFA.dw_offset_or_block_len; 372 } 373 374 /* 375 * Copy other columns. 376 */ 377 for (i = 0; i < DW_REG_TABLE_SIZE && i < dbg->dbg_frame_rule_table_size; 378 i++) { 379 380 /* Do not overwrite CFA column */ 381 if (i == cfa) 382 continue; 383 384 reg_table->rules[i].dw_offset_relevant = 385 rt->rt3_rules[i].dw_offset_relevant; 386 reg_table->rules[i].dw_regnum = rt->rt3_rules[i].dw_regnum; 387 reg_table->rules[i].dw_offset = 388 rt->rt3_rules[i].dw_offset_or_block_len; 389 } 390 391 *row_pc = pc; 392 393 return (DW_DLV_OK); 394 } 395 396 int 397 dwarf_get_fde_info_for_reg3(Dwarf_Fde fde, Dwarf_Half table_column, 398 Dwarf_Addr pc_requested, Dwarf_Small *value_type, 399 Dwarf_Signed *offset_relevant, Dwarf_Signed *register_num, 400 Dwarf_Signed *offset_or_block_len, Dwarf_Ptr *block_ptr, 401 Dwarf_Addr *row_pc, Dwarf_Error *error) 402 { 403 Dwarf_Regtable3 *rt; 404 Dwarf_Debug dbg; 405 Dwarf_Addr pc; 406 int ret; 407 408 dbg = fde != NULL ? fde->fde_dbg : NULL; 409 410 if (fde == NULL || value_type == NULL || offset_relevant == NULL || 411 register_num == NULL || offset_or_block_len == NULL || 412 block_ptr == NULL || row_pc == NULL) { 413 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 414 return (DW_DLV_ERROR); 415 } 416 417 if (pc_requested < fde->fde_initloc || 418 pc_requested >= fde->fde_initloc + fde->fde_adrange) { 419 DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE); 420 return (DW_DLV_ERROR); 421 } 422 423 ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc, 424 error); 425 if (ret != DW_DLE_NONE) 426 return (DW_DLV_ERROR); 427 428 if (table_column >= dbg->dbg_frame_rule_table_size) { 429 DWARF_SET_ERROR(dbg, error, DW_DLE_FRAME_TABLE_COL_BAD); 430 return (DW_DLV_ERROR); 431 } 432 433 *value_type = RL.dw_value_type; 434 *offset_relevant = RL.dw_offset_relevant; 435 *register_num = RL.dw_regnum; 436 *offset_or_block_len = RL.dw_offset_or_block_len; 437 *block_ptr = RL.dw_block_ptr; 438 *row_pc = pc; 439 440 return (DW_DLV_OK); 441 } 442 443 int 444 dwarf_get_fde_info_for_cfa_reg3(Dwarf_Fde fde, Dwarf_Addr pc_requested, 445 Dwarf_Small *value_type, Dwarf_Signed *offset_relevant, 446 Dwarf_Signed *register_num, Dwarf_Signed *offset_or_block_len, 447 Dwarf_Ptr *block_ptr, Dwarf_Addr *row_pc, Dwarf_Error *error) 448 { 449 Dwarf_Regtable3 *rt; 450 Dwarf_Debug dbg; 451 Dwarf_Addr pc; 452 int ret; 453 454 dbg = fde != NULL ? fde->fde_dbg : NULL; 455 456 if (fde == NULL || value_type == NULL || offset_relevant == NULL || 457 register_num == NULL || offset_or_block_len == NULL || 458 block_ptr == NULL || row_pc == NULL) { 459 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 460 return (DW_DLV_ERROR); 461 } 462 463 if (pc_requested < fde->fde_initloc || 464 pc_requested >= fde->fde_initloc + fde->fde_adrange) { 465 DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE); 466 return (DW_DLV_ERROR); 467 } 468 469 ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc, 470 error); 471 if (ret != DW_DLE_NONE) 472 return (DW_DLV_ERROR); 473 474 *value_type = CFA.dw_value_type; 475 *offset_relevant = CFA.dw_offset_relevant; 476 *register_num = CFA.dw_regnum; 477 *offset_or_block_len = CFA.dw_offset_or_block_len; 478 *block_ptr = CFA.dw_block_ptr; 479 *row_pc = pc; 480 481 return (DW_DLV_OK); 482 } 483 484 #undef RL 485 #undef CFA 486 487 int 488 dwarf_get_fde_info_for_all_regs3(Dwarf_Fde fde, Dwarf_Addr pc_requested, 489 Dwarf_Regtable3 *reg_table, Dwarf_Addr *row_pc, Dwarf_Error *error) 490 { 491 Dwarf_Regtable3 *rt; 492 Dwarf_Debug dbg; 493 Dwarf_Addr pc; 494 int ret; 495 496 dbg = fde != NULL ? fde->fde_dbg : NULL; 497 498 if (fde == NULL || reg_table == NULL || reg_table->rt3_rules == NULL || 499 row_pc == NULL) { 500 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 501 return (DW_DLV_ERROR); 502 } 503 504 assert(dbg != NULL); 505 506 if (pc_requested < fde->fde_initloc || 507 pc_requested >= fde->fde_initloc + fde->fde_adrange) { 508 DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE); 509 return (DW_DLV_ERROR); 510 } 511 512 ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc, 513 error); 514 if (ret != DW_DLE_NONE) 515 return (DW_DLV_ERROR); 516 517 ret = _dwarf_frame_regtable_copy(dbg, ®_table, rt, error); 518 if (ret != DW_DLE_NONE) 519 return (DW_DLV_ERROR); 520 521 *row_pc = pc; 522 523 return (DW_DLV_OK); 524 } 525 526 int 527 dwarf_expand_frame_instructions(Dwarf_Cie cie, Dwarf_Ptr instruction, 528 Dwarf_Unsigned len, Dwarf_Frame_Op **ret_oplist, Dwarf_Signed *ret_opcnt, 529 Dwarf_Error *error) 530 { 531 Dwarf_Debug dbg; 532 int ret; 533 534 dbg = cie != NULL ? cie->cie_dbg : NULL; 535 536 if (cie == NULL || instruction == NULL || len == 0 || 537 ret_oplist == NULL || ret_opcnt == NULL) { 538 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); 539 return (DW_DLV_ERROR); 540 } 541 542 ret = _dwarf_frame_get_fop(dbg, cie->cie_addrsize, instruction, len, 543 ret_oplist, ret_opcnt, error); 544 if (ret != DW_DLE_NONE) 545 return (DW_DLV_ERROR); 546 547 return (DW_DLV_OK); 548 } 549 550 Dwarf_Half 551 dwarf_set_frame_rule_table_size(Dwarf_Debug dbg, Dwarf_Half value) 552 { 553 Dwarf_Half old_value; 554 555 old_value = dbg->dbg_frame_rule_table_size; 556 dbg->dbg_frame_rule_table_size = value; 557 558 return (old_value); 559 } 560 561 Dwarf_Half 562 dwarf_set_frame_rule_initial_value(Dwarf_Debug dbg, Dwarf_Half value) 563 { 564 Dwarf_Half old_value; 565 566 old_value = dbg->dbg_frame_rule_initial_value; 567 dbg->dbg_frame_rule_initial_value = value; 568 569 return (old_value); 570 } 571 572 Dwarf_Half 573 dwarf_set_frame_cfa_value(Dwarf_Debug dbg, Dwarf_Half value) 574 { 575 Dwarf_Half old_value; 576 577 old_value = dbg->dbg_frame_cfa_value; 578 dbg->dbg_frame_cfa_value = value; 579 580 return (old_value); 581 } 582 583 Dwarf_Half 584 dwarf_set_frame_same_value(Dwarf_Debug dbg, Dwarf_Half value) 585 { 586 Dwarf_Half old_value; 587 588 old_value = dbg->dbg_frame_same_value; 589 dbg->dbg_frame_same_value = value; 590 591 return (old_value); 592 } 593 594 Dwarf_Half 595 dwarf_set_frame_undefined_value(Dwarf_Debug dbg, Dwarf_Half value) 596 { 597 Dwarf_Half old_value; 598 599 old_value = dbg->dbg_frame_undefined_value; 600 dbg->dbg_frame_undefined_value = value; 601 602 return (old_value); 603 } 604