gdb/dwarf2loc.c

   1 /* DWARF 2 location expression support for GDB.
   2
   3    Copyright 2003, 2005 Free Software Foundation, Inc.
   4
   5    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or (at
  12    your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful, but
  15    WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "ui-out.h"
  26 #include "value.h"
  27 #include "frame.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "inferior.h"
  31 #include "ax.h"
  32 #include "ax-gdb.h"
  33 #include "regcache.h"
  34 #include "objfiles.h"
  35 #include "exceptions.h"
  36
  37 #include "elf/dwarf2.h"
  38 #include "dwarf2expr.h"
  39 #include "dwarf2loc.h"
  40
  41 #include "gdb_string.h"
  42
  43 #ifndef DWARF2_REG_TO_REGNUM
  44 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  45 #endif
  46
  47 /* A helper function for dealing with location lists.  Given a
  48    symbol baton (BATON) and a pc value (PC), find the appropriate
  49    location expression, set *LOCEXPR_LENGTH, and return a pointer
  50    to the beginning of the expression.  Returns NULL on failure.
  51
  52    For now, only return the first matching location expression; there
  53    can be more than one in the list.  */
  54
  55 static char *
  56 find_location_expression (struct dwarf2_loclist_baton *baton,
  57                           size_t *locexpr_length, CORE_ADDR pc)
  58 {
  59   CORE_ADDR low, high;
  60   char *loc_ptr, *buf_end;
  61   unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT, length;
  62   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  63   /* Adjust base_address for relocatable objects.  */
  64   CORE_ADDR base_offset = ANOFFSET (baton->objfile->section_offsets,
  65                                     SECT_OFF_TEXT (baton->objfile));
  66   CORE_ADDR base_address = baton->base_address + base_offset;
  67
  68   loc_ptr = baton->data;
  69   buf_end = baton->data + baton->size;
  70
  71   while (1)
  72     {
  73       low = dwarf2_read_address (loc_ptr, buf_end, &length);
  74       loc_ptr += length;
  75       high = dwarf2_read_address (loc_ptr, buf_end, &length);
  76       loc_ptr += length;
  77
  78       /* An end-of-list entry.  */
  79       if (low == 0 && high == 0)
  80         return NULL;
  81
  82       /* A base-address-selection entry.  */
  83       if ((low & base_mask) == base_mask)
  84         {
  85           base_address = high;
  86           continue;
  87         }
  88
  89       /* Otherwise, a location expression entry.  */
  90       low += base_address;
  91       high += base_address;
  92
  93       length = extract_unsigned_integer (loc_ptr, 2);
  94       loc_ptr += 2;
  95
  96       if (pc >= low && pc < high)
  97         {
  98           *locexpr_length = length;
  99           return loc_ptr;
 100         }
 101
 102       loc_ptr += length;
 103     }
 104 }
 105
 106 /* This is the baton used when performing dwarf2 expression
 107    evaluation.  */
 108 struct dwarf_expr_baton
 109 {
 110   struct frame_info *frame;
 111   struct objfile *objfile;
 112 };
 113
 114 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 115
 116 /* Using the frame specified in BATON, read register REGNUM.  The lval
 117    type will be returned in LVALP, and for lval_memory the register
 118    save address will be returned in ADDRP.  */
 119 static CORE_ADDR
 120 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 121 {
 122   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 123   CORE_ADDR result, save_addr;
 124   enum lval_type lval_type;
 125   char *buf;
 126   int optimized, regnum, realnum, regsize;
 127
 128   regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 129   regsize = register_size (current_gdbarch, regnum);
 130   buf = (char *) alloca (regsize);
 131
 132   frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
 133                   &realnum, buf);
 134   /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
 135      address is always unsigned.  That may or may not be true.  */
 136   result = extract_unsigned_integer (buf, regsize);
 137
 138   return result;
 139 }
 140
 141 /* Read memory at ADDR (length LEN) into BUF.  */
 142
 143 static void
 144 dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 145 {
 146   read_memory (addr, buf, len);
 147 }
 148
 149 /* Using the frame specified in BATON, find the location expression
 150    describing the frame base.  Return a pointer to it in START and
 151    its length in LENGTH.  */
 152 static void
 153 dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
 154 {
 155   /* FIXME: cagney/2003-03-26: This code should be using
 156      get_frame_base_address(), and then implement a dwarf2 specific
 157      this_base method.  */
 158   struct symbol *framefunc;
 159   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 160
 161   framefunc = get_frame_function (debaton->frame);
 162
 163   if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
 164     {
 165       struct dwarf2_loclist_baton *symbaton;
 166       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 167       *start = find_location_expression (symbaton, length,
 168                                          get_frame_pc (debaton->frame));
 169     }
 170   else
 171     {
 172       struct dwarf2_locexpr_baton *symbaton;
 173       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 174       *length = symbaton->size;
 175       *start = symbaton->data;
 176     }
 177
 178   if (*start == NULL)
 179     error (_("Could not find the frame base for \"%s\"."),
 180            SYMBOL_NATURAL_NAME (framefunc));
 181 }
 182
 183 /* Using the objfile specified in BATON, find the address for the
 184    current thread's thread-local storage with offset OFFSET.  */
 185 static CORE_ADDR
 186 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 187 {
 188   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 189   volatile CORE_ADDR addr = 0;
 190
 191   if (target_get_thread_local_address_p ()
 192       && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
 193     {
 194       ptid_t ptid = inferior_ptid;
 195       struct objfile *objfile = debaton->objfile;
 196       volatile struct gdb_exception ex;
 197
 198       TRY_CATCH (ex, RETURN_MASK_ALL)
 199         {
 200           CORE_ADDR lm_addr;
 201
 202           /* Fetch the load module address for this objfile.  */
 203           lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
 204                                                            objfile);
 205           /* If it's 0, throw the appropriate exception.  */
 206           if (lm_addr == 0)
 207             throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
 208                          _("TLS load module not found"));
 209
 210           addr = target_get_thread_local_address (ptid, lm_addr, offset);
 211         }
 212       /* If an error occurred, print TLS related messages here.  Otherwise,
 213          throw the error to some higher catcher.  */
 214       if (ex.reason < 0)
 215         {
 216           int objfile_is_library = (objfile->flags & OBJF_SHARED);
 217
 218           switch (ex.error)
 219             {
 220             case TLS_NO_LIBRARY_SUPPORT_ERROR:
 221               error (_("Cannot find thread-local variables in this thread library."));
 222               break;
 223             case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
 224               if (objfile_is_library)
 225                 error (_("Cannot find shared library `%s' in dynamic"
 226                          " linker's load module list"), objfile->name);
 227               else
 228                 error (_("Cannot find executable file `%s' in dynamic"
 229                          " linker's load module list"), objfile->name);
 230               break;
 231             case TLS_NOT_ALLOCATED_YET_ERROR:
 232               if (objfile_is_library)
 233                 error (_("The inferior has not yet allocated storage for"
 234                          " thread-local variables in\n"
 235                          "the shared library `%s'\n"
 236                          "for %s"),
 237                        objfile->name, target_pid_to_str (ptid));
 238               else
 239                 error (_("The inferior has not yet allocated storage for"
 240                          " thread-local variables in\n"
 241                          "the executable `%s'\n"
 242                          "for %s"),
 243                        objfile->name, target_pid_to_str (ptid));
 244               break;
 245             case TLS_GENERIC_ERROR:
 246               if (objfile_is_library)
 247                 error (_("Cannot find thread-local storage for %s, "
 248                          "shared library %s:\n%s"),
 249                        target_pid_to_str (ptid),
 250                        objfile->name, ex.message);
 251               else
 252                 error (_("Cannot find thread-local storage for %s, "
 253                          "executable file %s:\n%s"),
 254                        target_pid_to_str (ptid),
 255                        objfile->name, ex.message);
 256               break;
 257             default:
 258               throw_exception (ex);
 259               break;
 260             }
 261         }
 262     }
 263   /* It wouldn't be wrong here to try a gdbarch method, too; finding
 264      TLS is an ABI-specific thing.  But we don't do that yet.  */
 265   else
 266     error (_("Cannot find thread-local variables on this target"));
 267
 268   return addr;
 269 }
 270
 271 /* Evaluate a location description, starting at DATA and with length
 272    SIZE, to find the current location of variable VAR in the context
 273    of FRAME.  */
 274 static struct value *
 275 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 276                           unsigned char *data, unsigned short size,
 277                           struct objfile *objfile)
 278 {
 279   struct gdbarch *arch = get_frame_arch (frame);
 280   struct value *retval;
 281   struct dwarf_expr_baton baton;
 282   struct dwarf_expr_context *ctx;
 283
 284   if (size == 0)
 285     {
 286       retval = allocate_value (SYMBOL_TYPE (var));
 287       VALUE_LVAL (retval) = not_lval;
 288       set_value_optimized_out (retval, 1);
 289     }
 290
 291   baton.frame = frame;
 292   baton.objfile = objfile;
 293
 294   ctx = new_dwarf_expr_context ();
 295   ctx->baton = &baton;
 296   ctx->read_reg = dwarf_expr_read_reg;
 297   ctx->read_mem = dwarf_expr_read_mem;
 298   ctx->get_frame_base = dwarf_expr_frame_base;
 299   ctx->get_tls_address = dwarf_expr_tls_address;
 300
 301   dwarf_expr_eval (ctx, data, size);
 302   if (ctx->num_pieces > 0)
 303     {
 304       /* We haven't implemented splicing together pieces from
 305          arbitrary sources yet.  */
 306       error (_("The value of variable '%s' is distributed across several\n"
 307              "locations, and GDB cannot access its value.\n"),
 308              SYMBOL_NATURAL_NAME (var));
 309     }
 310   else if (ctx->in_reg)
 311     {
 312       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 313       int gdb_regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 314       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 315     }
 316   else
 317     {
 318       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 319
 320       retval = allocate_value (SYMBOL_TYPE (var));
 321       VALUE_LVAL (retval) = lval_memory;
 322       set_value_lazy (retval, 1);
 323       VALUE_ADDRESS (retval) = address;
 324     }
 325
 326   free_dwarf_expr_context (ctx);
 327
 328   return retval;
 329 }
 330
 331
 332
 333
 334 \f
 335 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 336
 337 struct needs_frame_baton
 338 {
 339   int needs_frame;
 340 };
 341
 342 /* Reads from registers do require a frame.  */
 343 static CORE_ADDR
 344 needs_frame_read_reg (void *baton, int regnum)
 345 {
 346   struct needs_frame_baton *nf_baton = baton;
 347   nf_baton->needs_frame = 1;
 348   return 1;
 349 }
 350
 351 /* Reads from memory do not require a frame.  */
 352 static void
 353 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 354 {
 355   memset (buf, 0, len);
 356 }
 357
 358 /* Frame-relative accesses do require a frame.  */
 359 static void
 360 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
 361 {
 362   static char lit0 = DW_OP_lit0;
 363   struct needs_frame_baton *nf_baton = baton;
 364
 365   *start = &lit0;
 366   *length = 1;
 367
 368   nf_baton->needs_frame = 1;
 369 }
 370
 371 /* Thread-local accesses do require a frame.  */
 372 static CORE_ADDR
 373 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 374 {
 375   struct needs_frame_baton *nf_baton = baton;
 376   nf_baton->needs_frame = 1;
 377   return 1;
 378 }
 379
 380 /* Return non-zero iff the location expression at DATA (length SIZE)
 381    requires a frame to evaluate.  */
 382
 383 static int
 384 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 385 {
 386   struct needs_frame_baton baton;
 387   struct dwarf_expr_context *ctx;
 388   int in_reg;
 389
 390   baton.needs_frame = 0;
 391
 392   ctx = new_dwarf_expr_context ();
 393   ctx->baton = &baton;
 394   ctx->read_reg = needs_frame_read_reg;
 395   ctx->read_mem = needs_frame_read_mem;
 396   ctx->get_frame_base = needs_frame_frame_base;
 397   ctx->get_tls_address = needs_frame_tls_address;
 398
 399   dwarf_expr_eval (ctx, data, size);
 400
 401   in_reg = ctx->in_reg;
 402
 403   if (ctx->num_pieces > 0)
 404     {
 405       int i;
 406
 407       /* If the location has several pieces, and any of them are in
 408          registers, then we will need a frame to fetch them from.  */
 409       for (i = 0; i < ctx->num_pieces; i++)
 410         if (ctx->pieces[i].in_reg)
 411           in_reg = 1;
 412     }
 413
 414   free_dwarf_expr_context (ctx);
 415
 416   return baton.needs_frame || in_reg;
 417 }
 418
 419 static void
 420 dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 421                            struct axs_value * value, unsigned char *data,
 422                            int size)
 423 {
 424   if (size == 0)
 425     error (_("Symbol \"%s\" has been optimized out."),
 426            SYMBOL_PRINT_NAME (symbol));
 427
 428   if (size == 1
 429       && data[0] >= DW_OP_reg0
 430       && data[0] <= DW_OP_reg31)
 431     {
 432       value->kind = axs_lvalue_register;
 433       value->u.reg = data[0] - DW_OP_reg0;
 434     }
 435   else if (data[0] == DW_OP_regx)
 436     {
 437       ULONGEST reg;
 438       read_uleb128 (data + 1, data + size, &reg);
 439       value->kind = axs_lvalue_register;
 440       value->u.reg = reg;
 441     }
 442   else if (data[0] == DW_OP_fbreg)
 443     {
 444       /* And this is worse than just minimal; we should honor the frame base
 445          as above.  */
 446       int frame_reg;
 447       LONGEST frame_offset;
 448       unsigned char *buf_end;
 449
 450       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 451       if (buf_end != data + size)
 452         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 453                SYMBOL_PRINT_NAME (symbol));
 454
 455       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 456       ax_reg (ax, frame_reg);
 457       ax_const_l (ax, frame_offset);
 458       ax_simple (ax, aop_add);
 459
 460       ax_const_l (ax, frame_offset);
 461       ax_simple (ax, aop_add);
 462       value->kind = axs_lvalue_memory;
 463     }
 464   else
 465     error (_("Unsupported DWARF opcode in the location of \"%s\"."),
 466            SYMBOL_PRINT_NAME (symbol));
 467 }
 468 \f
 469 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 470    evaluator to calculate the location.  */
 471 static struct value *
 472 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 473 {
 474   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 475   struct value *val;
 476   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 477                                   dlbaton->objfile);
 478
 479   return val;
 480 }
 481
 482 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 483 static int
 484 locexpr_read_needs_frame (struct symbol *symbol)
 485 {
 486   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 487   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 488 }
 489
 490 /* Print a natural-language description of SYMBOL to STREAM.  */
 491 static int
 492 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 493 {
 494   /* FIXME: be more extensive.  */
 495   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 496
 497   if (dlbaton->size == 1
 498       && dlbaton->data[0] >= DW_OP_reg0
 499       && dlbaton->data[0] <= DW_OP_reg31)
 500     {
 501       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 502       fprintf_filtered (stream,
 503                         "a variable in register %s", REGISTER_NAME (regno));
 504       return 1;
 505     }
 506
 507   /* The location expression for a TLS variable looks like this (on a
 508      64-bit LE machine):
 509
 510      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 511                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 512
 513      0x3 is the encoding for DW_OP_addr, which has an operand as long
 514      as the size of an address on the target machine (here is 8
 515      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 516      The operand represents the offset at which the variable is within
 517      the thread local storage.  */
 518
 519   if (dlbaton->size > 1
 520       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 521     if (dlbaton->data[0] == DW_OP_addr)
 522       {
 523         int bytes_read;
 524         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 525                                                 &dlbaton->data[dlbaton->size - 1],
 526                                                 &bytes_read);
 527         fprintf_filtered (stream,
 528                           "a thread-local variable at offset %s in the "
 529                           "thread-local storage for `%s'",
 530                           paddr_nz (offset), dlbaton->objfile->name);
 531         return 1;
 532       }
 533
 534
 535   fprintf_filtered (stream,
 536                     "a variable with complex or multiple locations (DWARF2)");
 537   return 1;
 538 }
 539
 540
 541 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 542    any necessary bytecode in AX.
 543
 544    NOTE drow/2003-02-26: This function is extremely minimal, because
 545    doing it correctly is extremely complicated and there is no
 546    publicly available stub with tracepoint support for me to test
 547    against.  When there is one this function should be revisited.  */
 548
 549 static void
 550 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 551                             struct axs_value * value)
 552 {
 553   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 554
 555   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 556 }
 557
 558 /* The set of location functions used with the DWARF-2 expression
 559    evaluator.  */
 560 const struct symbol_ops dwarf2_locexpr_funcs = {
 561   locexpr_read_variable,
 562   locexpr_read_needs_frame,
 563   locexpr_describe_location,
 564   locexpr_tracepoint_var_ref
 565 };
 566
 567
 568 /* Wrapper functions for location lists.  These generally find
 569    the appropriate location expression and call something above.  */
 570
 571 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 572    evaluator to calculate the location.  */
 573 static struct value *
 574 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 575 {
 576   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 577   struct value *val;
 578   unsigned char *data;
 579   size_t size;
 580
 581   data = find_location_expression (dlbaton, &size,
 582                                    frame ? get_frame_pc (frame) : 0);
 583   if (data == NULL)
 584     {
 585       val = allocate_value (SYMBOL_TYPE (symbol));
 586       VALUE_LVAL (val) = not_lval;
 587       set_value_optimized_out (val, 1);
 588     }
 589   else
 590     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 591                                     dlbaton->objfile);
 592
 593   return val;
 594 }
 595
 596 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 597 static int
 598 loclist_read_needs_frame (struct symbol *symbol)
 599 {
 600   /* If there's a location list, then assume we need to have a frame
 601      to choose the appropriate location expression.  With tracking of
 602      global variables this is not necessarily true, but such tracking
 603      is disabled in GCC at the moment until we figure out how to
 604      represent it.  */
 605
 606   return 1;
 607 }
 608
 609 /* Print a natural-language description of SYMBOL to STREAM.  */
 610 static int
 611 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 612 {
 613   /* FIXME: Could print the entire list of locations.  */
 614   fprintf_filtered (stream, "a variable with multiple locations");
 615   return 1;
 616 }
 617
 618 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 619    any necessary bytecode in AX.  */
 620 static void
 621 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 622                             struct axs_value * value)
 623 {
 624   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 625   unsigned char *data;
 626   size_t size;
 627
 628   data = find_location_expression (dlbaton, &size, ax->scope);
 629   if (data == NULL)
 630     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 631
 632   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 633 }
 634
 635 /* The set of location functions used with the DWARF-2 expression
 636    evaluator and location lists.  */
 637 const struct symbol_ops dwarf2_loclist_funcs = {
 638   loclist_read_variable,
 639   loclist_read_needs_frame,
 640   loclist_describe_location,
 641   loclist_tracepoint_var_ref
 642 };