js/src/jit/Safepoints.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "jit/Safepoints.h"
   8
   9 #include "mozilla/MathAlgorithms.h"
  10
  11 #include "jit/BitSet.h"
  12 #include "jit/IonScript.h"
  13 #include "jit/JitSpewer.h"
  14 #include "jit/LIR.h"
  15 #include "jit/SafepointIndex.h"
  16
  17 using namespace js;
  18 using namespace jit;
  19
  20 using mozilla::FloorLog2;
  21
  22 SafepointWriter::SafepointWriter(uint32_t localSlotsSize,
  23                                  uint32_t argumentsSize)
  24     : localSlots_((localSlotsSize / sizeof(intptr_t)) +
  25                   1),  // Stack slot counts are inclusive.
  26       argumentSlots_(argumentsSize / sizeof(intptr_t)) {}
  27
  28 bool SafepointWriter::init(TempAllocator& alloc) {
  29   return localSlots_.init(alloc) && argumentSlots_.init(alloc);
  30 }
  31
  32 uint32_t SafepointWriter::startEntry() {
  33   JitSpew(JitSpew_Safepoints,
  34           "Encoding safepoint (position %zu):", stream_.length());
  35   return uint32_t(stream_.length());
  36 }
  37
  38 void SafepointWriter::writeOsiCallPointOffset(uint32_t osiCallPointOffset) {
  39   stream_.writeUnsigned(osiCallPointOffset);
  40 }
  41
  42 static void WriteRegisterMask(CompactBufferWriter& stream,
  43                               PackedRegisterMask bits) {
  44   if (sizeof(PackedRegisterMask) == 1) {
  45     stream.writeByte(bits);
  46   } else {
  47     MOZ_ASSERT(sizeof(PackedRegisterMask) <= 4);
  48     stream.writeUnsigned(bits);
  49   }
  50 }
  51
  52 static PackedRegisterMask ReadRegisterMask(CompactBufferReader& stream) {
  53   if (sizeof(PackedRegisterMask) == 1) {
  54     return stream.readByte();
  55   }
  56   MOZ_ASSERT(sizeof(PackedRegisterMask) <= 4);
  57   return stream.readUnsigned();
  58 }
  59
  60 static void WriteFloatRegisterMask(CompactBufferWriter& stream,
  61                                    FloatRegisters::SetType bits) {
  62   switch (sizeof(FloatRegisters::SetType)) {
  63 #ifdef JS_CODEGEN_ARM64
  64     case 16:
  65       stream.writeUnsigned64(bits.low());
  66       stream.writeUnsigned64(bits.high());
  67       break;
  68 #else
  69     case 1:
  70       stream.writeByte(bits);
  71       break;
  72     case 4:
  73       stream.writeUnsigned(bits);
  74       break;
  75     case 8:
  76       stream.writeUnsigned64(bits);
  77       break;
  78 #endif
  79     default:
  80       MOZ_CRASH("WriteFloatRegisterMask: unexpected size");
  81   }
  82 }
  83
  84 static FloatRegisters::SetType ReadFloatRegisterMask(
  85     CompactBufferReader& stream) {
  86   switch (sizeof(FloatRegisters::SetType)) {
  87 #ifdef JS_CODEGEN_ARM64
  88     case 16: {
  89       uint64_t low = stream.readUnsigned64();
  90       uint64_t high = stream.readUnsigned64();
  91       return Bitset128(high, low);
  92     }
  93 #else
  94     case 1:
  95       return stream.readByte();
  96     case 2:
  97     case 3:
  98     case 4:
  99       return stream.readUnsigned();
 100     case 8:
 101       return stream.readUnsigned64();
 102 #endif
 103     default:
 104       MOZ_CRASH("ReadFloatRegisterMask: unexpected size");
 105   }
 106 }
 107
 108 void SafepointWriter::writeGcRegs(LSafepoint* safepoint) {
 109   LiveGeneralRegisterSet gc(safepoint->gcRegs());
 110   LiveGeneralRegisterSet spilledGpr(safepoint->liveRegs().gprs());
 111   LiveFloatRegisterSet spilledFloat(safepoint->liveRegs().fpus());
 112   LiveGeneralRegisterSet slots(safepoint->slotsOrElementsRegs());
 113   LiveGeneralRegisterSet wasmAnyRef(safepoint->wasmAnyRefRegs());
 114   LiveGeneralRegisterSet valueRegs;
 115
 116   WriteRegisterMask(stream_, spilledGpr.bits());
 117   if (!spilledGpr.empty()) {
 118     WriteRegisterMask(stream_, gc.bits());
 119     WriteRegisterMask(stream_, slots.bits());
 120     WriteRegisterMask(stream_, wasmAnyRef.bits());
 121
 122 #ifdef JS_PUNBOX64
 123     valueRegs = safepoint->valueRegs();
 124     WriteRegisterMask(stream_, valueRegs.bits());
 125 #endif
 126   }
 127
 128   // GC registers are a subset of the spilled registers.
 129   MOZ_ASSERT((valueRegs.bits() & ~spilledGpr.bits()) == 0);
 130   MOZ_ASSERT((gc.bits() & ~spilledGpr.bits()) == 0);
 131
 132   WriteFloatRegisterMask(stream_, spilledFloat.bits());
 133
 134 #ifdef JS_JITSPEW
 135   if (JitSpewEnabled(JitSpew_Safepoints)) {
 136     for (GeneralRegisterForwardIterator iter(spilledGpr); iter.more(); ++iter) {
 137       const char* type = gc.has(*iter)          ? "gc"
 138                          : slots.has(*iter)     ? "slots"
 139                          : valueRegs.has(*iter) ? "value"
 140                                                 : "any";
 141       JitSpew(JitSpew_Safepoints, "    %s reg: %s", type, (*iter).name());
 142     }
 143     for (FloatRegisterForwardIterator iter(spilledFloat); iter.more(); ++iter) {
 144       JitSpew(JitSpew_Safepoints, "    float reg: %s", (*iter).name());
 145     }
 146   }
 147 #endif
 148 }
 149
 150 static void WriteBitset(const BitSet& set, CompactBufferWriter& stream) {
 151   size_t count = set.rawLength();
 152   const uint32_t* words = set.raw();
 153   for (size_t i = 0; i < count; i++) {
 154     stream.writeUnsigned(words[i]);
 155   }
 156 }
 157
 158 static void MapSlotsToBitset(BitSet& stackSet, BitSet& argumentSet,
 159                              CompactBufferWriter& stream,
 160                              const LSafepoint::SlotList& slots) {
 161   stackSet.clear();
 162   argumentSet.clear();
 163
 164   for (uint32_t i = 0; i < slots.length(); i++) {
 165     // Slots are represented at a distance from |fp|. We divide by the
 166     // pointer size, since we only care about pointer-sized/aligned slots
 167     // here.
 168     MOZ_ASSERT(slots[i].slot % sizeof(intptr_t) == 0);
 169     size_t index = slots[i].slot / sizeof(intptr_t);
 170     (slots[i].stack ? stackSet : argumentSet).insert(index);
 171   }
 172
 173   WriteBitset(stackSet, stream);
 174   WriteBitset(argumentSet, stream);
 175 }
 176
 177 void SafepointWriter::writeGcSlots(LSafepoint* safepoint) {
 178   LSafepoint::SlotList& slots = safepoint->gcSlots();
 179
 180 #ifdef JS_JITSPEW
 181   for (uint32_t i = 0; i < slots.length(); i++) {
 182     JitSpew(JitSpew_Safepoints, "    gc slot: %u", slots[i].slot);
 183   }
 184 #endif
 185
 186   MapSlotsToBitset(localSlots_, argumentSlots_, stream_, slots);
 187 }
 188
 189 void SafepointWriter::writeSlotsOrElementsSlots(LSafepoint* safepoint) {
 190   LSafepoint::SlotList& slots = safepoint->slotsOrElementsSlots();
 191
 192   stream_.writeUnsigned(slots.length());
 193
 194   for (uint32_t i = 0; i < slots.length(); i++) {
 195     if (!slots[i].stack) {
 196       MOZ_CRASH();
 197     }
 198 #ifdef JS_JITSPEW
 199     JitSpew(JitSpew_Safepoints, "    slots/elements slot: %u", slots[i].slot);
 200 #endif
 201     stream_.writeUnsigned(slots[i].slot);
 202   }
 203 }
 204
 205 void SafepointWriter::writeWasmAnyRefSlots(LSafepoint* safepoint) {
 206   LSafepoint::SlotList& slots = safepoint->wasmAnyRefSlots();
 207
 208   stream_.writeUnsigned(slots.length());
 209
 210   for (uint32_t i = 0; i < slots.length(); i++) {
 211     if (!slots[i].stack) {
 212       MOZ_CRASH();
 213     }
 214 #ifdef JS_JITSPEW
 215     JitSpew(JitSpew_Safepoints, "    wasm_anyref slot: %u", slots[i].slot);
 216 #endif
 217     stream_.writeUnsigned(slots[i].slot);
 218   }
 219 }
 220
 221 #ifdef JS_PUNBOX64
 222 void SafepointWriter::writeValueSlots(LSafepoint* safepoint) {
 223   LSafepoint::SlotList& slots = safepoint->valueSlots();
 224
 225 #  ifdef JS_JITSPEW
 226   for (uint32_t i = 0; i < slots.length(); i++) {
 227     JitSpew(JitSpew_Safepoints, "    gc value: %u", slots[i].slot);
 228   }
 229 #  endif
 230
 231   MapSlotsToBitset(localSlots_, argumentSlots_, stream_, slots);
 232 }
 233 #endif
 234
 235 #if defined(JS_JITSPEW) && defined(JS_NUNBOX32)
 236 static void DumpNunboxPart(const LAllocation& a) {
 237   Fprinter& out = JitSpewPrinter();
 238   if (a.isStackSlot()) {
 239     out.printf("stack %d", a.toStackSlot()->slot());
 240   } else if (a.isArgument()) {
 241     out.printf("arg %d", a.toArgument()->index());
 242   } else {
 243     out.printf("reg %s", a.toGeneralReg()->reg().name());
 244   }
 245 }
 246 #endif  // DEBUG
 247
 248 // Nunbox part encoding:
 249 //
 250 // Reg = 000
 251 // Stack = 001
 252 // Arg = 010
 253 //
 254 // [vwu] nentries:
 255 //    uint16_t:  tttp ppXX XXXY YYYY
 256 //
 257 //     If ttt = Reg, type is reg XXXXX
 258 //     If ppp = Reg, payload is reg YYYYY
 259 //
 260 //     If ttt != Reg, type is:
 261 //          XXXXX if not 11111, otherwise followed by [vwu]
 262 //     If ppp != Reg, payload is:
 263 //          YYYYY if not 11111, otherwise followed by [vwu]
 264 //
 265 enum NunboxPartKind { Part_Reg, Part_Stack, Part_Arg };
 266
 267 static const uint32_t PART_KIND_BITS = 3;
 268 static const uint32_t PART_KIND_MASK = (1 << PART_KIND_BITS) - 1;
 269 static const uint32_t PART_INFO_BITS = 5;
 270 static const uint32_t PART_INFO_MASK = (1 << PART_INFO_BITS) - 1;
 271
 272 static const uint32_t MAX_INFO_VALUE = (1 << PART_INFO_BITS) - 1;
 273 static const uint32_t TYPE_KIND_SHIFT = 16 - PART_KIND_BITS;
 274 static const uint32_t PAYLOAD_KIND_SHIFT = TYPE_KIND_SHIFT - PART_KIND_BITS;
 275 static const uint32_t TYPE_INFO_SHIFT = PAYLOAD_KIND_SHIFT - PART_INFO_BITS;
 276 static const uint32_t PAYLOAD_INFO_SHIFT = TYPE_INFO_SHIFT - PART_INFO_BITS;
 277
 278 static_assert(PAYLOAD_INFO_SHIFT == 0);
 279
 280 #ifdef JS_NUNBOX32
 281 static inline NunboxPartKind AllocationToPartKind(const LAllocation& a) {
 282   if (a.isRegister()) {
 283     return Part_Reg;
 284   }
 285   if (a.isStackSlot()) {
 286     return Part_Stack;
 287   }
 288   MOZ_ASSERT(a.isArgument());
 289   return Part_Arg;
 290 }
 291
 292 // gcc 4.5 doesn't actually inline CanEncodeInfoInHeader when only
 293 // using the "inline" keyword, and miscompiles the function as well
 294 // when doing block reordering with branch prediction information.
 295 // See bug 799295 comment 71.
 296 static MOZ_ALWAYS_INLINE bool CanEncodeInfoInHeader(const LAllocation& a,
 297                                                     uint32_t* out) {
 298   if (a.isGeneralReg()) {
 299     *out = a.toGeneralReg()->reg().code();
 300     return true;
 301   }
 302
 303   if (a.isStackSlot()) {
 304     *out = a.toStackSlot()->slot();
 305   } else {
 306     *out = a.toArgument()->index();
 307   }
 308
 309   return *out < MAX_INFO_VALUE;
 310 }
 311
 312 void SafepointWriter::writeNunboxParts(LSafepoint* safepoint) {
 313   LSafepoint::NunboxList& entries = safepoint->nunboxParts();
 314
 315 #  ifdef JS_JITSPEW
 316   if (JitSpewEnabled(JitSpew_Safepoints)) {
 317     for (uint32_t i = 0; i < entries.length(); i++) {
 318       SafepointNunboxEntry& entry = entries[i];
 319       if (entry.type.isUse() || entry.payload.isUse()) {
 320         continue;
 321       }
 322       JitSpewHeader(JitSpew_Safepoints);
 323       Fprinter& out = JitSpewPrinter();
 324       out.printf("    nunbox (type in ");
 325       DumpNunboxPart(entry.type);
 326       out.printf(", payload in ");
 327       DumpNunboxPart(entry.payload);
 328       out.printf(")\n");
 329     }
 330   }
 331 #  endif
 332
 333   // Safepoints are permitted to have partially filled in entries for nunboxes,
 334   // provided that only the type is live and not the payload. Omit these from
 335   // the written safepoint.
 336
 337   size_t pos = stream_.length();
 338   stream_.writeUnsigned(entries.length());
 339
 340   size_t count = 0;
 341   for (size_t i = 0; i < entries.length(); i++) {
 342     SafepointNunboxEntry& entry = entries[i];
 343
 344     if (entry.payload.isUse()) {
 345       // No allocation associated with the payload.
 346       continue;
 347     }
 348
 349     if (entry.type.isUse()) {
 350       // No allocation associated with the type. Look for another
 351       // safepoint entry with an allocation for the type.
 352       entry.type = safepoint->findTypeAllocation(entry.typeVreg);
 353       if (entry.type.isUse()) {
 354         continue;
 355       }
 356     }
 357
 358     count++;
 359
 360     uint16_t header = 0;
 361
 362     header |= (AllocationToPartKind(entry.type) << TYPE_KIND_SHIFT);
 363     header |= (AllocationToPartKind(entry.payload) << PAYLOAD_KIND_SHIFT);
 364
 365     uint32_t typeVal;
 366     bool typeExtra = !CanEncodeInfoInHeader(entry.type, &typeVal);
 367     if (!typeExtra) {
 368       header |= (typeVal << TYPE_INFO_SHIFT);
 369     } else {
 370       header |= (MAX_INFO_VALUE << TYPE_INFO_SHIFT);
 371     }
 372
 373     uint32_t payloadVal;
 374     bool payloadExtra = !CanEncodeInfoInHeader(entry.payload, &payloadVal);
 375     if (!payloadExtra) {
 376       header |= (payloadVal << PAYLOAD_INFO_SHIFT);
 377     } else {
 378       header |= (MAX_INFO_VALUE << PAYLOAD_INFO_SHIFT);
 379     }
 380
 381     stream_.writeFixedUint16_t(header);
 382     if (typeExtra) {
 383       stream_.writeUnsigned(typeVal);
 384     }
 385     if (payloadExtra) {
 386       stream_.writeUnsigned(payloadVal);
 387     }
 388   }
 389
 390   // Update the stream with the actual number of safepoint entries written.
 391   stream_.writeUnsignedAt(pos, count, entries.length());
 392 }
 393 #endif
 394
 395 void SafepointWriter::encode(LSafepoint* safepoint) {
 396   uint32_t safepointOffset = startEntry();
 397
 398   MOZ_ASSERT(safepoint->osiCallPointOffset());
 399
 400   writeOsiCallPointOffset(safepoint->osiCallPointOffset());
 401   writeGcRegs(safepoint);
 402   writeGcSlots(safepoint);
 403
 404 #ifdef JS_PUNBOX64
 405   writeValueSlots(safepoint);
 406 #else
 407   writeNunboxParts(safepoint);
 408 #endif
 409
 410   writeSlotsOrElementsSlots(safepoint);
 411   writeWasmAnyRefSlots(safepoint);
 412
 413   endEntry();
 414   safepoint->setOffset(safepointOffset);
 415 }
 416
 417 void SafepointWriter::endEntry() {
 418   JitSpew(JitSpew_Safepoints, "    -- entry ended at %u",
 419           uint32_t(stream_.length()));
 420 }
 421
 422 SafepointReader::SafepointReader(IonScript* script, const SafepointIndex* si)
 423     : stream_(script->safepoints() + si->safepointOffset(),
 424               script->safepoints() + script->safepointsSize()),
 425       localSlots_((script->localSlotsSize() / sizeof(intptr_t)) +
 426                   1),  // Stack slot counts are inclusive.
 427       argumentSlots_(script->argumentSlotsSize() / sizeof(intptr_t)),
 428       nunboxSlotsRemaining_(0),
 429       slotsOrElementsSlotsRemaining_(0),
 430       wasmAnyRefSlotsRemaining_(0) {
 431   osiCallPointOffset_ = stream_.readUnsigned();
 432
 433   // gcSpills is a subset of allGprSpills.
 434   allGprSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
 435   if (allGprSpills_.empty()) {
 436     gcSpills_ = allGprSpills_;
 437     valueSpills_ = allGprSpills_;
 438     slotsOrElementsSpills_ = allGprSpills_;
 439     wasmAnyRefSpills_ = allGprSpills_;
 440   } else {
 441     gcSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
 442     slotsOrElementsSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
 443     wasmAnyRefSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
 444 #ifdef JS_PUNBOX64
 445     valueSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
 446 #endif
 447   }
 448
 449   allFloatSpills_ = FloatRegisterSet(ReadFloatRegisterMask(stream_));
 450
 451   advanceFromGcRegs();
 452 }
 453
 454 uint32_t SafepointReader::osiReturnPointOffset() const {
 455   return osiCallPointOffset_ + Assembler::PatchWrite_NearCallSize();
 456 }
 457
 458 CodeLocationLabel SafepointReader::InvalidationPatchPoint(
 459     IonScript* script, const SafepointIndex* si) {
 460   SafepointReader reader(script, si);
 461
 462   return CodeLocationLabel(script->method(),
 463                            CodeOffset(reader.osiCallPointOffset()));
 464 }
 465
 466 void SafepointReader::advanceFromGcRegs() {
 467   currentSlotChunk_ = 0;
 468   nextSlotChunkNumber_ = 0;
 469   currentSlotsAreStack_ = true;
 470 }
 471
 472 bool SafepointReader::getSlotFromBitmap(SafepointSlotEntry* entry) {
 473   while (currentSlotChunk_ == 0) {
 474     // Are there any more chunks to read?
 475     if (currentSlotsAreStack_) {
 476       if (nextSlotChunkNumber_ == BitSet::RawLengthForBits(localSlots_)) {
 477         nextSlotChunkNumber_ = 0;
 478         currentSlotsAreStack_ = false;
 479         continue;
 480       }
 481     } else if (nextSlotChunkNumber_ ==
 482                BitSet::RawLengthForBits(argumentSlots_)) {
 483       return false;
 484     }
 485
 486     // Yes, read the next chunk.
 487     currentSlotChunk_ = stream_.readUnsigned();
 488     nextSlotChunkNumber_++;
 489   }
 490
 491   // The current chunk still has bits in it, so get the next bit, then mask
 492   // it out of the slot chunk.
 493   uint32_t bit = FloorLog2(currentSlotChunk_);
 494   currentSlotChunk_ &= ~(1 << bit);
 495
 496   // Return the slot, and re-scale it by the pointer size, reversing the
 497   // transformation in MapSlotsToBitset.
 498   entry->stack = currentSlotsAreStack_;
 499   entry->slot = (((nextSlotChunkNumber_ - 1) * BitSet::BitsPerWord) + bit) *
 500                 sizeof(intptr_t);
 501   return true;
 502 }
 503
 504 bool SafepointReader::getGcSlot(SafepointSlotEntry* entry) {
 505   if (getSlotFromBitmap(entry)) {
 506     return true;
 507   }
 508   advanceFromGcSlots();
 509   return false;
 510 }
 511
 512 void SafepointReader::advanceFromGcSlots() {
 513   // No, reset the counter.
 514   currentSlotChunk_ = 0;
 515   nextSlotChunkNumber_ = 0;
 516   currentSlotsAreStack_ = true;
 517 #ifdef JS_NUNBOX32
 518   // Nunbox slots are next.
 519   nunboxSlotsRemaining_ = stream_.readUnsigned();
 520 #else
 521   // Value slots are next.
 522 #endif
 523 }
 524
 525 bool SafepointReader::getValueSlot(SafepointSlotEntry* entry) {
 526   if (getSlotFromBitmap(entry)) {
 527     return true;
 528   }
 529   advanceFromNunboxOrValueSlots();
 530   return false;
 531 }
 532
 533 static inline LAllocation PartFromStream(CompactBufferReader& stream,
 534                                          NunboxPartKind kind, uint32_t info) {
 535   if (kind == Part_Reg) {
 536     return LGeneralReg(Register::FromCode(info));
 537   }
 538
 539   if (info == MAX_INFO_VALUE) {
 540     info = stream.readUnsigned();
 541   }
 542
 543   if (kind == Part_Stack) {
 544     return LStackSlot(info);
 545   }
 546
 547   MOZ_ASSERT(kind == Part_Arg);
 548   return LArgument(info);
 549 }
 550
 551 bool SafepointReader::getNunboxSlot(LAllocation* type, LAllocation* payload) {
 552   if (!nunboxSlotsRemaining_--) {
 553     advanceFromNunboxOrValueSlots();
 554     return false;
 555   }
 556
 557   uint16_t header = stream_.readFixedUint16_t();
 558   NunboxPartKind typeKind =
 559       (NunboxPartKind)((header >> TYPE_KIND_SHIFT) & PART_KIND_MASK);
 560   NunboxPartKind payloadKind =
 561       (NunboxPartKind)((header >> PAYLOAD_KIND_SHIFT) & PART_KIND_MASK);
 562   uint32_t typeInfo = (header >> TYPE_INFO_SHIFT) & PART_INFO_MASK;
 563   uint32_t payloadInfo = (header >> PAYLOAD_INFO_SHIFT) & PART_INFO_MASK;
 564
 565   *type = PartFromStream(stream_, typeKind, typeInfo);
 566   *payload = PartFromStream(stream_, payloadKind, payloadInfo);
 567   return true;
 568 }
 569
 570 void SafepointReader::advanceFromNunboxOrValueSlots() {
 571   slotsOrElementsSlotsRemaining_ = stream_.readUnsigned();
 572 }
 573
 574 bool SafepointReader::getSlotsOrElementsSlot(SafepointSlotEntry* entry) {
 575   if (!slotsOrElementsSlotsRemaining_--) {
 576     advanceFromSlotsOrElementsSlots();
 577     return false;
 578   }
 579   entry->stack = true;
 580   entry->slot = stream_.readUnsigned();
 581   return true;
 582 }
 583
 584 void SafepointReader::advanceFromSlotsOrElementsSlots() {
 585   wasmAnyRefSlotsRemaining_ = stream_.readUnsigned();
 586 }
 587
 588 bool SafepointReader::getWasmAnyRefSlot(SafepointSlotEntry* entry) {
 589   if (!wasmAnyRefSlotsRemaining_--) {
 590     return false;
 591   }
 592   entry->stack = true;
 593   entry->slot = stream_.readUnsigned();
 594   return true;
 595 }