1170263Sdarrenr/* Dwarf2 Expression Evaluator 2170263Sdarrenr Copyright 2001, 2002, 2003 Free Software Foundation, Inc. 3170263Sdarrenr Contributed by Daniel Berlin (dan@dberlin.org) 4170263Sdarrenr 5170263Sdarrenr This file is part of GDB. 6170263Sdarrenr 7170263Sdarrenr This program is free software; you can redistribute it and/or modify 8170263Sdarrenr it under the terms of the GNU General Public License as published by 9170263Sdarrenr the Free Software Foundation; either version 2 of the License, or 10170263Sdarrenr (at your option) any later version. 11170263Sdarrenr 12170263Sdarrenr This program is distributed in the hope that it will be useful, 13170263Sdarrenr but WITHOUT ANY WARRANTY; without even the implied warranty of 14170263Sdarrenr MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15170263Sdarrenr GNU General Public License for more details. 16170263Sdarrenr 17170263Sdarrenr You should have received a copy of the GNU General Public License 18170263Sdarrenr along with this program; if not, write to the Free Software 19170263Sdarrenr Foundation, Inc., 59 Temple Place - Suite 330, 20170263Sdarrenr Boston, MA 02111-1307, USA. */ 21170263Sdarrenr 22170263Sdarrenr#include "defs.h" 23170263Sdarrenr#include "symtab.h" 24170263Sdarrenr#include "gdbtypes.h" 25170263Sdarrenr#include "value.h" 26170263Sdarrenr#include "gdbcore.h" 27170263Sdarrenr#include "elf/dwarf2.h" 28170263Sdarrenr#include "dwarf2expr.h" 29170263Sdarrenr 30170263Sdarrenr/* Local prototypes. */ 31170263Sdarrenr 32170263Sdarrenrstatic void execute_stack_op (struct dwarf_expr_context *, 33170263Sdarrenr unsigned char *, unsigned char *); 34170263Sdarrenr 35170263Sdarrenr/* Create a new context for the expression evaluator. */ 36170263Sdarrenr 37170263Sdarrenrstruct dwarf_expr_context * 38170263Sdarrenrnew_dwarf_expr_context (void) 39170263Sdarrenr{ 40170263Sdarrenr struct dwarf_expr_context *retval; 41170263Sdarrenr retval = xcalloc (1, sizeof (struct dwarf_expr_context)); 42170263Sdarrenr retval->stack_len = 0; 43170263Sdarrenr retval->stack_allocated = 10; 44170263Sdarrenr retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR)); 45170263Sdarrenr return retval; 46170263Sdarrenr} 47170263Sdarrenr 48170263Sdarrenr/* Release the memory allocated to CTX. */ 49170263Sdarrenr 50170263Sdarrenrvoid 51170263Sdarrenrfree_dwarf_expr_context (struct dwarf_expr_context *ctx) 52170263Sdarrenr{ 53170263Sdarrenr xfree (ctx->stack); 54170263Sdarrenr xfree (ctx); 55170263Sdarrenr} 56170263Sdarrenr 57170263Sdarrenr/* Expand the memory allocated to CTX's stack to contain at least 58170263Sdarrenr NEED more elements than are currently used. */ 59170263Sdarrenr 60170263Sdarrenrstatic void 61170263Sdarrenrdwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need) 62170263Sdarrenr{ 63170263Sdarrenr if (ctx->stack_len + need > ctx->stack_allocated) 64170263Sdarrenr { 65170263Sdarrenr size_t newlen = ctx->stack_len + need + 10; 66170263Sdarrenr ctx->stack = xrealloc (ctx->stack, 67170263Sdarrenr newlen * sizeof (CORE_ADDR)); 68170263Sdarrenr ctx->stack_allocated = newlen; 69170263Sdarrenr } 70170263Sdarrenr} 71170263Sdarrenr 72170263Sdarrenr/* Push VALUE onto CTX's stack. */ 73170263Sdarrenr 74170263Sdarrenrvoid 75170263Sdarrenrdwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value) 76170263Sdarrenr{ 77170263Sdarrenr dwarf_expr_grow_stack (ctx, 1); 78170263Sdarrenr ctx->stack[ctx->stack_len++] = value; 79170263Sdarrenr} 80170263Sdarrenr 81170263Sdarrenr/* Pop the top item off of CTX's stack. */ 82170263Sdarrenr 83170263Sdarrenrvoid 84170263Sdarrenrdwarf_expr_pop (struct dwarf_expr_context *ctx) 85170263Sdarrenr{ 86170263Sdarrenr if (ctx->stack_len <= 0) 87170263Sdarrenr error ("dwarf expression stack underflow"); 88170263Sdarrenr ctx->stack_len--; 89170263Sdarrenr} 90170263Sdarrenr 91170263Sdarrenr/* Retrieve the N'th item on CTX's stack. */ 92170263Sdarrenr 93170263SdarrenrCORE_ADDR 94170263Sdarrenrdwarf_expr_fetch (struct dwarf_expr_context *ctx, int n) 95170263Sdarrenr{ 96170263Sdarrenr if (ctx->stack_len < n) 97170263Sdarrenr error ("Asked for position %d of stack, stack only has %d elements on it\n", 98170263Sdarrenr n, ctx->stack_len); 99170263Sdarrenr return ctx->stack[ctx->stack_len - (1 + n)]; 100170263Sdarrenr 101170263Sdarrenr} 102170263Sdarrenr 103170263Sdarrenr/* Evaluate the expression at ADDR (LEN bytes long) using the context 104170263Sdarrenr CTX. */ 105170263Sdarrenr 106170263Sdarrenrvoid 107170263Sdarrenrdwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr, 108170263Sdarrenr size_t len) 109170263Sdarrenr{ 110170263Sdarrenr execute_stack_op (ctx, addr, addr + len); 111170263Sdarrenr} 112170263Sdarrenr 113170263Sdarrenr/* Decode the unsigned LEB128 constant at BUF into the variable pointed to 114170263Sdarrenr by R, and return the new value of BUF. Verify that it doesn't extend 115170263Sdarrenr past BUF_END. */ 116170263Sdarrenr 117170263Sdarrenrunsigned char * 118170263Sdarrenrread_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r) 119170263Sdarrenr{ 120170263Sdarrenr unsigned shift = 0; 121170263Sdarrenr ULONGEST result = 0; 122170263Sdarrenr unsigned char byte; 123170263Sdarrenr 124170263Sdarrenr while (1) 125170263Sdarrenr { 126170263Sdarrenr if (buf >= buf_end) 127170263Sdarrenr error ("read_uleb128: Corrupted DWARF expression."); 128170263Sdarrenr 129170263Sdarrenr byte = *buf++; 130170263Sdarrenr result |= (byte & 0x7f) << shift; 131170263Sdarrenr if ((byte & 0x80) == 0) 132170263Sdarrenr break; 133170263Sdarrenr shift += 7; 134170263Sdarrenr } 135170263Sdarrenr *r = result; 136170263Sdarrenr return buf; 137170263Sdarrenr} 138170263Sdarrenr 139170263Sdarrenr/* Decode the signed LEB128 constant at BUF into the variable pointed to 140170263Sdarrenr by R, and return the new value of BUF. Verify that it doesn't extend 141170263Sdarrenr past BUF_END. */ 142170263Sdarrenr 143170263Sdarrenrunsigned char * 144170263Sdarrenrread_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r) 145170263Sdarrenr{ 146170263Sdarrenr unsigned shift = 0; 147170263Sdarrenr LONGEST result = 0; 148170263Sdarrenr unsigned char byte; 149170263Sdarrenr 150170263Sdarrenr while (1) 151170263Sdarrenr { 152170263Sdarrenr if (buf >= buf_end) 153170263Sdarrenr error ("read_sleb128: Corrupted DWARF expression."); 154170263Sdarrenr 155170263Sdarrenr byte = *buf++; 156170263Sdarrenr result |= (byte & 0x7f) << shift; 157170263Sdarrenr shift += 7; 158170263Sdarrenr if ((byte & 0x80) == 0) 159170263Sdarrenr break; 160170263Sdarrenr } 161170263Sdarrenr if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0) 162170263Sdarrenr result |= -(1 << shift); 163170263Sdarrenr 164170263Sdarrenr *r = result; 165170263Sdarrenr return buf; 166170263Sdarrenr} 167170263Sdarrenr 168170263Sdarrenr/* Read an address from BUF, and verify that it doesn't extend past 169170263Sdarrenr BUF_END. The address is returned, and *BYTES_READ is set to the 170170263Sdarrenr number of bytes read from BUF. */ 171170263Sdarrenr 172170263SdarrenrCORE_ADDR 173170263Sdarrenrdwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read) 174170263Sdarrenr{ 175170263Sdarrenr CORE_ADDR result; 176170263Sdarrenr 177170263Sdarrenr if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT) 178170263Sdarrenr error ("dwarf2_read_address: Corrupted DWARF expression."); 179170263Sdarrenr 180170263Sdarrenr *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT; 181170263Sdarrenr /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2 182170263Sdarrenr address is always unsigned. That may or may not be true. */ 183170263Sdarrenr result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT); 184170263Sdarrenr return result; 185170263Sdarrenr} 186170263Sdarrenr 187170263Sdarrenr/* Return the type of an address, for unsigned arithmetic. */ 188170263Sdarrenr 189170263Sdarrenrstatic struct type * 190170263Sdarrenrunsigned_address_type (void) 191170263Sdarrenr{ 192170263Sdarrenr switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT) 193170263Sdarrenr { 194170263Sdarrenr case 2: 195170263Sdarrenr return builtin_type_uint16; 196170263Sdarrenr case 4: 197170263Sdarrenr return builtin_type_uint32; 198170263Sdarrenr case 8: 199170263Sdarrenr return builtin_type_uint64; 200170263Sdarrenr default: 201170263Sdarrenr internal_error (__FILE__, __LINE__, 202170263Sdarrenr "Unsupported address size.\n"); 203170263Sdarrenr } 204170263Sdarrenr} 205170263Sdarrenr 206170263Sdarrenr/* Return the type of an address, for signed arithmetic. */ 207170263Sdarrenr 208170263Sdarrenrstatic struct type * 209170263Sdarrenrsigned_address_type (void) 210170263Sdarrenr{ 211170263Sdarrenr switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT) 212170263Sdarrenr { 213170263Sdarrenr case 2: 214170263Sdarrenr return builtin_type_int16; 215170263Sdarrenr case 4: 216170263Sdarrenr return builtin_type_int32; 217170263Sdarrenr case 8: 218170263Sdarrenr return builtin_type_int64; 219170263Sdarrenr default: 220170263Sdarrenr internal_error (__FILE__, __LINE__, 221170263Sdarrenr "Unsupported address size.\n"); 222170263Sdarrenr } 223170263Sdarrenr} 224170263Sdarrenr 225170263Sdarrenr/* The engine for the expression evaluator. Using the context in CTX, 226170263Sdarrenr evaluate the expression between OP_PTR and OP_END. */ 227170263Sdarrenr 228170263Sdarrenrstatic void 229170263Sdarrenrexecute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr, 230170263Sdarrenr unsigned char *op_end) 231170263Sdarrenr{ 232170263Sdarrenr ctx->in_reg = 0; 233170263Sdarrenr 234170263Sdarrenr while (op_ptr < op_end) 235170263Sdarrenr { 236170263Sdarrenr enum dwarf_location_atom op = *op_ptr++; 237170263Sdarrenr CORE_ADDR result; 238170263Sdarrenr ULONGEST uoffset, reg; 239170263Sdarrenr LONGEST offset; 240170263Sdarrenr int bytes_read; 241170263Sdarrenr 242170263Sdarrenr switch (op) 243170263Sdarrenr { 244170263Sdarrenr case DW_OP_lit0: 245170263Sdarrenr case DW_OP_lit1: 246170263Sdarrenr case DW_OP_lit2: 247170263Sdarrenr case DW_OP_lit3: 248170263Sdarrenr case DW_OP_lit4: 249170263Sdarrenr case DW_OP_lit5: 250170263Sdarrenr case DW_OP_lit6: 251170263Sdarrenr case DW_OP_lit7: 252170263Sdarrenr case DW_OP_lit8: 253170263Sdarrenr case DW_OP_lit9: 254170263Sdarrenr case DW_OP_lit10: 255170263Sdarrenr case DW_OP_lit11: 256170263Sdarrenr case DW_OP_lit12: 257170263Sdarrenr case DW_OP_lit13: 258170263Sdarrenr case DW_OP_lit14: 259170263Sdarrenr case DW_OP_lit15: 260170263Sdarrenr case DW_OP_lit16: 261170263Sdarrenr case DW_OP_lit17: 262170263Sdarrenr case DW_OP_lit18: 263170263Sdarrenr case DW_OP_lit19: 264170263Sdarrenr case DW_OP_lit20: 265170263Sdarrenr case DW_OP_lit21: 266170263Sdarrenr case DW_OP_lit22: 267170263Sdarrenr case DW_OP_lit23: 268170263Sdarrenr case DW_OP_lit24: 269170263Sdarrenr case DW_OP_lit25: 270170263Sdarrenr case DW_OP_lit26: 271170263Sdarrenr case DW_OP_lit27: 272170263Sdarrenr case DW_OP_lit28: 273170263Sdarrenr case DW_OP_lit29: 274170263Sdarrenr case DW_OP_lit30: 275170263Sdarrenr case DW_OP_lit31: 276170263Sdarrenr result = op - DW_OP_lit0; 277170263Sdarrenr break; 278170263Sdarrenr 279170263Sdarrenr case DW_OP_addr: 280170263Sdarrenr result = dwarf2_read_address (op_ptr, op_end, &bytes_read); 281170263Sdarrenr op_ptr += bytes_read; 282170263Sdarrenr break; 283170263Sdarrenr 284170263Sdarrenr case DW_OP_const1u: 285170263Sdarrenr result = extract_unsigned_integer (op_ptr, 1); 286170263Sdarrenr op_ptr += 1; 287170263Sdarrenr break; 288170263Sdarrenr case DW_OP_const1s: 289170263Sdarrenr result = extract_signed_integer (op_ptr, 1); 290170263Sdarrenr op_ptr += 1; 291170263Sdarrenr break; 292170263Sdarrenr case DW_OP_const2u: 293170263Sdarrenr result = extract_unsigned_integer (op_ptr, 2); 294170263Sdarrenr op_ptr += 2; 295170263Sdarrenr break; 296170263Sdarrenr case DW_OP_const2s: 297170263Sdarrenr result = extract_signed_integer (op_ptr, 2); 298170263Sdarrenr op_ptr += 2; 299170263Sdarrenr break; 300170263Sdarrenr case DW_OP_const4u: 301170263Sdarrenr result = extract_unsigned_integer (op_ptr, 4); 302170263Sdarrenr op_ptr += 4; 303170263Sdarrenr break; 304170263Sdarrenr case DW_OP_const4s: 305170263Sdarrenr result = extract_signed_integer (op_ptr, 4); 306170263Sdarrenr op_ptr += 4; 307170263Sdarrenr break; 308170263Sdarrenr case DW_OP_const8u: 309170263Sdarrenr result = extract_unsigned_integer (op_ptr, 8); 310170263Sdarrenr op_ptr += 8; 311170263Sdarrenr break; 312170263Sdarrenr case DW_OP_const8s: 313170263Sdarrenr result = extract_signed_integer (op_ptr, 8); 314170263Sdarrenr op_ptr += 8; 315170263Sdarrenr break; 316170263Sdarrenr case DW_OP_constu: 317170263Sdarrenr op_ptr = read_uleb128 (op_ptr, op_end, &uoffset); 318170263Sdarrenr result = uoffset; 319170263Sdarrenr break; 320170263Sdarrenr case DW_OP_consts: 321170263Sdarrenr op_ptr = read_sleb128 (op_ptr, op_end, &offset); 322170263Sdarrenr result = offset; 323170263Sdarrenr break; 324170263Sdarrenr 325170263Sdarrenr /* The DW_OP_reg operations are required to occur alone in 326170263Sdarrenr location expressions. */ 327170263Sdarrenr case DW_OP_reg0: 328170263Sdarrenr case DW_OP_reg1: 329170263Sdarrenr case DW_OP_reg2: 330170263Sdarrenr case DW_OP_reg3: 331170263Sdarrenr case DW_OP_reg4: 332170263Sdarrenr case DW_OP_reg5: 333170263Sdarrenr case DW_OP_reg6: 334170263Sdarrenr case DW_OP_reg7: 335170263Sdarrenr case DW_OP_reg8: 336170263Sdarrenr case DW_OP_reg9: 337170263Sdarrenr case DW_OP_reg10: 338170263Sdarrenr case DW_OP_reg11: 339170263Sdarrenr case DW_OP_reg12: 340170263Sdarrenr case DW_OP_reg13: 341170263Sdarrenr case DW_OP_reg14: 342170263Sdarrenr case DW_OP_reg15: 343170263Sdarrenr case DW_OP_reg16: 344170263Sdarrenr case DW_OP_reg17: 345170263Sdarrenr case DW_OP_reg18: 346170263Sdarrenr case DW_OP_reg19: 347170263Sdarrenr case DW_OP_reg20: 348170263Sdarrenr case DW_OP_reg21: 349170263Sdarrenr case DW_OP_reg22: 350170263Sdarrenr case DW_OP_reg23: 351 case DW_OP_reg24: 352 case DW_OP_reg25: 353 case DW_OP_reg26: 354 case DW_OP_reg27: 355 case DW_OP_reg28: 356 case DW_OP_reg29: 357 case DW_OP_reg30: 358 case DW_OP_reg31: 359 if (op_ptr != op_end && *op_ptr != DW_OP_piece) 360 error ("DWARF-2 expression error: DW_OP_reg operations must be " 361 "used either alone or in conjuction with DW_OP_piece."); 362 363 result = op - DW_OP_reg0; 364 ctx->in_reg = 1; 365 366 break; 367 368 case DW_OP_regx: 369 op_ptr = read_uleb128 (op_ptr, op_end, ®); 370 if (op_ptr != op_end && *op_ptr != DW_OP_piece) 371 error ("DWARF-2 expression error: DW_OP_reg operations must be " 372 "used either alone or in conjuction with DW_OP_piece."); 373 374 result = reg; 375 ctx->in_reg = 1; 376 break; 377 378 case DW_OP_breg0: 379 case DW_OP_breg1: 380 case DW_OP_breg2: 381 case DW_OP_breg3: 382 case DW_OP_breg4: 383 case DW_OP_breg5: 384 case DW_OP_breg6: 385 case DW_OP_breg7: 386 case DW_OP_breg8: 387 case DW_OP_breg9: 388 case DW_OP_breg10: 389 case DW_OP_breg11: 390 case DW_OP_breg12: 391 case DW_OP_breg13: 392 case DW_OP_breg14: 393 case DW_OP_breg15: 394 case DW_OP_breg16: 395 case DW_OP_breg17: 396 case DW_OP_breg18: 397 case DW_OP_breg19: 398 case DW_OP_breg20: 399 case DW_OP_breg21: 400 case DW_OP_breg22: 401 case DW_OP_breg23: 402 case DW_OP_breg24: 403 case DW_OP_breg25: 404 case DW_OP_breg26: 405 case DW_OP_breg27: 406 case DW_OP_breg28: 407 case DW_OP_breg29: 408 case DW_OP_breg30: 409 case DW_OP_breg31: 410 { 411 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 412 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0); 413 result += offset; 414 } 415 break; 416 case DW_OP_bregx: 417 { 418 op_ptr = read_uleb128 (op_ptr, op_end, ®); 419 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 420 result = (ctx->read_reg) (ctx->baton, reg); 421 result += offset; 422 } 423 break; 424 case DW_OP_fbreg: 425 { 426 unsigned char *datastart; 427 size_t datalen; 428 unsigned int before_stack_len; 429 430 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 431 /* Rather than create a whole new context, we simply 432 record the stack length before execution, then reset it 433 afterwards, effectively erasing whatever the recursive 434 call put there. */ 435 before_stack_len = ctx->stack_len; 436 /* FIXME: cagney/2003-03-26: This code should be using 437 get_frame_base_address(), and then implement a dwarf2 438 specific this_base method. */ 439 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen); 440 dwarf_expr_eval (ctx, datastart, datalen); 441 result = dwarf_expr_fetch (ctx, 0); 442 if (ctx->in_reg) 443 result = (ctx->read_reg) (ctx->baton, result); 444 result = result + offset; 445 ctx->stack_len = before_stack_len; 446 ctx->in_reg = 0; 447 } 448 break; 449 case DW_OP_dup: 450 result = dwarf_expr_fetch (ctx, 0); 451 break; 452 453 case DW_OP_drop: 454 dwarf_expr_pop (ctx); 455 goto no_push; 456 457 case DW_OP_pick: 458 offset = *op_ptr++; 459 result = dwarf_expr_fetch (ctx, offset); 460 break; 461 462 case DW_OP_over: 463 result = dwarf_expr_fetch (ctx, 1); 464 break; 465 466 case DW_OP_rot: 467 { 468 CORE_ADDR t1, t2, t3; 469 470 if (ctx->stack_len < 3) 471 error ("Not enough elements for DW_OP_rot. Need 3, have %d\n", 472 ctx->stack_len); 473 t1 = ctx->stack[ctx->stack_len - 1]; 474 t2 = ctx->stack[ctx->stack_len - 2]; 475 t3 = ctx->stack[ctx->stack_len - 3]; 476 ctx->stack[ctx->stack_len - 1] = t2; 477 ctx->stack[ctx->stack_len - 2] = t3; 478 ctx->stack[ctx->stack_len - 3] = t1; 479 goto no_push; 480 } 481 482 case DW_OP_deref: 483 case DW_OP_deref_size: 484 case DW_OP_abs: 485 case DW_OP_neg: 486 case DW_OP_not: 487 case DW_OP_plus_uconst: 488 /* Unary operations. */ 489 result = dwarf_expr_fetch (ctx, 0); 490 dwarf_expr_pop (ctx); 491 492 switch (op) 493 { 494 case DW_OP_deref: 495 { 496 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT); 497 int bytes_read; 498 499 (ctx->read_mem) (ctx->baton, buf, result, 500 TARGET_ADDR_BIT / TARGET_CHAR_BIT); 501 result = dwarf2_read_address (buf, 502 buf + (TARGET_ADDR_BIT 503 / TARGET_CHAR_BIT), 504 &bytes_read); 505 } 506 break; 507 508 case DW_OP_deref_size: 509 { 510 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT); 511 int bytes_read; 512 513 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++); 514 result = dwarf2_read_address (buf, 515 buf + (TARGET_ADDR_BIT 516 / TARGET_CHAR_BIT), 517 &bytes_read); 518 } 519 break; 520 521 case DW_OP_abs: 522 if ((signed int) result < 0) 523 result = -result; 524 break; 525 case DW_OP_neg: 526 result = -result; 527 break; 528 case DW_OP_not: 529 result = ~result; 530 break; 531 case DW_OP_plus_uconst: 532 op_ptr = read_uleb128 (op_ptr, op_end, ®); 533 result += reg; 534 break; 535 } 536 break; 537 538 case DW_OP_and: 539 case DW_OP_div: 540 case DW_OP_minus: 541 case DW_OP_mod: 542 case DW_OP_mul: 543 case DW_OP_or: 544 case DW_OP_plus: 545 case DW_OP_shl: 546 case DW_OP_shr: 547 case DW_OP_shra: 548 case DW_OP_xor: 549 case DW_OP_le: 550 case DW_OP_ge: 551 case DW_OP_eq: 552 case DW_OP_lt: 553 case DW_OP_gt: 554 case DW_OP_ne: 555 { 556 /* Binary operations. Use the value engine to do computations in 557 the right width. */ 558 CORE_ADDR first, second; 559 enum exp_opcode binop; 560 struct value *val1, *val2; 561 562 second = dwarf_expr_fetch (ctx, 0); 563 dwarf_expr_pop (ctx); 564 565 first = dwarf_expr_fetch (ctx, 0); 566 dwarf_expr_pop (ctx); 567 568 val1 = value_from_longest (unsigned_address_type (), first); 569 val2 = value_from_longest (unsigned_address_type (), second); 570 571 switch (op) 572 { 573 case DW_OP_and: 574 binop = BINOP_BITWISE_AND; 575 break; 576 case DW_OP_div: 577 binop = BINOP_DIV; 578 case DW_OP_minus: 579 binop = BINOP_SUB; 580 break; 581 case DW_OP_mod: 582 binop = BINOP_MOD; 583 break; 584 case DW_OP_mul: 585 binop = BINOP_MUL; 586 break; 587 case DW_OP_or: 588 binop = BINOP_BITWISE_IOR; 589 break; 590 case DW_OP_plus: 591 binop = BINOP_ADD; 592 break; 593 case DW_OP_shl: 594 binop = BINOP_LSH; 595 break; 596 case DW_OP_shr: 597 binop = BINOP_RSH; 598 case DW_OP_shra: 599 binop = BINOP_RSH; 600 val1 = value_from_longest (signed_address_type (), first); 601 break; 602 case DW_OP_xor: 603 binop = BINOP_BITWISE_XOR; 604 break; 605 case DW_OP_le: 606 binop = BINOP_LEQ; 607 break; 608 case DW_OP_ge: 609 binop = BINOP_GEQ; 610 break; 611 case DW_OP_eq: 612 binop = BINOP_EQUAL; 613 break; 614 case DW_OP_lt: 615 binop = BINOP_LESS; 616 break; 617 case DW_OP_gt: 618 binop = BINOP_GTR; 619 break; 620 case DW_OP_ne: 621 binop = BINOP_NOTEQUAL; 622 break; 623 default: 624 internal_error (__FILE__, __LINE__, 625 "Can't be reached."); 626 } 627 result = value_as_long (value_binop (val1, val2, binop)); 628 } 629 break; 630 631 case DW_OP_GNU_push_tls_address: 632 /* Variable is at a constant offset in the thread-local 633 storage block into the objfile for the current thread and 634 the dynamic linker module containing this expression. Here 635 we return returns the offset from that base. The top of the 636 stack has the offset from the beginning of the thread 637 control block at which the variable is located. Nothing 638 should follow this operator, so the top of stack would be 639 returned. */ 640 result = dwarf_expr_fetch (ctx, 0); 641 dwarf_expr_pop (ctx); 642 result = (ctx->get_tls_address) (ctx->baton, result); 643 break; 644 645 case DW_OP_skip: 646 offset = extract_signed_integer (op_ptr, 2); 647 op_ptr += 2; 648 op_ptr += offset; 649 goto no_push; 650 651 case DW_OP_bra: 652 offset = extract_signed_integer (op_ptr, 2); 653 op_ptr += 2; 654 if (dwarf_expr_fetch (ctx, 0) != 0) 655 op_ptr += offset; 656 dwarf_expr_pop (ctx); 657 goto no_push; 658 659 case DW_OP_nop: 660 goto no_push; 661 662 default: 663 error ("Unhandled dwarf expression opcode 0x%x", op); 664 } 665 666 /* Most things push a result value. */ 667 dwarf_expr_push (ctx, result); 668 no_push:; 669 } 670} 671