jdk

1
/*
2
 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#include "precompiled.hpp"
26
#include "code/codeCache.hpp"
27
#include "code/compiledIC.hpp"
28
#include "code/nmethod.hpp"
29
#include "code/relocInfo.hpp"
30
#include "memory/resourceArea.hpp"
31
#include "memory/universe.hpp"
32
#include "oops/compressedOops.inline.hpp"
33
#include "oops/oop.inline.hpp"
34
#include "runtime/flags/flagSetting.hpp"
35
#include "runtime/stubCodeGenerator.hpp"
36
#include "utilities/align.hpp"
37
#include "utilities/checkedCast.hpp"
38
#include "utilities/copy.hpp"
39

40
#include <new>
41
#include <type_traits>
42

43
const RelocationHolder RelocationHolder::none; // its type is relocInfo::none
44

45

46
// Implementation of relocInfo
47

48
#ifdef ASSERT
49
relocInfo::relocType relocInfo::check_relocType(relocType type) {
50
  assert(type != data_prefix_tag, "cannot build a prefix this way");
51
  assert((type & type_mask) == type, "wrong type");
52
  return type;
53
}
54

55
void relocInfo::check_offset_and_format(int offset, int format) {
56
  assert(offset >= 0 && offset < offset_limit(), "offset out off bounds");
57
  assert(is_aligned(offset, offset_unit), "misaligned offset");
58
  assert((format & format_mask) == format, "wrong format");
59
}
60
#endif // ASSERT
61

62
void relocInfo::initialize(CodeSection* dest, Relocation* reloc) {
63
  relocInfo* data = this+1;  // here's where the data might go
64
  dest->set_locs_end(data);  // sync end: the next call may read dest.locs_end
65
  reloc->pack_data_to(dest); // maybe write data into locs, advancing locs_end
66
  relocInfo* data_limit = dest->locs_end();
67
  if (data_limit > data) {
68
    relocInfo suffix = (*this);
69
    data_limit = this->finish_prefix((short*) data_limit);
70
    // Finish up with the suffix.  (Hack note: pack_data_to might edit this.)
71
    *data_limit = suffix;
72
    dest->set_locs_end(data_limit+1);
73
  }
74
}
75

76
relocInfo* relocInfo::finish_prefix(short* prefix_limit) {
77
  assert(sizeof(relocInfo) == sizeof(short), "change this code");
78
  short* p = (short*)(this+1);
79
  assert(prefix_limit >= p, "must be a valid span of data");
80
  int plen = checked_cast<int>(prefix_limit - p);
81
  if (plen == 0) {
82
    debug_only(_value = 0xFFFF);
83
    return this;                         // no data: remove self completely
84
  }
85
  if (plen == 1 && fits_into_immediate(p[0])) {
86
    (*this) = immediate_relocInfo(p[0]); // move data inside self
87
    return this+1;
88
  }
89
  // cannot compact, so just update the count and return the limit pointer
90
  (*this) = prefix_info(plen);       // write new datalen
91
  assert(data() + datalen() == prefix_limit, "pointers must line up");
92
  return (relocInfo*)prefix_limit;
93
}
94

95
void relocInfo::set_type(relocType t) {
96
  int old_offset = addr_offset();
97
  int old_format = format();
98
  (*this) = relocInfo(t, old_offset, old_format);
99
  assert(type()==(int)t, "sanity check");
100
  assert(addr_offset()==old_offset, "sanity check");
101
  assert(format()==old_format, "sanity check");
102
}
103

104
void relocInfo::change_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type, relocType new_type) {
105
  bool found = false;
106
  while (itr->next() && !found) {
107
    if (itr->addr() == pc) {
108
      assert(itr->type()==old_type, "wrong relocInfo type found");
109
      itr->current()->set_type(new_type);
110
      found=true;
111
    }
112
  }
113
  assert(found, "no relocInfo found for pc");
114
}
115

116

117
// ----------------------------------------------------------------------------------------------------
118
// Implementation of RelocIterator
119

120
void RelocIterator::initialize(nmethod* nm, address begin, address limit) {
121
  initialize_misc();
122

123
  if (nm == nullptr && begin != nullptr) {
124
    // allow nmethod to be deduced from beginning address
125
    CodeBlob* cb = CodeCache::find_blob(begin);
126
    nm = (cb != nullptr) ? cb->as_nmethod_or_null() : nullptr;
127
  }
128
  guarantee(nm != nullptr, "must be able to deduce nmethod from other arguments");
129

130
  _code    = nm;
131
  _current = nm->relocation_begin() - 1;
132
  _end     = nm->relocation_end();
133
  _addr    = nm->content_begin();
134

135
  // Initialize code sections.
136
  _section_start[CodeBuffer::SECT_CONSTS] = nm->consts_begin();
137
  _section_start[CodeBuffer::SECT_INSTS ] = nm->insts_begin() ;
138
  _section_start[CodeBuffer::SECT_STUBS ] = nm->stub_begin()  ;
139

140
  _section_end  [CodeBuffer::SECT_CONSTS] = nm->consts_end()  ;
141
  _section_end  [CodeBuffer::SECT_INSTS ] = nm->insts_end()   ;
142
  _section_end  [CodeBuffer::SECT_STUBS ] = nm->stub_end()    ;
143

144
  assert(!has_current(), "just checking");
145
  assert(begin == nullptr || begin >= nm->code_begin(), "in bounds");
146
  assert(limit == nullptr || limit <= nm->code_end(),   "in bounds");
147
  set_limits(begin, limit);
148
}
149

150

151
RelocIterator::RelocIterator(CodeSection* cs, address begin, address limit) {
152
  initialize_misc();
153
  assert(((cs->locs_start() != nullptr) && (cs->locs_end() != nullptr)), "valid start and end pointer");
154
  _current = cs->locs_start()-1;
155
  _end     = cs->locs_end();
156
  _addr    = cs->start();
157
  _code    = nullptr; // Not cb->blob();
158

159
  CodeBuffer* cb = cs->outer();
160
  assert((int) SECT_LIMIT == CodeBuffer::SECT_LIMIT, "my copy must be equal");
161
  for (int n = (int) CodeBuffer::SECT_FIRST; n < (int) CodeBuffer::SECT_LIMIT; n++) {
162
    CodeSection* cs = cb->code_section(n);
163
    _section_start[n] = cs->start();
164
    _section_end  [n] = cs->end();
165
  }
166

167
  assert(!has_current(), "just checking");
168

169
  assert(begin == nullptr || begin >= cs->start(), "in bounds");
170
  assert(limit == nullptr || limit <= cs->end(),   "in bounds");
171
  set_limits(begin, limit);
172
}
173

174
bool RelocIterator::addr_in_const() const {
175
  const int n = CodeBuffer::SECT_CONSTS;
176
  return section_start(n) <= addr() && addr() < section_end(n);
177
}
178

179

180
void RelocIterator::set_limits(address begin, address limit) {
181
  _limit = limit;
182

183
  // the limit affects this next stuff:
184
  if (begin != nullptr) {
185
    relocInfo* backup;
186
    address    backup_addr;
187
    while (true) {
188
      backup      = _current;
189
      backup_addr = _addr;
190
      if (!next() || addr() >= begin) break;
191
    }
192
    // At this point, either we are at the first matching record,
193
    // or else there is no such record, and !has_current().
194
    // In either case, revert to the immediately preceding state.
195
    _current = backup;
196
    _addr    = backup_addr;
197
    set_has_current(false);
198
  }
199
}
200

201

202
// All the strange bit-encodings are in here.
203
// The idea is to encode relocation data which are small integers
204
// very efficiently (a single extra halfword).  Larger chunks of
205
// relocation data need a halfword header to hold their size.
206
void RelocIterator::advance_over_prefix() {
207
  if (_current->is_datalen()) {
208
    _data    = (short*) _current->data();
209
    _datalen =          _current->datalen();
210
    _current += _datalen + 1;   // skip the embedded data & header
211
  } else {
212
    _databuf = _current->immediate();
213
    _data = &_databuf;
214
    _datalen = 1;
215
    _current++;                 // skip the header
216
  }
217
  // The client will see the following relocInfo, whatever that is.
218
  // It is the reloc to which the preceding data applies.
219
}
220

221

222
void RelocIterator::initialize_misc() {
223
  set_has_current(false);
224
  for (int i = (int) CodeBuffer::SECT_FIRST; i < (int) CodeBuffer::SECT_LIMIT; i++) {
225
    _section_start[i] = nullptr;  // these will be lazily computed, if needed
226
    _section_end  [i] = nullptr;
227
  }
228
}
229

230

231
Relocation* RelocIterator::reloc() {
232
  // (take the "switch" out-of-line)
233
  relocInfo::relocType t = type();
234
  if (false) {}
235
  #define EACH_TYPE(name)                             \
236
  else if (t == relocInfo::name##_type) {             \
237
    return name##_reloc();                            \
238
  }
239
  APPLY_TO_RELOCATIONS(EACH_TYPE);
240
  #undef EACH_TYPE
241
  assert(t == relocInfo::none, "must be padding");
242
  _rh = RelocationHolder::none;
243
  return _rh.reloc();
244
}
245

246
// Verify all the destructors are trivial, so we don't need to worry about
247
// destroying old contents of a RelocationHolder being assigned or destroyed.
248
#define VERIFY_TRIVIALLY_DESTRUCTIBLE_AUX(Reloc) \
249
  static_assert(std::is_trivially_destructible<Reloc>::value, "must be");
250

251
#define VERIFY_TRIVIALLY_DESTRUCTIBLE(name) \
252
  VERIFY_TRIVIALLY_DESTRUCTIBLE_AUX(PASTE_TOKENS(name, _Relocation));
253

254
APPLY_TO_RELOCATIONS(VERIFY_TRIVIALLY_DESTRUCTIBLE)
255
VERIFY_TRIVIALLY_DESTRUCTIBLE_AUX(Relocation)
256

257
#undef VERIFY_TRIVIALLY_DESTRUCTIBLE_AUX
258
#undef VERIFY_TRIVIALLY_DESTRUCTIBLE
259

260
// Define all the copy_into functions.  These rely on all Relocation types
261
// being trivially destructible (verified above).  So it doesn't matter
262
// whether the target holder has been previously initialized or not.  There's
263
// no need to consider that distinction and destruct the relocation in an
264
// already initialized holder.
265
#define DEFINE_COPY_INTO_AUX(Reloc)                             \
266
  void Reloc::copy_into(RelocationHolder& holder) const {       \
267
    copy_into_helper(*this, holder);                            \
268
  }
269

270
#define DEFINE_COPY_INTO(name) \
271
  DEFINE_COPY_INTO_AUX(PASTE_TOKENS(name, _Relocation))
272

273
APPLY_TO_RELOCATIONS(DEFINE_COPY_INTO)
274
DEFINE_COPY_INTO_AUX(Relocation)
275

276
#undef DEFINE_COPY_INTO_AUX
277
#undef DEFINE_COPY_INTO
278

279
//////// Methods for flyweight Relocation types
280

281
// some relocations can compute their own values
282
address Relocation::value() {
283
  ShouldNotReachHere();
284
  return nullptr;
285
}
286

287

288
void Relocation::set_value(address x) {
289
  ShouldNotReachHere();
290
}
291

292
void Relocation::const_set_data_value(address x) {
293
#ifdef _LP64
294
  if (format() == relocInfo::narrow_oop_in_const) {
295
    *(narrowOop*)addr() = CompressedOops::encode(cast_to_oop(x));
296
  } else {
297
#endif
298
    *(address*)addr() = x;
299
#ifdef _LP64
300
  }
301
#endif
302
}
303

304
void Relocation::const_verify_data_value(address x) {
305
#ifdef _LP64
306
  if (format() == relocInfo::narrow_oop_in_const) {
307
    guarantee(*(narrowOop*)addr() == CompressedOops::encode(cast_to_oop(x)), "must agree");
308
  } else {
309
#endif
310
    guarantee(*(address*)addr() == x, "must agree");
311
#ifdef _LP64
312
  }
313
#endif
314
}
315

316

317
RelocationHolder Relocation::spec_simple(relocInfo::relocType rtype) {
318
  if (rtype == relocInfo::none)  return RelocationHolder::none;
319
  relocInfo ri = relocInfo(rtype, 0);
320
  RelocIterator itr;
321
  itr.set_current(ri);
322
  itr.reloc();
323
  return itr._rh;
324
}
325

326
address Relocation::old_addr_for(address newa,
327
                                 const CodeBuffer* src, CodeBuffer* dest) {
328
  int sect = dest->section_index_of(newa);
329
  guarantee(sect != CodeBuffer::SECT_NONE, "lost track of this address");
330
  address ostart = src->code_section(sect)->start();
331
  address nstart = dest->code_section(sect)->start();
332
  return ostart + (newa - nstart);
333
}
334

335
address Relocation::new_addr_for(address olda,
336
                                 const CodeBuffer* src, CodeBuffer* dest) {
337
  debug_only(const CodeBuffer* src0 = src);
338
  int sect = CodeBuffer::SECT_NONE;
339
  // Look for olda in the source buffer, and all previous incarnations
340
  // if the source buffer has been expanded.
341
  for (; src != nullptr; src = src->before_expand()) {
342
    sect = src->section_index_of(olda);
343
    if (sect != CodeBuffer::SECT_NONE)  break;
344
  }
345
  guarantee(sect != CodeBuffer::SECT_NONE, "lost track of this address");
346
  address ostart = src->code_section(sect)->start();
347
  address nstart = dest->code_section(sect)->start();
348
  return nstart + (olda - ostart);
349
}
350

351
void Relocation::normalize_address(address& addr, const CodeSection* dest, bool allow_other_sections) {
352
  address addr0 = addr;
353
  if (addr0 == nullptr || dest->allocates2(addr0))  return;
354
  CodeBuffer* cb = dest->outer();
355
  addr = new_addr_for(addr0, cb, cb);
356
  assert(allow_other_sections || dest->contains2(addr),
357
         "addr must be in required section");
358
}
359

360

361
void CallRelocation::set_destination(address x) {
362
  pd_set_call_destination(x);
363
}
364

365
void CallRelocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
366
  // Usually a self-relative reference to an external routine.
367
  // On some platforms, the reference is absolute (not self-relative).
368
  // The enhanced use of pd_call_destination sorts this all out.
369
  address orig_addr = old_addr_for(addr(), src, dest);
370
  address callee    = pd_call_destination(orig_addr);
371
  // Reassert the callee address, this time in the new copy of the code.
372
  pd_set_call_destination(callee);
373
}
374

375

376
#ifdef USE_TRAMPOLINE_STUB_FIX_OWNER
377
void trampoline_stub_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
378
  // Finalize owner destination only for nmethods
379
  if (dest->blob() != nullptr) return;
380
  pd_fix_owner_after_move();
381
}
382
#endif
383

384
//// pack/unpack methods
385

386
void oop_Relocation::pack_data_to(CodeSection* dest) {
387
  short* p = (short*) dest->locs_end();
388
  p = pack_1_int_to(p, _oop_index);
389
  dest->set_locs_end((relocInfo*) p);
390
}
391

392

393
void oop_Relocation::unpack_data() {
394
  _oop_index = unpack_1_int();
395
}
396

397
void metadata_Relocation::pack_data_to(CodeSection* dest) {
398
  short* p = (short*) dest->locs_end();
399
  p = pack_1_int_to(p, _metadata_index);
400
  dest->set_locs_end((relocInfo*) p);
401
}
402

403

404
void metadata_Relocation::unpack_data() {
405
  _metadata_index = unpack_1_int();
406
}
407

408

409
void virtual_call_Relocation::pack_data_to(CodeSection* dest) {
410
  short*  p     = (short*) dest->locs_end();
411
  address point =          dest->locs_point();
412

413
  normalize_address(_cached_value, dest);
414
  jint x0 = scaled_offset_null_special(_cached_value, point);
415
  p = pack_2_ints_to(p, x0, _method_index);
416
  dest->set_locs_end((relocInfo*) p);
417
}
418

419

420
void virtual_call_Relocation::unpack_data() {
421
  jint x0 = 0;
422
  unpack_2_ints(x0, _method_index);
423
  address point = addr();
424
  _cached_value = x0==0? nullptr: address_from_scaled_offset(x0, point);
425
}
426

427
void runtime_call_w_cp_Relocation::pack_data_to(CodeSection * dest) {
428
  short* p = pack_1_int_to((short *)dest->locs_end(), (jint)(_offset >> 2));
429
  dest->set_locs_end((relocInfo*) p);
430
}
431

432
void runtime_call_w_cp_Relocation::unpack_data() {
433
  _offset = unpack_1_int() << 2;
434
}
435

436
void static_stub_Relocation::pack_data_to(CodeSection* dest) {
437
  short* p = (short*) dest->locs_end();
438
  CodeSection* insts = dest->outer()->insts();
439
  normalize_address(_static_call, insts);
440
  p = pack_1_int_to(p, scaled_offset(_static_call, insts->start()));
441
  dest->set_locs_end((relocInfo*) p);
442
}
443

444
void static_stub_Relocation::unpack_data() {
445
  address base = binding()->section_start(CodeBuffer::SECT_INSTS);
446
  jint offset = unpack_1_int();
447
  _static_call = address_from_scaled_offset(offset, base);
448
}
449

450
void trampoline_stub_Relocation::pack_data_to(CodeSection* dest ) {
451
  short* p = (short*) dest->locs_end();
452
  CodeSection* insts = dest->outer()->insts();
453
  normalize_address(_owner, insts);
454
  p = pack_1_int_to(p, scaled_offset(_owner, insts->start()));
455
  dest->set_locs_end((relocInfo*) p);
456
}
457

458
void trampoline_stub_Relocation::unpack_data() {
459
  address base = binding()->section_start(CodeBuffer::SECT_INSTS);
460
  _owner = address_from_scaled_offset(unpack_1_int(), base);
461
}
462

463
void external_word_Relocation::pack_data_to(CodeSection* dest) {
464
  short* p = (short*) dest->locs_end();
465
  int index = ExternalsRecorder::find_index(_target);
466
  p = pack_1_int_to(p, index);
467
  dest->set_locs_end((relocInfo*) p);
468
}
469

470

471
void external_word_Relocation::unpack_data() {
472
  int index = unpack_1_int();
473
  _target = ExternalsRecorder::at(index);
474
}
475

476

477
void internal_word_Relocation::pack_data_to(CodeSection* dest) {
478
  short* p = (short*) dest->locs_end();
479
  normalize_address(_target, dest, true);
480

481
  // Check whether my target address is valid within this section.
482
  // If not, strengthen the relocation type to point to another section.
483
  int sindex = _section;
484
  if (sindex == CodeBuffer::SECT_NONE && _target != nullptr
485
      && (!dest->allocates(_target) || _target == dest->locs_point())) {
486
    sindex = dest->outer()->section_index_of(_target);
487
    guarantee(sindex != CodeBuffer::SECT_NONE, "must belong somewhere");
488
    relocInfo* base = dest->locs_end() - 1;
489
    assert(base->type() == this->type(), "sanity");
490
    // Change the written type, to be section_word_type instead.
491
    base->set_type(relocInfo::section_word_type);
492
  }
493

494
  // Note: An internal_word relocation cannot refer to its own instruction,
495
  // because we reserve "0" to mean that the pointer itself is embedded
496
  // in the code stream.  We use a section_word relocation for such cases.
497

498
  if (sindex == CodeBuffer::SECT_NONE) {
499
    assert(type() == relocInfo::internal_word_type, "must be base class");
500
    guarantee(_target == nullptr || dest->allocates2(_target), "must be within the given code section");
501
    jint x0 = scaled_offset_null_special(_target, dest->locs_point());
502
    assert(!(x0 == 0 && _target != nullptr), "correct encoding of null target");
503
    p = pack_1_int_to(p, x0);
504
  } else {
505
    assert(_target != nullptr, "sanity");
506
    CodeSection* sect = dest->outer()->code_section(sindex);
507
    guarantee(sect->allocates2(_target), "must be in correct section");
508
    address base = sect->start();
509
    jint offset = scaled_offset(_target, base);
510
    assert((uint)sindex < (uint)CodeBuffer::SECT_LIMIT, "sanity");
511
    assert(CodeBuffer::SECT_LIMIT <= (1 << section_width), "section_width++");
512
    p = pack_1_int_to(p, (offset << section_width) | sindex);
513
  }
514

515
  dest->set_locs_end((relocInfo*) p);
516
}
517

518

519
void internal_word_Relocation::unpack_data() {
520
  jint x0 = unpack_1_int();
521
  _target = x0==0? nullptr: address_from_scaled_offset(x0, addr());
522
  _section = CodeBuffer::SECT_NONE;
523
}
524

525

526
void section_word_Relocation::unpack_data() {
527
  jint    x      = unpack_1_int();
528
  jint    offset = (x >> section_width);
529
  int     sindex = (x & ((1<<section_width)-1));
530
  address base   = binding()->section_start(sindex);
531

532
  _section = sindex;
533
  _target  = address_from_scaled_offset(offset, base);
534
}
535

536
//// miscellaneous methods
537
oop* oop_Relocation::oop_addr() {
538
  int n = _oop_index;
539
  if (n == 0) {
540
    // oop is stored in the code stream
541
    return (oop*) pd_address_in_code();
542
  } else {
543
    // oop is stored in table at nmethod::oops_begin
544
    return code()->oop_addr_at(n);
545
  }
546
}
547

548

549
oop oop_Relocation::oop_value() {
550
  // clean inline caches store a special pseudo-null
551
  if (Universe::contains_non_oop_word(oop_addr())) {
552
    return nullptr;
553
  }
554
  return *oop_addr();
555
}
556

557

558
void oop_Relocation::fix_oop_relocation() {
559
  if (!oop_is_immediate()) {
560
    // get the oop from the pool, and re-insert it into the instruction:
561
    set_value(value());
562
  }
563
}
564

565

566
void oop_Relocation::verify_oop_relocation() {
567
  if (!oop_is_immediate()) {
568
    // get the oop from the pool, and re-insert it into the instruction:
569
    verify_value(value());
570
  }
571
}
572

573
// meta data versions
574
Metadata** metadata_Relocation::metadata_addr() {
575
  int n = _metadata_index;
576
  if (n == 0) {
577
    // metadata is stored in the code stream
578
    return (Metadata**) pd_address_in_code();
579
    } else {
580
    // metadata is stored in table at nmethod::metadatas_begin
581
    return code()->metadata_addr_at(n);
582
    }
583
  }
584

585

586
Metadata* metadata_Relocation::metadata_value() {
587
  Metadata* v = *metadata_addr();
588
  // clean inline caches store a special pseudo-null
589
  if (v == (Metadata*)Universe::non_oop_word())  v = nullptr;
590
  return v;
591
  }
592

593

594
void metadata_Relocation::fix_metadata_relocation() {
595
  if (!metadata_is_immediate()) {
596
    // get the metadata from the pool, and re-insert it into the instruction:
597
    pd_fix_value(value());
598
  }
599
}
600

601
address virtual_call_Relocation::cached_value() {
602
  assert(_cached_value != nullptr && _cached_value < addr(), "must precede ic_call");
603
  return _cached_value;
604
}
605

606
Method* virtual_call_Relocation::method_value() {
607
  nmethod* nm = code();
608
  if (nm == nullptr) return (Method*)nullptr;
609
  Metadata* m = nm->metadata_at(_method_index);
610
  assert(m != nullptr || _method_index == 0, "should be non-null for non-zero index");
611
  assert(m == nullptr || m->is_method(), "not a method");
612
  return (Method*)m;
613
}
614

615
void virtual_call_Relocation::clear_inline_cache() {
616
  ResourceMark rm;
617
  CompiledIC* icache = CompiledIC_at(this);
618
  icache->set_to_clean();
619
}
620

621

622
void opt_virtual_call_Relocation::pack_data_to(CodeSection* dest) {
623
  short* p = (short*) dest->locs_end();
624
  p = pack_1_int_to(p, _method_index);
625
  dest->set_locs_end((relocInfo*) p);
626
}
627

628
void opt_virtual_call_Relocation::unpack_data() {
629
  _method_index = unpack_1_int();
630
}
631

632
Method* opt_virtual_call_Relocation::method_value() {
633
  nmethod* nm = code();
634
  if (nm == nullptr) return (Method*)nullptr;
635
  Metadata* m = nm->metadata_at(_method_index);
636
  assert(m != nullptr || _method_index == 0, "should be non-null for non-zero index");
637
  assert(m == nullptr || m->is_method(), "not a method");
638
  return (Method*)m;
639
}
640

641
void opt_virtual_call_Relocation::clear_inline_cache() {
642
  ResourceMark rm;
643
  CompiledDirectCall* callsite = CompiledDirectCall::at(this);
644
  callsite->set_to_clean();
645
}
646

647
address opt_virtual_call_Relocation::static_stub() {
648
  // search for the static stub who points back to this static call
649
  address static_call_addr = addr();
650
  RelocIterator iter(code());
651
  while (iter.next()) {
652
    if (iter.type() == relocInfo::static_stub_type) {
653
      static_stub_Relocation* stub_reloc = iter.static_stub_reloc();
654
      if (stub_reloc->static_call() == static_call_addr) {
655
        return iter.addr();
656
      }
657
    }
658
  }
659
  return nullptr;
660
}
661

662
Method* static_call_Relocation::method_value() {
663
  nmethod* nm = code();
664
  if (nm == nullptr) return (Method*)nullptr;
665
  Metadata* m = nm->metadata_at(_method_index);
666
  assert(m != nullptr || _method_index == 0, "should be non-null for non-zero index");
667
  assert(m == nullptr || m->is_method(), "not a method");
668
  return (Method*)m;
669
}
670

671
void static_call_Relocation::pack_data_to(CodeSection* dest) {
672
  short* p = (short*) dest->locs_end();
673
  p = pack_1_int_to(p, _method_index);
674
  dest->set_locs_end((relocInfo*) p);
675
}
676

677
void static_call_Relocation::unpack_data() {
678
  _method_index = unpack_1_int();
679
}
680

681
void static_call_Relocation::clear_inline_cache() {
682
  ResourceMark rm;
683
  CompiledDirectCall* callsite = CompiledDirectCall::at(this);
684
  callsite->set_to_clean();
685
}
686

687

688
address static_call_Relocation::static_stub() {
689
  // search for the static stub who points back to this static call
690
  address static_call_addr = addr();
691
  RelocIterator iter(code());
692
  while (iter.next()) {
693
    if (iter.type() == relocInfo::static_stub_type) {
694
      static_stub_Relocation* stub_reloc = iter.static_stub_reloc();
695
      if (stub_reloc->static_call() == static_call_addr) {
696
        return iter.addr();
697
      }
698
    }
699
  }
700
  return nullptr;
701
}
702

703
// Finds the trampoline address for a call. If no trampoline stub is
704
// found nullptr is returned which can be handled by the caller.
705
address trampoline_stub_Relocation::get_trampoline_for(address call, nmethod* code) {
706
  // There are no relocations available when the code gets relocated
707
  // because of CodeBuffer expansion.
708
  if (code->relocation_size() == 0)
709
    return nullptr;
710

711
  RelocIterator iter(code, call);
712
  while (iter.next()) {
713
    if (iter.type() == relocInfo::trampoline_stub_type) {
714
      if (iter.trampoline_stub_reloc()->owner() == call) {
715
        return iter.addr();
716
      }
717
    }
718
  }
719

720
  return nullptr;
721
}
722

723
void static_stub_Relocation::clear_inline_cache() {
724
  // Call stub is only used when calling the interpreted code.
725
  // It does not really need to be cleared, except that we want to clean out the methodoop.
726
  CompiledDirectCall::set_stub_to_clean(this);
727
}
728

729

730
void external_word_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
731
  if (_target != nullptr) {
732
    // Probably this reference is absolute,  not relative, so the following is
733
    // probably a no-op.
734
    set_value(_target);
735
  }
736
  // If target is nullptr, this is  an absolute embedded reference to an external
737
  // location, which means  there is nothing to fix here.  In either case, the
738
  // resulting target should be an "external" address.
739
  postcond(src->section_index_of(target()) == CodeBuffer::SECT_NONE);
740
  postcond(dest->section_index_of(target()) == CodeBuffer::SECT_NONE);
741
}
742

743

744
address external_word_Relocation::target() {
745
  address target = _target;
746
  if (target == nullptr) {
747
    target = pd_get_address_from_code();
748
  }
749
  return target;
750
}
751

752

753
void internal_word_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
754
  address target = _target;
755
  if (target == nullptr) {
756
    target = new_addr_for(this->target(), src, dest);
757
  }
758
  set_value(target);
759
}
760

761

762
address internal_word_Relocation::target() {
763
  address target = _target;
764
  if (target == nullptr) {
765
    if (addr_in_const()) {
766
      target = *(address*)addr();
767
    } else {
768
      target = pd_get_address_from_code();
769
    }
770
  }
771
  return target;
772
}
773

774
//---------------------------------------------------------------------------------
775
// Non-product code
776

777
#ifndef PRODUCT
778

779
static const char* reloc_type_string(relocInfo::relocType t) {
780
  switch (t) {
781
  #define EACH_CASE(name) \
782
  case relocInfo::name##_type: \
783
    return #name;
784

785
  APPLY_TO_RELOCATIONS(EACH_CASE);
786
  #undef EACH_CASE
787

788
  case relocInfo::none:
789
    return "none";
790
  case relocInfo::data_prefix_tag:
791
    return "prefix";
792
  default:
793
    return "UNKNOWN RELOC TYPE";
794
  }
795
}
796

797

798
void RelocIterator::print_current() {
799
  if (!has_current()) {
800
    tty->print_cr("(no relocs)");
801
    return;
802
  }
803
  tty->print("relocInfo@" INTPTR_FORMAT " [type=%d(%s) addr=" INTPTR_FORMAT " offset=%d",
804
             p2i(_current), type(), reloc_type_string((relocInfo::relocType) type()), p2i(_addr), _current->addr_offset());
805
  if (current()->format() != 0)
806
    tty->print(" format=%d", current()->format());
807
  if (datalen() == 1) {
808
    tty->print(" data=%d", data()[0]);
809
  } else if (datalen() > 0) {
810
    tty->print(" data={");
811
    for (int i = 0; i < datalen(); i++) {
812
      tty->print("%04x", data()[i] & 0xFFFF);
813
    }
814
    tty->print("}");
815
  }
816
  tty->print("]");
817
  switch (type()) {
818
  case relocInfo::oop_type:
819
    {
820
      oop_Relocation* r = oop_reloc();
821
      oop* oop_addr  = nullptr;
822
      oop  raw_oop   = nullptr;
823
      oop  oop_value = nullptr;
824
      if (code() != nullptr || r->oop_is_immediate()) {
825
        oop_addr  = r->oop_addr();
826
        raw_oop   = *oop_addr;
827
        oop_value = r->oop_value();
828
      }
829
      tty->print(" | [oop_addr=" INTPTR_FORMAT " *=" INTPTR_FORMAT "]",
830
                 p2i(oop_addr), p2i(raw_oop));
831
      // Do not print the oop by default--we want this routine to
832
      // work even during GC or other inconvenient times.
833
      if (WizardMode && oop_value != nullptr) {
834
        tty->print("oop_value=" INTPTR_FORMAT ": ", p2i(oop_value));
835
        if (oopDesc::is_oop(oop_value)) {
836
          oop_value->print_value_on(tty);
837
        }
838
      }
839
      break;
840
    }
841
  case relocInfo::metadata_type:
842
    {
843
      metadata_Relocation* r = metadata_reloc();
844
      Metadata** metadata_addr  = nullptr;
845
      Metadata*    raw_metadata   = nullptr;
846
      Metadata*    metadata_value = nullptr;
847
      if (code() != nullptr || r->metadata_is_immediate()) {
848
        metadata_addr  = r->metadata_addr();
849
        raw_metadata   = *metadata_addr;
850
        metadata_value = r->metadata_value();
851
      }
852
      tty->print(" | [metadata_addr=" INTPTR_FORMAT " *=" INTPTR_FORMAT "]",
853
                 p2i(metadata_addr), p2i(raw_metadata));
854
      if (metadata_value != nullptr) {
855
        tty->print("metadata_value=" INTPTR_FORMAT ": ", p2i(metadata_value));
856
        metadata_value->print_value_on(tty);
857
      }
858
      break;
859
    }
860
  case relocInfo::external_word_type:
861
  case relocInfo::internal_word_type:
862
  case relocInfo::section_word_type:
863
    {
864
      DataRelocation* r = (DataRelocation*) reloc();
865
      tty->print(" | [target=" INTPTR_FORMAT "]", p2i(r->value())); //value==target
866
      break;
867
    }
868
  case relocInfo::static_call_type:
869
    {
870
      static_call_Relocation* r = (static_call_Relocation*) reloc();
871
      tty->print(" | [destination=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
872
                 p2i(r->destination()), p2i(r->method_value()));
873
      break;
874
    }
875
  case relocInfo::runtime_call_type:
876
  case relocInfo::runtime_call_w_cp_type:
877
    {
878
      CallRelocation* r = (CallRelocation*) reloc();
879
      tty->print(" | [destination=" INTPTR_FORMAT "]", p2i(r->destination()));
880
      break;
881
    }
882
  case relocInfo::virtual_call_type:
883
    {
884
      virtual_call_Relocation* r = (virtual_call_Relocation*) reloc();
885
      tty->print(" | [destination=" INTPTR_FORMAT " cached_value=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
886
                 p2i(r->destination()), p2i(r->cached_value()), p2i(r->method_value()));
887
      break;
888
    }
889
  case relocInfo::static_stub_type:
890
    {
891
      static_stub_Relocation* r = (static_stub_Relocation*) reloc();
892
      tty->print(" | [static_call=" INTPTR_FORMAT "]", p2i(r->static_call()));
893
      break;
894
    }
895
  case relocInfo::trampoline_stub_type:
896
    {
897
      trampoline_stub_Relocation* r = (trampoline_stub_Relocation*) reloc();
898
      tty->print(" | [trampoline owner=" INTPTR_FORMAT "]", p2i(r->owner()));
899
      break;
900
    }
901
  case relocInfo::opt_virtual_call_type:
902
    {
903
      opt_virtual_call_Relocation* r = (opt_virtual_call_Relocation*) reloc();
904
      tty->print(" | [destination=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
905
                 p2i(r->destination()), p2i(r->method_value()));
906
      break;
907
    }
908
  default:
909
    break;
910
  }
911
  tty->cr();
912
}
913

914

915
void RelocIterator::print() {
916
  RelocIterator save_this = (*this);
917
  relocInfo* scan = _current;
918
  if (!has_current())  scan += 1;  // nothing to scan here!
919

920
  bool skip_next = has_current();
921
  bool got_next;
922
  while (true) {
923
    got_next = (skip_next || next());
924
    skip_next = false;
925

926
    tty->print("         @" INTPTR_FORMAT ": ", p2i(scan));
927
    relocInfo* newscan = _current+1;
928
    if (!has_current())  newscan -= 1;  // nothing to scan here!
929
    while (scan < newscan) {
930
      tty->print("%04x", *(short*)scan & 0xFFFF);
931
      scan++;
932
    }
933
    tty->cr();
934

935
    if (!got_next)  break;
936
    print_current();
937
  }
938

939
  (*this) = save_this;
940
}
941

942
// For the debugger:
943
extern "C"
944
void print_blob_locs(nmethod* nm) {
945
  nm->print();
946
  RelocIterator iter(nm);
947
  iter.print();
948
}
949
extern "C"
950
void print_buf_locs(CodeBuffer* cb) {
951
  FlagSetting fs(PrintRelocations, true);
952
  cb->print();
953
}
954
#endif // !PRODUCT
955