Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
unwind_decoder.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2000 Hewlett-Packard Co
3  * Copyright (C) 2000 David Mosberger-Tang <[email protected]>
4  *
5  * Generic IA-64 unwind info decoder.
6  *
7  * This file is used both by the Linux kernel and objdump. Please keep
8  * the two copies of this file in sync.
9  *
10  * You need to customize the decoder by defining the following
11  * macros/constants before including this file:
12  *
13  * Types:
14  * unw_word Unsigned integer type with at least 64 bits
15  *
16  * Register names:
17  * UNW_REG_BSP
18  * UNW_REG_BSPSTORE
19  * UNW_REG_FPSR
20  * UNW_REG_LC
21  * UNW_REG_PFS
22  * UNW_REG_PR
23  * UNW_REG_RNAT
24  * UNW_REG_PSP
25  * UNW_REG_RP
26  * UNW_REG_UNAT
27  *
28  * Decoder action macros:
29  * UNW_DEC_BAD_CODE(code)
30  * UNW_DEC_ABI(fmt,abi,context,arg)
31  * UNW_DEC_BR_GR(fmt,brmask,gr,arg)
32  * UNW_DEC_BR_MEM(fmt,brmask,arg)
33  * UNW_DEC_COPY_STATE(fmt,label,arg)
34  * UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
35  * UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
36  * UNW_DEC_FR_MEM(fmt,frmask,arg)
37  * UNW_DEC_GR_GR(fmt,grmask,gr,arg)
38  * UNW_DEC_GR_MEM(fmt,grmask,arg)
39  * UNW_DEC_LABEL_STATE(fmt,label,arg)
40  * UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
41  * UNW_DEC_MEM_STACK_V(fmt,t,arg)
42  * UNW_DEC_PRIUNAT_GR(fmt,r,arg)
43  * UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
44  * UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
45  * UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
46  * UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
47  * UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
48  * UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
49  * UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
50  * UNW_DEC_REG_REG(fmt,src,dst,arg)
51  * UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
52  * UNW_DEC_REG_WHEN(fmt,reg,t,arg)
53  * UNW_DEC_RESTORE(fmt,t,abreg,arg)
54  * UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
55  * UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
56  * UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
57  * UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
58  * UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
59  * UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
60  * UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
61  * UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
62  * UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
63  */
64 
65 static unw_word
66 unw_decode_uleb128 (unsigned char **dpp)
67 {
68  unsigned shift = 0;
69  unw_word byte, result = 0;
70  unsigned char *bp = *dpp;
71 
72  while (1)
73  {
74  byte = *bp++;
75  result |= (byte & 0x7f) << shift;
76  if ((byte & 0x80) == 0)
77  break;
78  shift += 7;
79  }
80  *dpp = bp;
81  return result;
82 }
83 
84 static unsigned char *
85 unw_decode_x1 (unsigned char *dp, unsigned char code, void *arg)
86 {
87  unsigned char byte1, abreg;
88  unw_word t, off;
89 
90  byte1 = *dp++;
91  t = unw_decode_uleb128 (&dp);
92  off = unw_decode_uleb128 (&dp);
93  abreg = (byte1 & 0x7f);
94  if (byte1 & 0x80)
95  UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
96  else
97  UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
98  return dp;
99 }
100 
101 static unsigned char *
102 unw_decode_x2 (unsigned char *dp, unsigned char code, void *arg)
103 {
104  unsigned char byte1, byte2, abreg, x, ytreg;
105  unw_word t;
106 
107  byte1 = *dp++; byte2 = *dp++;
108  t = unw_decode_uleb128 (&dp);
109  abreg = (byte1 & 0x7f);
110  ytreg = byte2;
111  x = (byte1 >> 7) & 1;
112  if ((byte1 & 0x80) == 0 && ytreg == 0)
113  UNW_DEC_RESTORE(X2, t, abreg, arg);
114  else
115  UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
116  return dp;
117 }
118 
119 static unsigned char *
120 unw_decode_x3 (unsigned char *dp, unsigned char code, void *arg)
121 {
122  unsigned char byte1, byte2, abreg, qp;
123  unw_word t, off;
124 
125  byte1 = *dp++; byte2 = *dp++;
126  t = unw_decode_uleb128 (&dp);
127  off = unw_decode_uleb128 (&dp);
128 
129  qp = (byte1 & 0x3f);
130  abreg = (byte2 & 0x7f);
131 
132  if (byte1 & 0x80)
133  UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
134  else
135  UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
136  return dp;
137 }
138 
139 static unsigned char *
140 unw_decode_x4 (unsigned char *dp, unsigned char code, void *arg)
141 {
142  unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
143  unw_word t;
144 
145  byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
146  t = unw_decode_uleb128 (&dp);
147 
148  qp = (byte1 & 0x3f);
149  abreg = (byte2 & 0x7f);
150  x = (byte2 >> 7) & 1;
151  ytreg = byte3;
152 
153  if ((byte2 & 0x80) == 0 && byte3 == 0)
154  UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
155  else
156  UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
157  return dp;
158 }
159 
160 static unsigned char *
161 unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
162 {
163  int body = (code & 0x20) != 0;
164  unw_word rlen;
165 
166  rlen = (code & 0x1f);
167  UNW_DEC_PROLOGUE(R1, body, rlen, arg);
168  return dp;
169 }
170 
171 static unsigned char *
172 unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
173 {
174  unsigned char byte1, mask, grsave;
175  unw_word rlen;
176 
177  byte1 = *dp++;
178 
179  mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
180  grsave = (byte1 & 0x7f);
181  rlen = unw_decode_uleb128 (&dp);
182  UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
183  return dp;
184 }
185 
186 static unsigned char *
187 unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
188 {
189  unw_word rlen;
190 
191  rlen = unw_decode_uleb128 (&dp);
192  UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
193  return dp;
194 }
195 
196 static unsigned char *
197 unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
198 {
199  unsigned char brmask = (code & 0x1f);
200 
201  UNW_DEC_BR_MEM(P1, brmask, arg);
202  return dp;
203 }
204 
205 static unsigned char *
206 unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
207 {
208  if ((code & 0x10) == 0)
209  {
210  unsigned char byte1 = *dp++;
211 
212  UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
213  (byte1 & 0x7f), arg);
214  }
215  else if ((code & 0x08) == 0)
216  {
217  unsigned char byte1 = *dp++, r, dst;
218 
219  r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
220  dst = (byte1 & 0x7f);
221  switch (r)
222  {
223  case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
224  case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
225  case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
226  case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
227  case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
228  case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
229  case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
230  case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
231  case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
232  case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
233  case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
234  case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
235  default: UNW_DEC_BAD_CODE(r); break;
236  }
237  }
238  else if ((code & 0x7) == 0)
239  UNW_DEC_SPILL_MASK(P4, dp, arg);
240  else if ((code & 0x7) == 1)
241  {
242  unw_word grmask, frmask, byte1, byte2, byte3;
243 
244  byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
245  grmask = ((byte1 >> 4) & 0xf);
246  frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
247  UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
248  }
249  else
250  UNW_DEC_BAD_CODE(code);
251  return dp;
252 }
253 
254 static unsigned char *
255 unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
256 {
257  int gregs = (code & 0x10) != 0;
258  unsigned char mask = (code & 0x0f);
259 
260  if (gregs)
261  UNW_DEC_GR_MEM(P6, mask, arg);
262  else
263  UNW_DEC_FR_MEM(P6, mask, arg);
264  return dp;
265 }
266 
267 static unsigned char *
268 unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
269 {
270  unsigned char r, byte1, byte2;
271  unw_word t, size;
272 
273  if ((code & 0x10) == 0)
274  {
275  r = (code & 0xf);
276  t = unw_decode_uleb128 (&dp);
277  switch (r)
278  {
279  case 0:
280  size = unw_decode_uleb128 (&dp);
281  UNW_DEC_MEM_STACK_F(P7, t, size, arg);
282  break;
283 
284  case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
285  case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
286  case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
287  case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
288  case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
289  case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
290  case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
291  case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
292  case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
293  case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
294  case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
295  case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
296  case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
297  case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
298  case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
299  default: UNW_DEC_BAD_CODE(r); break;
300  }
301  }
302  else
303  {
304  switch (code & 0xf)
305  {
306  case 0x0: /* p8 */
307  {
308  r = *dp++;
309  t = unw_decode_uleb128 (&dp);
310  switch (r)
311  {
312  case 1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
313  case 2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
314  case 3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
315  case 4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
316  case 5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
317  case 6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
318  case 7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
319  case 8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
320  case 9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
321  case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
322  case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
323  case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
324  case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
325  case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
326  case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
327  case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
328  case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
329  case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
330  case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
331  default: UNW_DEC_BAD_CODE(r); break;
332  }
333  }
334  break;
335 
336  case 0x1:
337  byte1 = *dp++; byte2 = *dp++;
338  UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
339  break;
340 
341  case 0xf: /* p10 */
342  byte1 = *dp++; byte2 = *dp++;
343  UNW_DEC_ABI(P10, byte1, byte2, arg);
344  break;
345 
346  case 0x9:
347  return unw_decode_x1 (dp, code, arg);
348 
349  case 0xa:
350  return unw_decode_x2 (dp, code, arg);
351 
352  case 0xb:
353  return unw_decode_x3 (dp, code, arg);
354 
355  case 0xc:
356  return unw_decode_x4 (dp, code, arg);
357 
358  default:
359  UNW_DEC_BAD_CODE(code);
360  break;
361  }
362  }
363  return dp;
364 }
365 
366 static unsigned char *
367 unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
368 {
369  unw_word label = (code & 0x1f);
370 
371  if ((code & 0x20) != 0)
372  UNW_DEC_COPY_STATE(B1, label, arg);
373  else
374  UNW_DEC_LABEL_STATE(B1, label, arg);
375  return dp;
376 }
377 
378 static unsigned char *
379 unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
380 {
381  unw_word t;
382 
383  t = unw_decode_uleb128 (&dp);
384  UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
385  return dp;
386 }
387 
388 static unsigned char *
389 unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
390 {
391  unw_word t, ecount, label;
392 
393  if ((code & 0x10) == 0)
394  {
395  t = unw_decode_uleb128 (&dp);
396  ecount = unw_decode_uleb128 (&dp);
397  UNW_DEC_EPILOGUE(B3, t, ecount, arg);
398  }
399  else if ((code & 0x07) == 0)
400  {
401  label = unw_decode_uleb128 (&dp);
402  if ((code & 0x08) != 0)
403  UNW_DEC_COPY_STATE(B4, label, arg);
404  else
405  UNW_DEC_LABEL_STATE(B4, label, arg);
406  }
407  else
408  switch (code & 0x7)
409  {
410  case 1: return unw_decode_x1 (dp, code, arg);
411  case 2: return unw_decode_x2 (dp, code, arg);
412  case 3: return unw_decode_x3 (dp, code, arg);
413  case 4: return unw_decode_x4 (dp, code, arg);
414  default: UNW_DEC_BAD_CODE(code); break;
415  }
416  return dp;
417 }
418 
419 typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
420 
421 static unw_decoder unw_decode_table[2][8] =
422 {
423  /* prologue table: */
424  {
425  unw_decode_r1, /* 0 */
426  unw_decode_r1,
427  unw_decode_r2,
428  unw_decode_r3,
429  unw_decode_p1, /* 4 */
430  unw_decode_p2_p5,
431  unw_decode_p6,
432  unw_decode_p7_p10
433  },
434  {
435  unw_decode_r1, /* 0 */
436  unw_decode_r1,
437  unw_decode_r2,
438  unw_decode_r3,
439  unw_decode_b1, /* 4 */
440  unw_decode_b1,
441  unw_decode_b2,
442  unw_decode_b3_x4
443  }
444 };
445 
446 /*
447  * Decode one descriptor and return address of next descriptor.
448  */
449 static inline unsigned char *
450 unw_decode (unsigned char *dp, int inside_body, void *arg)
451 {
452  unw_decoder decoder;
453  unsigned char code;
454 
455  code = *dp++;
456  decoder = unw_decode_table[inside_body][code >> 5];
457  dp = (*decoder) (dp, code, arg);
458  return dp;
459 }
Generated on Thu Jan 10 2013 13:07:01 for Linux Kernel by   doxygen 1.8.2