Open64: osprey/libdwarf/libdwarf/pro

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000,2004 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2.1 of the GNU Lesser General Public License 
00011   as published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU Lesser General Public 
00025   License along with this program; if not, write the Free Software 
00026   Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 
00027   USA.
00028 
00029   Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
00030   Mountain View, CA 94043, or:
00031 
00032   http://www.sgi.com
00033 
00034   For further information regarding this notice, see:
00035 
00036   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00037 
00038 */
00039 
00040 
00041 
00042 #include "config.h"
00043 #include "libdwarfdefs.h"
00044 #include <stdio.h>
00045 #include <string.h>
00046 #include <limits.h>
00047 #include "pro_incl.h"
00048 #include "pro_frame.h"
00049 
00050 static void _dwarf_pro_add_to_fde(Dwarf_P_Fde fde,
00051           Dwarf_P_Frame_Pgm inst);
00052 
00053 /*-------------------------------------------------------------------------
00054   This functions adds a cie struct to the debug pointer. Its in the
00055   form of a linked list.
00056   augmenter: string reps augmentation (implementation defined)
00057   code_align: alignment of code
00058   data_align: alignment of data
00059   init_bytes: byts having initial instructions
00060   init_n_bytes: number of bytes of initial instructions
00061 --------------------------------------------------------------------------*/
00062 Dwarf_Unsigned
00063 dwarf_add_frame_cie(Dwarf_P_Debug dbg,
00064         const char *augmenter,
00065         Dwarf_Small code_align,
00066         Dwarf_Small data_align,
00067         Dwarf_Small return_reg,
00068         Dwarf_Ptr init_bytes,
00069         Dwarf_Unsigned init_n_bytes, Dwarf_Error * error)
00070 {
00071     Dwarf_P_Cie curcie;
00072 
00073     if (dbg->de_frame_cies == NULL) {
00074   dbg->de_frame_cies = (Dwarf_P_Cie)
00075       _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_P_Cie_s));
00076   if (dbg->de_frame_cies == NULL) {
00077       DWARF_P_DBG_ERROR(dbg, DW_DLE_CIE_ALLOC, DW_DLV_NOCOUNT);
00078   }
00079   curcie = dbg->de_frame_cies;
00080   dbg->de_n_cie = 1;
00081   dbg->de_last_cie = curcie;
00082     } else {
00083   curcie = dbg->de_last_cie;
00084   curcie->cie_next = (Dwarf_P_Cie)
00085       _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_P_Cie_s));
00086   if (curcie->cie_next == NULL) {
00087       DWARF_P_DBG_ERROR(dbg, DW_DLE_CIE_ALLOC, DW_DLV_NOCOUNT);
00088   }
00089   curcie = curcie->cie_next;
00090   dbg->de_n_cie++;
00091   dbg->de_last_cie = curcie;
00092     }
00093     curcie->cie_version = DW_CIE_VERSION;
00094     curcie->cie_aug = augmenter;
00095     curcie->cie_code_align = code_align;
00096     curcie->cie_data_align = data_align;
00097     curcie->cie_ret_reg = return_reg;
00098     curcie->cie_personality = 0;
00099     curcie->cie_inst = (char *) init_bytes;
00100     curcie->cie_inst_bytes = (long) init_n_bytes;
00101     curcie->cie_next = NULL;
00102     return dbg->de_n_cie;
00103 }
00104 
00105 
00106 /*-------------------------------------------------------------------------
00107   This functions adds a fde struct to the debug pointer. Its in the
00108   form of a linked list.
00109   die: subprogram/function die corresponding to this fde
00110   cie: cie referred to by this fde, obtained from call to 
00111       add_frame_cie() routine.
00112   virt_addr: beginning address
00113   code_len: length of code reps by the fde
00114 --------------------------------------------------------------------------*/
00115  /*ARGSUSED*/     /* pretend all args used */
00116     Dwarf_Unsigned
00117 dwarf_add_frame_fde(Dwarf_P_Debug dbg,
00118         Dwarf_P_Fde fde,
00119         Dwarf_P_Die die,
00120         Dwarf_Unsigned cie,
00121         Dwarf_Unsigned virt_addr,
00122         Dwarf_Unsigned code_len,
00123         Dwarf_Unsigned symidx, Dwarf_Error * error)
00124 {
00125     return dwarf_add_frame_fde_b(dbg, fde, die, cie, virt_addr,
00126          code_len, symidx, 0, 0, error);
00127 }
00128 
00129 /*ARGSUSED10*/
00130 Dwarf_Unsigned
00131 dwarf_add_frame_fde_b(Dwarf_P_Debug dbg,
00132           Dwarf_P_Fde fde,
00133           Dwarf_P_Die die,
00134           Dwarf_Unsigned cie,
00135           Dwarf_Unsigned virt_addr,
00136           Dwarf_Unsigned code_len,
00137           Dwarf_Unsigned symidx,
00138           Dwarf_Unsigned symidx_of_end,
00139           Dwarf_Addr offset_from_end_sym,
00140           Dwarf_Error * error)
00141 {
00142     Dwarf_P_Fde curfde;
00143 
00144     fde->fde_die = die;
00145     fde->fde_cie = (long) cie;
00146     fde->fde_initloc = virt_addr;
00147     fde->fde_r_symidx = symidx;
00148     fde->fde_addr_range = code_len;
00149     fde->fde_offset_into_exception_tables = DW_DLX_NO_EH_OFFSET;
00150     fde->fde_exception_table_symbol = 0;
00151     fde->fde_end_symbol_offset = offset_from_end_sym;
00152     fde->fde_end_symbol = symidx_of_end;
00153 
00154     curfde = dbg->de_last_fde;
00155     if (curfde == NULL) {
00156   dbg->de_frame_fdes = fde;
00157   dbg->de_last_fde = fde;
00158   dbg->de_n_fde = 1;
00159     } else {
00160   curfde->fde_next = fde;
00161   dbg->de_last_fde = fde;
00162   dbg->de_n_fde++;
00163     }
00164     return dbg->de_n_fde;
00165 }
00166 
00167 /*-------------------------------------------------------------------------
00168   This functions adds information to an fde. The fde is
00169   linked into the linked list of fde's maintained in the Dwarf_P_Debug
00170   structure.
00171   dbg: The debug descriptor.
00172   fde: The fde to be added.
00173   die: subprogram/function die corresponding to this fde
00174   cie: cie referred to by this fde, obtained from call to 
00175       add_frame_cie() routine.
00176   virt_addr: beginning address
00177   code_len: length of code reps by the fde
00178   symidx: The symbol id of the symbol wrt to which relocation needs
00179     to be performed for 'virt_addr'.
00180   offset_into_exception_tables: The start of exception tables for
00181     this function (indicated as an offset into the exception
00182     tables). A value of -1 indicates that there is no exception
00183     table entries associated with this function.
00184   exception_table_symbol: The symbol id of the section for exception
00185     tables wrt to which the offset_into_exception_tables will
00186     be relocated.
00187 --------------------------------------------------------------------------*/
00188 Dwarf_Unsigned
00189 dwarf_add_frame_info(Dwarf_P_Debug dbg,
00190          Dwarf_P_Fde fde,
00191          Dwarf_P_Die die,
00192          Dwarf_Unsigned cie,
00193          Dwarf_Unsigned virt_addr,
00194          Dwarf_Unsigned code_len,
00195          Dwarf_Unsigned symidx,
00196          Dwarf_Signed offset_into_exception_tables,
00197          Dwarf_Unsigned exception_table_symbol,
00198          Dwarf_Error * error)
00199 {
00200 
00201     return dwarf_add_frame_info_b(dbg, fde, die, cie, virt_addr,
00202           code_len, symidx,
00203           /* end_symbol */ 0,
00204           /* offset_from_end */ 0,
00205           offset_into_exception_tables,
00206           exception_table_symbol, error);
00207 
00208 }
00209 
00210  /*ARGSUSED*/     /* pretend all args used */
00211     Dwarf_Unsigned
00212 dwarf_add_frame_info_b(Dwarf_P_Debug dbg,
00213            Dwarf_P_Fde fde,
00214            Dwarf_P_Die die,
00215            Dwarf_Unsigned cie,
00216            Dwarf_Unsigned virt_addr,
00217            Dwarf_Unsigned code_len,
00218            Dwarf_Unsigned symidx,
00219            Dwarf_Unsigned end_symidx,
00220            Dwarf_Unsigned offset_from_end_symbol,
00221            Dwarf_Signed offset_into_exception_tables,
00222            Dwarf_Unsigned exception_table_symbol,
00223            Dwarf_Error * error)
00224 {
00225     Dwarf_P_Fde curfde;
00226 
00227     fde->fde_die = die;
00228     fde->fde_cie = (long) cie;
00229     fde->fde_initloc = virt_addr;
00230     fde->fde_r_symidx = symidx;
00231     fde->fde_addr_range = code_len;
00232     fde->fde_offset_into_exception_tables =
00233   offset_into_exception_tables;
00234     fde->fde_exception_table_symbol = exception_table_symbol;
00235     fde->fde_end_symbol_offset = offset_from_end_symbol;
00236     fde->fde_end_symbol = end_symidx;
00237 
00238 
00239     curfde = dbg->de_last_fde;
00240     if (curfde == NULL) {
00241   dbg->de_frame_fdes = fde;
00242   dbg->de_last_fde = fde;
00243   dbg->de_n_fde = 1;
00244     } else {
00245   curfde->fde_next = fde;
00246   dbg->de_last_fde = fde;
00247   dbg->de_n_fde++;
00248     }
00249     return dbg->de_n_fde;
00250 }
00251 
00252 
00253 /*-------------------------------------------------------------------
00254   Create a new fde 
00255 ---------------------------------------------------------------------*/
00256 Dwarf_P_Fde
00257 dwarf_new_fde(Dwarf_P_Debug dbg, Dwarf_Error * error)
00258 {
00259     Dwarf_P_Fde fde;
00260 
00261     fde = (Dwarf_P_Fde)
00262   _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_P_Fde_s));
00263     if (fde == NULL) {
00264   DWARF_P_DBG_ERROR(dbg, DW_DLE_FDE_ALLOC,
00265         (Dwarf_P_Fde) DW_DLV_BADADDR);
00266     }
00267     fde->fde_next = NULL;
00268     fde->fde_inst = NULL;
00269     fde->fde_n_inst = 0;
00270     fde->fde_n_bytes = 0;
00271     fde->fde_last_inst = NULL;
00272     fde->fde_uwordb_size = dbg->de_offset_size;
00273     return fde;
00274 }
00275 
00276 /*------------------------------------------------------------------------
00277   Add cfe_offset instruction to fde
00278 -------------------------------------------------------------------------*/
00279 Dwarf_P_Fde
00280 dwarf_fde_cfa_offset(Dwarf_P_Fde fde,
00281          Dwarf_Unsigned reg,
00282          Dwarf_Signed offset, Dwarf_Error * error)
00283 {
00284     Dwarf_Ubyte opc, regno;
00285     char *ptr;
00286     Dwarf_P_Frame_Pgm curinst;
00287     int nbytes;
00288     int res;
00289     char buff1[ENCODE_SPACE_NEEDED];
00290 
00291     curinst = (Dwarf_P_Frame_Pgm)
00292   _dwarf_p_get_alloc(NULL, sizeof(struct Dwarf_P_Frame_Pgm_s));
00293     if (curinst == NULL) {
00294   DWARF_P_DBG_ERROR(NULL, DW_DLE_FPGM_ALLOC,
00295         (Dwarf_P_Fde) DW_DLV_BADADDR);
00296     }
00297     opc = DW_CFA_offset;
00298     regno = reg;
00299     if (regno & 0xc0) {
00300   DWARF_P_DBG_ERROR(NULL, DW_DLE_REGNO_OVFL,
00301         (Dwarf_P_Fde) DW_DLV_BADADDR);
00302     }
00303     opc = opc | regno;    /* lower 6 bits are register number */
00304     curinst->dfp_opcode = opc;
00305     res = _dwarf_pro_encode_leb128_nm(offset, &nbytes,
00306               buff1, sizeof(buff1));
00307     if (res != DW_DLV_OK) {
00308   _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00309   return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00310     }
00311     ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes);
00312     if (ptr == NULL) {
00313   _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00314   return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00315     }
00316     memcpy(ptr, buff1, nbytes);
00317 
00318     curinst->dfp_args = ptr;
00319     curinst->dfp_nbytes = nbytes;
00320     curinst->dfp_next = NULL;
00321 
00322     _dwarf_pro_add_to_fde(fde, curinst);
00323     return fde;
00324 }
00325 
00326 /*
00327     Generic routine to add opcode to fde instructions. val1 and
00328     val2 are parameters whose interpretation depends on the 'op'.
00329 
00330     This does not work properly for  DW_DLC_SYMBOLIC_RELOCATIONS
00331     for DW_CFA_set_loc or DW_DVA_advance_loc* 'op', as
00332     these ops normally are addresses or (DW_CFA_set_loc) 
00333     or code lengths (DW_DVA_advance_loc*) and such must be
00334     represented with relocations and symbol indices for
00335     DW_DLC_SYMBOLIC_RELOCATIONS.
00336 
00337 */
00338 Dwarf_P_Fde
00339 dwarf_add_fde_inst(Dwarf_P_Fde fde,
00340        Dwarf_Small op,
00341        Dwarf_Unsigned val1,
00342        Dwarf_Unsigned val2, Dwarf_Error * error)
00343 {
00344     Dwarf_P_Frame_Pgm curinst;
00345     int nbytes, nbytes1, nbytes2;
00346     Dwarf_Ubyte db;
00347     Dwarf_Half dh;
00348     Dwarf_Word dw;
00349     Dwarf_Unsigned du;
00350     char *ptr;
00351     int res;
00352     char buff1[ENCODE_SPACE_NEEDED];
00353     char buff2[ENCODE_SPACE_NEEDED];
00354 
00355 
00356     nbytes = 0;
00357     ptr = NULL;
00358     curinst = (Dwarf_P_Frame_Pgm)
00359   _dwarf_p_get_alloc(NULL, sizeof(struct Dwarf_P_Frame_Pgm_s));
00360     if (curinst == NULL) {
00361   _dwarf_p_error(NULL, error, DW_DLE_FPGM_ALLOC);
00362   return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00363     }
00364 
00365     switch (op) {
00366 #if defined TARG_X8664
00367       // This does not seem specific to x8664, but I will leave it for now.
00368   // The previous code here apparently assumed the labels for this "op"
00369   // need to be encoded in 4 bytes --- that is not the case. This "op"
00370   // limits to 4 bytes whatever follows it. And whatever follows it is
00371   // the subtraction between the 2 labels, i.e., each label may need
00372   // more number of bytes.
00373   // Use Dwarf_Unsigned for each label (bugs 4071, 4490, 9729), also
00374   // affects code in pro_section.c and dwf_section.c.
00375   case DW_CFA_advance_loc4:
00376       du = val1;
00377           ptr = (char *) _dwarf_p_get_alloc(NULL, 2 * sizeof(Dwarf_Unsigned));
00378           if (ptr == NULL) {
00379             _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00380               return((Dwarf_P_Fde)DW_DLV_BADADDR);
00381           }
00382           memcpy((void *)ptr, (const void *)&du, sizeof(Dwarf_Unsigned));
00383         du = val2;
00384           memcpy((void *)ptr + sizeof(Dwarf_Unsigned), (const void *)&du,
00385                        sizeof(Dwarf_Unsigned));
00386             nbytes = 4;
00387           break;
00388 #endif // TARG_X8664
00389     case DW_CFA_advance_loc:
00390   if (val1 <= 0x3f) {
00391       db = val1;
00392       op |= db;
00393   }
00394   /* test not portable FIX */
00395   else if (val1 <= UCHAR_MAX) {
00396       op = DW_CFA_advance_loc1;
00397       db = val1;
00398       ptr = (char *) _dwarf_p_get_alloc(NULL, 1);
00399       if (ptr == NULL) {
00400     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00401     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00402       }
00403       memcpy((void *) ptr, (const void *) &db, 1);
00404       nbytes = 1;
00405   }
00406   /* test not portable FIX */
00407   else if (val1 <= USHRT_MAX) {
00408       op = DW_CFA_advance_loc2;
00409       dh = val1;
00410       ptr = (char *) _dwarf_p_get_alloc(NULL, 2);
00411       if (ptr == NULL) {
00412     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00413     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00414       }
00415       memcpy((void *) ptr, (const void *) &dh, 2);
00416       nbytes = 2;
00417   }
00418   /* test not portable FIX */
00419   else if (val1 <= ULONG_MAX) {
00420       op = DW_CFA_advance_loc4;
00421       dw = (Dwarf_Word) val1;
00422       ptr = (char *) _dwarf_p_get_alloc(NULL, 4);
00423       if (ptr == NULL) {
00424     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00425     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00426       }
00427       memcpy((void *) ptr, (const void *) &dw, 4);
00428       nbytes = 4;
00429   } else {
00430       op = DW_CFA_MIPS_advance_loc8;
00431       du = val1;
00432       ptr =
00433     (char *) _dwarf_p_get_alloc(NULL,
00434               sizeof(Dwarf_Unsigned));
00435       if (ptr == NULL) {
00436     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00437     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00438       }
00439       memcpy((void *) ptr, (const void *) &du, 8);
00440       nbytes = 8;
00441   }
00442   break;
00443 
00444     case DW_CFA_offset:
00445   if (val1 <= MAX_6_BIT_VALUE) {
00446       db = val1;
00447       op |= db;
00448       res = _dwarf_pro_encode_leb128_nm(val2, &nbytes,
00449                 buff1, sizeof(buff1));
00450       if (res != DW_DLV_OK) {
00451     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00452     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00453       }
00454       ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes);
00455       if (ptr == NULL) {
00456     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00457     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00458       }
00459       memcpy(ptr, buff1, nbytes);
00460 
00461   } else {
00462       op = DW_CFA_offset_extended;
00463 
00464       res = _dwarf_pro_encode_leb128_nm(val1, &nbytes1,
00465                 buff1, sizeof(buff1));
00466       if (res != DW_DLV_OK) {
00467     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00468     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00469       }
00470       res = _dwarf_pro_encode_leb128_nm(val2, &nbytes2,
00471                 buff2, sizeof(buff2));
00472       if (res != DW_DLV_OK) {
00473     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00474     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00475       }
00476       ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes1 + nbytes2);
00477       if (ptr == NULL) {
00478     _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00479     return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00480       }
00481       memcpy(ptr, buff1, nbytes1);
00482       memcpy(ptr + nbytes1, buff2, nbytes2);
00483       nbytes = nbytes1 + nbytes2;
00484   }
00485   break;
00486 
00487     case DW_CFA_undefined:
00488     case DW_CFA_same_value:
00489   res = _dwarf_pro_encode_leb128_nm(val1, &nbytes,
00490             buff1, sizeof(buff1));
00491   if (res != DW_DLV_OK) {
00492       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00493       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00494   }
00495   ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes);
00496   if (ptr == NULL) {
00497       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00498       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00499   }
00500   memcpy(ptr, buff1, nbytes);
00501   break;
00502 
00503     case DW_CFA_register:
00504     case DW_CFA_def_cfa:
00505   res = _dwarf_pro_encode_leb128_nm(val1, &nbytes1,
00506             buff1, sizeof(buff1));
00507   if (res != DW_DLV_OK) {
00508       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00509       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00510   }
00511 
00512   res = _dwarf_pro_encode_leb128_nm(val2, &nbytes2,
00513             buff2, sizeof(buff2));
00514   if (res != DW_DLV_OK) {
00515       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00516       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00517   }
00518 
00519   ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes1 + nbytes2);
00520   if (ptr == NULL) {
00521       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00522       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00523   }
00524   memcpy(ptr, buff1, nbytes1);
00525   memcpy(ptr + nbytes1, buff2, nbytes2);
00526   nbytes = nbytes1 + nbytes2;
00527   break;
00528 
00529     case DW_CFA_def_cfa_register:
00530     case DW_CFA_def_cfa_offset:
00531   res = _dwarf_pro_encode_leb128_nm(val1, &nbytes,
00532             buff1, sizeof(buff1));
00533   if (res != DW_DLV_OK) {
00534       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00535       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00536   }
00537   ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes);
00538   if (ptr == NULL) {
00539       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00540       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00541   }
00542   memcpy(ptr, buff1, nbytes);
00543   break;
00544 
00545 #ifdef TARG_SL
00546     case DW_CFA_SL_gpr_reginfo:
00547     case DW_CFA_SL_cr_reginfo:
00548     case DW_CFA_SL_sr_reginfo:
00549     nbytes = 4;
00550   res = _dwarf_pro_encode_leb128_nm(val1, &nbytes,
00551             buff1, sizeof(buff1));
00552   if (res != DW_DLV_OK) {
00553       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00554       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00555   }
00556   ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes);
00557   if (ptr == NULL) {
00558       _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00559       return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00560   }
00561   memcpy(ptr, buff1, nbytes);
00562   break;
00563 #endif
00564 
00565     default:
00566   break;
00567     }
00568 
00569     curinst->dfp_opcode = op;
00570     curinst->dfp_args = ptr;
00571     curinst->dfp_nbytes = nbytes;
00572     curinst->dfp_next = NULL;
00573 
00574     _dwarf_pro_add_to_fde(fde, curinst);
00575     return fde;
00576 }
00577 
00578 #ifdef KEY
00579 /* Similar to dwarf_add_fde_inst, except that the offset denoted by VAL2
00580    is signed.
00581 */
00582 Dwarf_P_Fde
00583 dwarf_add_fde_inst_with_signed_offset(Dwarf_P_Fde fde,
00584                                       Dwarf_Small op,
00585                                       Dwarf_Unsigned val1,
00586                                       Dwarf_Signed val2, Dwarf_Error * error)
00587 {
00588     Dwarf_P_Frame_Pgm curinst;
00589     int nbytes, nbytes1, nbytes2;
00590     char *ptr;
00591     int res;
00592     char buff1[ENCODE_SPACE_NEEDED];
00593     char buff2[ENCODE_SPACE_NEEDED];
00594 
00595 
00596     nbytes = 0;
00597     ptr = NULL;
00598     curinst = (Dwarf_P_Frame_Pgm)
00599         _dwarf_p_get_alloc(NULL, sizeof(struct Dwarf_P_Frame_Pgm_s));
00600     if (curinst == NULL) {
00601         _dwarf_p_error(NULL, error, DW_DLE_FPGM_ALLOC);
00602         return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00603     }
00604 
00605     if (op == DW_CFA_offset_extended_sf)
00606     {
00607       res = _dwarf_pro_encode_leb128_nm(val1, &nbytes1,
00608                                         buff1, sizeof(buff1));
00609       if (res != DW_DLV_OK) {
00610         _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00611         return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00612       }
00613       res = _dwarf_pro_encode_signed_leb128_nm(val2, &nbytes2,
00614                                                buff2, sizeof(buff2));
00615       if (res != DW_DLV_OK) {
00616         _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00617         return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00618       }
00619       ptr = (char *) _dwarf_p_get_alloc(NULL, nbytes1 + nbytes2);
00620       if (ptr == NULL) {
00621         _dwarf_p_error(NULL, error, DW_DLE_STRING_ALLOC);
00622         return ((Dwarf_P_Fde) DW_DLV_BADADDR);
00623       }
00624       memcpy(ptr, buff1, nbytes1);
00625       memcpy(ptr + nbytes1, buff2, nbytes2);
00626       nbytes = nbytes1 + nbytes2;
00627     }
00628     curinst->dfp_opcode = op;
00629     curinst->dfp_args = ptr;
00630     curinst->dfp_nbytes = nbytes;
00631     curinst->dfp_next = NULL;
00632 
00633     _dwarf_pro_add_to_fde(fde, curinst);
00634     return fde;
00635 }
00636 #endif
00637 
00638 /*------------------------------------------------------------------------
00639   instructions are added to fde in the form of a linked
00640   list. This function manages the linked list
00641 -------------------------------------------------------------------------*/
00642 void
00643 _dwarf_pro_add_to_fde(Dwarf_P_Fde fde, Dwarf_P_Frame_Pgm curinst)
00644 {
00645     if (fde->fde_last_inst) {
00646   fde->fde_last_inst->dfp_next = curinst;
00647   fde->fde_last_inst = curinst;
00648   fde->fde_n_inst++;
00649   fde->fde_n_bytes +=
00650       (long) (curinst->dfp_nbytes + sizeof(Dwarf_Ubyte));
00651     } else {
00652   fde->fde_last_inst = curinst;
00653   fde->fde_inst = curinst;
00654   fde->fde_n_inst = 1;
00655   fde->fde_n_bytes =
00656       (long) (curinst->dfp_nbytes + sizeof(Dwarf_Ubyte));
00657     }
00658 }
osprey/libdwarf/libdwarf/pro_frame.c
