void ciMethodData::print_data_on(outputStream* st) { ResourceMark rm; ciProfileData* data; for (data = first_data(); is_valid(data); data = next_data(data)) { st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } st->print_cr("--- Extra data:"); DataLayout* dp = data_layout_at(data_size()); DataLayout* end = data_layout_at(data_size() + extra_data_size()); for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { if (dp->tag() == DataLayout::no_tag) continue; if (dp->tag() == DataLayout::bit_data_tag) { data = new BitData(dp); } else { assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo"); data = new ciArgInfoData(dp); dp = end; // ArgInfoData is at the end of extra data section. } st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } }
// Translate a bci to its corresponding data, or NULL. ciProfileData* ciMethodData::bci_to_data(int bci) { ciProfileData* data = data_before(bci); for ( ; is_valid(data); data = next_data(data)) { if (data->bci() == bci) { set_hint_di(dp_to_di(data->dp())); return data; } else if (data->bci() > bci) { break; } } // bci_to_extra_data(bci) ... DataLayout* dp = data_layout_at(data_size()); DataLayout* end = data_layout_at(data_size() + extra_data_size()); for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { if (dp->tag() == DataLayout::no_tag) { _saw_free_extra_data = true; // observed an empty slot (common case) return NULL; } if (dp->tag() == DataLayout::arg_info_data_tag) { break; // ArgInfoData is at the end of extra data section. } if (dp->bci() == bci) { assert(dp->tag() == DataLayout::bit_data_tag, "sane"); return new ciBitData(dp); } } return NULL; }
// Translate a bci to its corresponding data, or NULL. ciProfileData* ciMethodData::bci_to_data(int bci, ciMethod* m) { // If m is not NULL we look for a SpeculativeTrapData entry if (m == NULL) { ciProfileData* data = data_before(bci); for ( ; is_valid(data); data = next_data(data)) { if (data->bci() == bci) { set_hint_di(dp_to_di(data->dp())); return data; } else if (data->bci() > bci) { break; } } } bool two_free_slots = false; ciProfileData* result = bci_to_extra_data(bci, m, two_free_slots); if (result != NULL) { return result; } if (m != NULL && !two_free_slots) { // We were looking for a SpeculativeTrapData entry we didn't // find. Room is not available for more SpeculativeTrapData // entries, look in the non SpeculativeTrapData entries. return bci_to_data(bci, NULL); } return NULL; }
void process_data( const char *data, size_t length ) { if( length > 0 ) { std::string next_data(data, data + length); const size_t old_size = queue_->messages( ).size( ); /// revert data block revertor_->transform( next_data ); /** * message = transformed(<size>data) * we must revert data here **/ //queue_->append( &next_data[0], next_data.size( )); queue_->append( next_data.empty( ) ? NULL : &next_data[0], next_data.size( ) ); queue_->process( ); if( queue_->messages( ).size( ) > old_size ) { parent_->on_data_ready( ); } } }
void methodDataOopDesc::print_data_on(outputStream* st) { ResourceMark rm; ProfileData* data = first_data(); for ( ; is_valid(data); data = next_data(data)) { st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } st->print_cr("--- Extra data:"); DataLayout* dp = extra_data_base(); DataLayout* end = extra_data_limit(); for (; dp < end; dp = next_extra(dp)) { // No need for "OrderAccess::load_acquire" ops, // since the data structure is monotonic. if (dp->tag() == DataLayout::no_tag) continue; if (dp->tag() == DataLayout::bit_data_tag) { data = new BitData(dp); } else { assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo"); data = new ArgInfoData(dp); dp = end; // ArgInfoData is at the end of extra data section. } st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } }
void ciMethodData::print_data_on(outputStream* st) { ResourceMark rm; ciProfileData* data; for (data = first_data(); is_valid(data); data = next_data(data)) { st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } }
// Give each of the data entries a chance to perform specific // data initialization. void methodDataOopDesc::post_initialize(BytecodeStream* stream) { ResourceMark rm; ProfileData* data; for (data = first_data(); is_valid(data); data = next_data(data)) { stream->set_start(data->bci()); stream->next(); data->post_initialize(stream, this); } }
void ciMethodData::load_data() { MethodData* mdo = get_MethodData(); if (mdo == NULL) { return; } // To do: don't copy the data if it is not "ripe" -- require a minimum # // of invocations. // Snapshot the data -- actually, take an approximate snapshot of // the data. Any concurrently executing threads may be changing the // data as we copy it. Copy::disjoint_words((HeapWord*) mdo, (HeapWord*) &_orig, sizeof(_orig) / HeapWordSize); Arena* arena = CURRENT_ENV->arena(); _data_size = mdo->data_size(); _extra_data_size = mdo->extra_data_size(); int total_size = _data_size + _extra_data_size; _data = (intptr_t *) arena->Amalloc(total_size); Copy::disjoint_words((HeapWord*) mdo->data_base(), (HeapWord*) _data, total_size / HeapWordSize); // Traverse the profile data, translating any oops into their // ci equivalents. ResourceMark rm; ciProfileData* ci_data = first_data(); ProfileData* data = mdo->first_data(); while (is_valid(ci_data)) { ci_data->translate_from(data); ci_data = next_data(ci_data); data = mdo->next_data(data); } if (mdo->parameters_type_data() != NULL) { _parameters = data_layout_at(mdo->parameters_type_data_di()); ciParametersTypeData* parameters = new ciParametersTypeData(_parameters); parameters->translate_from(mdo->parameters_type_data()); } load_extra_data(); // Note: Extra data are all BitData, and do not need translation. _current_mileage = MethodData::mileage_of(mdo->method()); _invocation_counter = mdo->invocation_count(); _backedge_counter = mdo->backedge_count(); _state = mdo->is_mature()? mature_state: immature_state; _eflags = mdo->eflags(); _arg_local = mdo->arg_local(); _arg_stack = mdo->arg_stack(); _arg_returned = mdo->arg_returned(); #ifndef PRODUCT if (ReplayCompiles) { ciReplay::initialize(this); } #endif }
// Translate a bci to its corresponding data, or NULL. ProfileData* methodDataOopDesc::bci_to_data(int bci) { ProfileData* data = data_before(bci); for ( ; is_valid(data); data = next_data(data)) { if (data->bci() == bci) { set_hint_di(dp_to_di(data->dp())); return data; } else if (data->bci() > bci) { break; } } return bci_to_extra_data(bci, false); }
// Translate a bci to its corresponding data index (di). address methodDataOopDesc::bci_to_dp(int bci) { ResourceMark rm; ProfileData* data = data_before(bci); ProfileData* prev = NULL; for ( ; is_valid(data); data = next_data(data)) { if (data->bci() >= bci) { if (data->bci() == bci) set_hint_di(dp_to_di(data->dp())); else if (prev != NULL) set_hint_di(dp_to_di(prev->dp())); return data->dp(); } prev = data; } return (address)limit_data_position(); }
void ciMethodData::load_data() { methodDataOop mdo = get_methodDataOop(); if (mdo == NULL) return; // To do: don't copy the data if it is not "ripe" -- require a minimum # // of invocations. // Snapshot the data -- actually, take an approximate snapshot of // the data. Any concurrently executing threads may be changing the // data as we copy it. int skip_header = oopDesc::header_size(); Copy::disjoint_words((HeapWord*) mdo + skip_header, (HeapWord*) &_orig + skip_header, sizeof(_orig) / HeapWordSize - skip_header); DEBUG_ONLY(*_orig.adr_method() = NULL); // no dangling oops, please Arena* arena = CURRENT_ENV->arena(); _data_size = mdo->data_size(); _extra_data_size = mdo->extra_data_size(); int total_size = _data_size + _extra_data_size; _data = (intptr_t *) arena->Amalloc(total_size); Copy::disjoint_words((HeapWord*) mdo->data_base(), (HeapWord*) _data, total_size / HeapWordSize); // Traverse the profile data, translating any oops into their // ci equivalents. ResourceMark rm; ciProfileData* ci_data = first_data(); ProfileData* data = mdo->first_data(); while (is_valid(ci_data)) { ci_data->translate_from(data); ci_data = next_data(ci_data); data = mdo->next_data(data); } // Note: Extra data are all BitData, and do not need translation. _current_mileage = methodDataOopDesc::mileage_of(mdo->method()); _state = mdo->is_mature()? mature_state: immature_state; _eflags = mdo->eflags(); _arg_local = mdo->arg_local(); _arg_stack = mdo->arg_stack(); _arg_returned = mdo->arg_returned(); }
void ciMethodData::print_data_on(outputStream* st) { ResourceMark rm; ciParametersTypeData* parameters = parameters_type_data(); if (parameters != NULL) { parameters->print_data_on(st); } ciProfileData* data; for (data = first_data(); is_valid(data); data = next_data(data)) { st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } st->print_cr("--- Extra data:"); DataLayout* dp = extra_data_base(); DataLayout* end = args_data_limit(); for (;; dp = MethodData::next_extra(dp)) { assert(dp < end, "moved past end of extra data"); switch (dp->tag()) { case DataLayout::no_tag: continue; case DataLayout::bit_data_tag: data = new BitData(dp); break; case DataLayout::arg_info_data_tag: data = new ciArgInfoData(dp); dp = end; // ArgInfoData is at the end of extra data section. break; case DataLayout::speculative_trap_data_tag: data = new ciSpeculativeTrapData(dp); break; default: fatal(err_msg("unexpected tag %d", dp->tag())); } st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); if (dp >= end) return; } }
void methodDataOopDesc::print_data_on(outputStream* st) { ResourceMark rm; ProfileData* data = first_data(); for ( ; is_valid(data); data = next_data(data)) { st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } DataLayout* dp = extra_data_base(); DataLayout* end = extra_data_limit(); for (; dp < end; dp = next_extra(dp)) { // No need for "OrderAccess::load_acquire" ops, // since the data structure is monotonic. if (dp->tag() == DataLayout::no_tag) break; if (dp == extra_data_base()) st->print_cr("--- Extra data:"); data = new BitData(dp); st->print("%d", dp_to_di(data->dp())); st->fill_to(6); data->print_data_on(st); } }
int next_imps(unsigned short *impbuf, int buflen, long timelen) { static int toput; static int bitrem; static dbyte dirpulse; unsigned short *impbufend, *impbufstart; impbufstart = impbuf; impbufend = impbuf + buflen; while(impbuf < impbufend - 1 && timelen > 0) { switch(playstate) { case PL_PAUSE: if(currlev && lead_pause) { PULSE(IMP_1MS); lead_pause --; } else if(lead_pause > 10) { if(tapeopt.blanknoise && !(rb->rand() % 64)) DPULSE(IMP_1MS * 10 - 1000, 1000); else DPULSE(IMP_1MS * 10, 0); lead_pause -= 10; } else if(lead_pause) { DPULSE(IMP_1MS, 0); lead_pause --; } else { if(tf_cseg.num || tf_cseg.sync1p || tf_cseg.sync2p || tf_cseg.ptr != tf_cseg.len) finished = 0; switch (tf_cseg.type) { case ST_NORM: playstate = PL_LEADER; break; case ST_DIRE: playstate = PL_DIRE; dirpulse = 0; break; case ST_PSEQ: playstate = PL_PSEQ; break; default: playstate = PL_NONE; } } break; case PL_LEADER: if(tf_cseg.num >= 2) { DPULSE(tf_cseg.pulse, tf_cseg.pulse); tf_cseg.num -= 2; } else if(tf_cseg.num) { PULSE(tf_cseg.pulse); tf_cseg.num --; } else { /* PL_SYNC */ if(tf_cseg.sync1p || tf_cseg.sync2p) DPULSE(tf_cseg.sync1p, tf_cseg.sync2p); bitrem = 0; playstate = PL_DATA; } break; case PL_DATA: if(!bitrem) { toput = next_data(); if(toput < 0) { playstate = PL_END; break; } if(tf_cseg.ptr != tf_cseg.len) { if(timelen > 16 * max(tf_cseg.onep, tf_cseg.zerop) && impbuf <= impbufend - 16) { int p1, p2, br, tp; p1 = tf_cseg.onep; p2 = tf_cseg.zerop; br = 8; tp = toput; while(br) { if(tp & 0x80) DPULSE(p1, p1); else DPULSE(p2, p2); br--; tp <<= 1; } bitrem = 0; break; } bitrem = 8; } else { bitrem = tf_cseg.bused; if(!bitrem) break; } } if(toput & 0x80) DPULSE(tf_cseg.onep, tf_cseg.onep); else DPULSE(tf_cseg.zerop, tf_cseg.zerop); bitrem--, toput <<= 1; break; case PL_PSEQ: { int b1, b2; dbyte pulse1, pulse2; b1 = next_data(); b2 = next_data(); if(b1 < 0 || b2 < 0) { playstate = PL_END; break; } pulse1 = b1 + (b2 << 8); b1 = next_data(); b2 = next_data(); if(b1 < 0 || b2 < 0) { PULSE(pulse1); playstate = PL_END; break; } pulse2 = b1 + (b2 << 8); DPULSE(pulse1, pulse2); } break; case PL_DIRE: for(;;) { if(!bitrem) { toput = next_data(); if(toput < 0) { playstate = PL_END; DPULSE(dirpulse, 0); break; } if(tf_cseg.ptr != tf_cseg.len) bitrem = 8; else { bitrem = tf_cseg.bused; if(!bitrem) break; } } bitrem--; toput <<= 1; if(((toput & 0x0100) ^ (currlev ? 0x0100 : 0x00))) { PULSE(dirpulse); dirpulse = tf_cseg.pulse; break; } dirpulse += tf_cseg.pulse; if(dirpulse >= 0x8000) { DPULSE(dirpulse, 0); dirpulse = 0; break; } } break; case PL_END: if(tf_cseg.pause) { PULSE(IMP_1MS); tf_cseg.pause--; if(currlev) PULSE(0); finished = 1; } playstate = PL_NONE; break; case PL_NONE: default: return PTRDIFF(impbuf, impbufstart); } } return PTRDIFF(impbuf, impbufstart); }
int next_byte(void) { playstate = PL_NONE; return next_data(); }
static int interpret_tzx_header(byte *hb, struct seginfo *csp) { int res; int segid; byte *hip; int offs; dbyte dtmp; segid = hb[0]; hip = hb+1; switch(segid) { case 0x10: normal_segment(csp); csp->pause = DBYTE(hip, 0x00); break; case 0x11: rb->snprintf(seg_desc,DESC_LEN, "Turbo Data"); csp->type = ST_NORM; csp->segtype = SEG_DATA_TURBO; csp->pulse = DBYTE(hip, 0x00); csp->sync1p = DBYTE(hip, 0x02); csp->sync2p = DBYTE(hip, 0x04); csp->zerop = DBYTE(hip, 0x06); csp->onep = DBYTE(hip, 0x08); csp->num = DBYTE(hip, 0x0A); csp->bused = BYTE(hip, 0x0C); csp->pause = DBYTE(hip, 0x0D); break; case 0x12: rb->snprintf(seg_desc,DESC_LEN, "Pure Tone"); csp->type = ST_NORM; csp->segtype = SEG_OTHER; csp->pulse = DBYTE(hip, 0x00); csp->num = DBYTE(hip, 0x02); csp->sync1p = 0; csp->sync2p = 0; csp->zerop = 0; csp->onep = 0; csp->bused = 0; csp->pause = 0; break; case 0x13: rb->snprintf(seg_desc,DESC_LEN, "Pulse Sequence"); csp->type = ST_PSEQ; csp->segtype = SEG_OTHER; csp->pause = 0; break; case 0x14: rb->snprintf(seg_desc,DESC_LEN, "Pure Data"); csp->type = ST_NORM; csp->segtype = SEG_DATA_PURE; csp->zerop = DBYTE(hip, 0x00); csp->onep = DBYTE(hip, 0x02); csp->bused = BYTE(hip, 0x04); csp->pause = DBYTE(hip, 0x05); csp->pulse = 0; csp->num = 0; csp->sync1p = 0; csp->sync2p = 0; break; case 0x15: rb->snprintf(seg_desc,DESC_LEN, "Direct Recording"); csp->type = ST_DIRE; csp->segtype = SEG_OTHER; csp->pulse = DBYTE(hip, 0x00); csp->pause = DBYTE(hip, 0x02); csp->bused = BYTE(hip, 0x04); break; case 0x20: dtmp = DBYTE(hip, 0x00); if(dtmp == 0) { if(!tapeopt.stoppause) { csp->type = ST_MISC; csp->segtype = SEG_STOP; } else { csp->pause = tapeopt.stoppause * 1000; csp->type = ST_NORM; csp->segtype = SEG_PAUSE; } rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape Mark"); } else { csp->pause = dtmp; csp->type = ST_NORM; csp->segtype = SEG_PAUSE; rb->snprintf(seg_desc,DESC_LEN, "Pause for %i.%03is", csp->pause / 1000, csp->pause % 1000); } csp->pulse = 0; csp->num = 0; csp->sync1p = 0; csp->sync2p = 0; csp->zerop = 0; csp->onep = 0; csp->bused = 0; break; case 0x21: csp->type = ST_MISC; csp->segtype = SEG_GRP_BEG; res = readbuf(rbuf, csp->len, tapefd); if(res != (int) csp->len) { premature(csp); return 0; } csp->ptr += csp->len; { int blen; rb->snprintf(seg_desc,DESC_LEN, "Begin Group: "); blen = (int) rb->strlen(seg_desc); rb->strlcpy(seg_desc+blen, (char *) rbuf, (unsigned) csp->len + 1); } break; case 0x22: rb->snprintf(seg_desc,DESC_LEN, "End Group"); csp->type = ST_MISC; csp->segtype = SEG_GRP_END; break; case 0x23: offs = (signed short) DBYTE(hip, 0x00); if(offs == 0) { rb->snprintf(seg_desc,DESC_LEN, "Infinite loop"); csp->type = ST_MISC; csp->segtype = SEG_STOP; } else { csp->type = ST_MISC; csp->segtype = SEG_SKIP; rb->snprintf(seg_desc,DESC_LEN, "Jump to %i", segi+offs); jump_to_segment(segi + offs, csp); } break; case 0x24: loopctr = DBYTE(hip, 0x00); rb->snprintf(seg_desc,DESC_LEN, "Loop %i times", loopctr); loopbeg = segi+1; csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x25: csp->type = ST_MISC; csp->segtype = SEG_SKIP; if(loopctr) loopctr--; if(loopctr) { jump_to_segment(loopbeg, csp); rb->snprintf(seg_desc,DESC_LEN, "Loop to: %i", loopbeg); } else rb->snprintf(seg_desc,DESC_LEN, "Loop End"); break; case 0x26: csp->type = ST_MISC; csp->segtype = SEG_SKIP; dtmp = DBYTE(hip, 0x00); if(callctr < dtmp) { int offset; callbeg = segi; /*fseek(tapefp, callctr*2, SEEK_CUR);*/ rb->lseek(tapefd, callctr*2, SEEK_CUR); csp->ptr += callctr*2; res = readbuf(rbuf, 2, tapefd); if(res != 2) { premature(csp); return 0; } csp->ptr += 2; offset = (signed short) DBYTE(rbuf, 0x00); rb->snprintf(seg_desc,DESC_LEN, "Call to %i", segi+offset); jump_to_segment(segi+offset, csp); callctr++; } else { callctr = 0; rb->snprintf(seg_desc,DESC_LEN, "Call Sequence End"); } break; case 0x27: csp->type = ST_MISC; csp->segtype = SEG_SKIP; rb->snprintf(seg_desc,DESC_LEN, "Return"); if(callctr > 0) jump_to_segment(callbeg, csp); break; case 0x28: rb->snprintf(seg_desc,DESC_LEN, "Selection (Not yet supported)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x2A: if(tapeopt.machine == MACHINE_48) { rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape in 48k Mode (Stopped)"); csp->type = ST_MISC; csp->segtype = SEG_STOP; } else { rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape in 48k Mode (Not Stopped)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; } break; case 0x31: case 0x30: csp->type = ST_MISC; csp->segtype = SEG_SKIP; res = readbuf(rbuf, csp->len, tapefd); if(res != (int) csp->len) { premature(csp); return 0; } csp->ptr += csp->len; rb->strlcpy(seg_desc, (char *) rbuf, (unsigned) csp->len + 1); break; case 0x32: csp->type = ST_MISC; csp->segtype = SEG_SKIP; { int numstr, i; i = 0; numstr = next_data(); for(;numstr > 0; numstr--) { int tlen, tid, b; tid = next_data(); tlen = next_data(); if(tid < 0 || tlen < 0) return 0; for(; tlen; tlen--) { b = next_data(); if(b < 0) return 0; seg_desc[i++] = b; } seg_desc[i++] = '\n'; } seg_desc[i] = '\0'; } break; case 0x33: rb->snprintf(seg_desc,DESC_LEN, "Hardware Information (Not yet supported)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x34: rb->snprintf(seg_desc, DESC_LEN,"Emulation Information (Not yet supported)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x35: rb->snprintf(seg_desc,DESC_LEN, "Custom Information (Not yet supported)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x40: rb->snprintf(seg_desc, DESC_LEN,"Snapshot (Not yet supported)"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; break; case 0x5A: rb->snprintf(seg_desc, DESC_LEN,"Tapefile Concatenation Point"); csp->type = ST_MISC; csp->segtype = SEG_SKIP; default: csp->type = ST_MISC; csp->segtype = SEG_SKIP; rb->snprintf(seg_desc,DESC_LEN, "Unknown TZX block (id: %02X, version: %i.%02i)", segid, tf_tpi.tzxmajver, tf_tpi.tzxminver); break; } return 1; }
static void xact_out(usb_addr_t addr, usb_endp_t endpoint, uint8_t *data, uint16_t len) { send_token(PID_OUT, addr, endpoint); send_data(next_data(), data, len); recv_handshake(); }
/* "mutate" function for struct mc_class. */ static void sparse_xarray_mc_mutate (struct mc *mc, const void *ots_) { struct test_params *params = mc_get_aux (mc); size_t n_columns = params->n_columns; const struct test_state *ots = ots_; struct test_model otm; int i; test_model_extract (params, ots, &otm); for (i = 0; i < params->n_xarrays; i++) { unsigned char value; int row, col, n, src, dst; /* Write all possible values to each possible single cell. */ if (params->write_cells) for (row = 0; row < params->max_rows; row++) for (col = 0; col < n_columns; col++) for (value = 0; value < params->n_values; value++) if (mc_include_state (mc)) { struct test_state *ts = test_state_clone (params, ots); struct sparse_xarray *sx = ts->xarrays[i]; struct test_model tm = otm; struct xarray_model *model = &tm.models[i]; mc_name_operation (mc, "xarray %d: set (%d,%d) to %d", i, row, col, value); if (!sparse_xarray_write (sx, row, col, 1, &value)) NOT_REACHED (); model->data[row][col] = value; model->contains_row[row] = true; check_state (mc, ts, &tm); } /* Write all possible row contents to each row. */ if (params->write_rows) for (row = 0; row < params->max_rows; row++) { struct test_model tm = otm; struct xarray_model *model = &tm.models[i]; memset (model->data[row], 0, n_columns); model->contains_row[row] = true; do { if (mc_include_state (mc)) { struct test_state *ts = test_state_clone (params, ots); struct sparse_xarray *sx = ts->xarrays[i]; char row_string[MAX_COLS + 1]; mc_name_operation (mc, "xarray %d: set row %d to %s", i, row, row_string); for (col = 0; col < n_columns; col++) { value = model->data[row][col]; row_string[col] = value < 10 ? '0' + value : '*'; } row_string[n_columns] = '\0'; if (!sparse_xarray_write (sx, row, 0, n_columns, model->data[row])) NOT_REACHED (); check_state (mc, ts, &tm); } } while (next_data (model->data[row], n_columns, params->n_values)); } /* Write all possible values to each possible column. */ if (params->write_columns) for (col = 0; col < n_columns; col++) for (value = 0; value < params->n_values; value++) if (mc_include_state (mc)) { struct test_state *ts = test_state_clone (params, ots); struct sparse_xarray *sx = ts->xarrays[i]; struct test_model tm = otm; struct xarray_model *model = &tm.models[i]; mc_name_operation (mc, "xarray %d: write value %d to " "column %d", i, value, col); if (!sparse_xarray_write_columns (sx, col, 1, &value)) NOT_REACHED (); for (row = 0; row < params->max_rows; row++) model->data[row][col] = value; check_state (mc, ts, &tm); } /* Copy all possible column ranges within a single sparse_xarray. */ if (params->copy_within_xarray) for (n = 1; n <= n_columns; n++) for (src = 0; src <= n_columns - n; src++) for (dst = 0; dst <= n_columns - n; dst++) if (mc_include_state (mc)) { struct copy_columns_params copy_aux; struct test_state *ts = test_state_clone (params, ots); struct sparse_xarray *sx = ts->xarrays[i]; struct test_model tm = otm; struct xarray_model *model = &tm.models[i]; mc_name_operation (mc, "xarray %d: copy %d columns from " "offset %d to offset %d", i, n, src, dst); copy_aux.n = n; copy_aux.src = src; copy_aux.dst = dst; if (!sparse_xarray_copy (sx, sx, copy_columns, ©_aux)) NOT_REACHED (); for (row = 0; row < params->max_rows; row++) memmove (&model->data[row][dst], &model->data[row][src], n); check_state (mc, ts, &tm); } } if (params->n_xarrays == 2) { int row, n, src, dst; /* Copy all possible column ranges from xarrays[0] to xarrays[1]. */ for (n = 1; n <= n_columns; n++) for (src = 0; src <= n_columns - n; src++) for (dst = 0; dst <= n_columns - n; dst++) if (mc_include_state (mc)) { struct copy_columns_params copy_aux; struct test_state *ts = test_state_clone (params, ots); struct test_model tm = otm; mc_name_operation (mc, "copy %d columns from offset %d in " "xarray 0 to offset %d in xarray 1", n, src, dst); copy_aux.n = n; copy_aux.src = src; copy_aux.dst = dst; if (!sparse_xarray_copy (ts->xarrays[0], ts->xarrays[1], copy_columns, ©_aux)) NOT_REACHED (); for (row = 0; row < params->max_rows; row++) { if (tm.models[0].contains_row[row]) tm.models[1].contains_row[row] = true; memmove (&tm.models[1].data[row][dst], &tm.models[0].data[row][src], n); } check_state (mc, ts, &tm); } } }
void ciMethodData::dump_replay_data(outputStream* out) { ResourceMark rm; MethodData* mdo = get_MethodData(); Method* method = mdo->method(); Klass* holder = method->method_holder(); out->print("ciMethodData %s %s %s %d %d", holder->name()->as_quoted_ascii(), method->name()->as_quoted_ascii(), method->signature()->as_quoted_ascii(), _state, current_mileage()); // dump the contents of the MDO header as raw data unsigned char* orig = (unsigned char*)&_orig; int length = sizeof(_orig); out->print(" orig %d", length); for (int i = 0; i < length; i++) { out->print(" %d", orig[i]); } // dump the MDO data as raw data int elements = (data_size() + extra_data_size()) / sizeof(intptr_t); out->print(" data %d", elements); for (int i = 0; i < elements; i++) { // We could use INTPTR_FORMAT here but that's a zero justified // which makes comparing it with the SA version of this output // harder. #ifdef _LP64 out->print(" 0x%" FORMAT64_MODIFIER "x", data()[i]); #else out->print(" 0x%x", data()[i]); #endif } // The MDO contained oop references as ciObjects, so scan for those // and emit pairs of offset and klass name so that they can be // reconstructed at runtime. The first round counts the number of // oop references and the second actually emits them. ciParametersTypeData* parameters = parameters_type_data(); for (int count = 0, round = 0; round < 2; round++) { if (round == 1) out->print(" oops %d", count); ProfileData* pdata = first_data(); for ( ; is_valid(pdata); pdata = next_data(pdata)) { if (pdata->is_VirtualCallData()) { ciVirtualCallData* vdata = (ciVirtualCallData*)pdata; dump_replay_data_receiver_type_helper<ciVirtualCallData>(out, round, count, vdata); if (pdata->is_VirtualCallTypeData()) { ciVirtualCallTypeData* call_type_data = (ciVirtualCallTypeData*)pdata; dump_replay_data_call_type_helper<ciVirtualCallTypeData>(out, round, count, call_type_data); } } else if (pdata->is_ReceiverTypeData()) { ciReceiverTypeData* vdata = (ciReceiverTypeData*)pdata; dump_replay_data_receiver_type_helper<ciReceiverTypeData>(out, round, count, vdata); } else if (pdata->is_CallTypeData()) { ciCallTypeData* call_type_data = (ciCallTypeData*)pdata; dump_replay_data_call_type_helper<ciCallTypeData>(out, round, count, call_type_data); } } if (parameters != NULL) { for (int i = 0; i < parameters->number_of_parameters(); i++) { dump_replay_data_type_helper(out, round, count, parameters, ParametersTypeData::type_offset(i), parameters->valid_parameter_type(i)); } } } for (int count = 0, round = 0; round < 2; round++) { if (round == 1) out->print(" methods %d", count); dump_replay_data_extra_data_helper(out, round, count); } out->cr(); }