//---------------------------------------------------------------------------
void simplify(int code_length)
{
#ifdef SIMPLIFY
bool *marked = new bool[code_length];
for (int i = 0; i < code_length; marked[i++] = false);
mark(code_length - 1, marked);
// how many are skipped until a given instruction
int *skipped = new int[code_length];
if (!marked[0])
skipped[0] = 1;
else
skipped[0] = 0;
for (int i = 1; i < code_length; i++)
if (!marked[i])
skipped[i] = skipped[i - 1] + 1;
else
skipped[i] = skipped[i - 1];
if (simplified_prg)
delete[] simplified_prg;
simplified_prg = new t_code3[code_length];
num_utilized_instructions = 0;
for (int i = 0; i < code_length; i++)
if (marked[i]) {
simplified_prg[num_utilized_instructions] = prg[i];
if (prg[i].op < 0) {// operator
simplified_prg[num_utilized_instructions].adr1 -= skipped[prg[i].adr1];
simplified_prg[num_utilized_instructions].adr2 -= skipped[prg[i].adr2];
}
num_utilized_instructions++;
}
delete[] skipped;
delete[] marked;
#else
if (simplified_prg)
delete[] simplified_prg;
simplified_prg = new t_code3[code_length];
num_utilized_instructions = code_length;
for (int i = 0; i < code_length; i++)
simplified_prg[i] = prg[i];
#endif
}
/* Make sure we get the calculation in RFC 1624 section 4 correct. */
static void
test_rfc1624(void)
{
/* "...an IP packet header in which a 16-bit field m = 0x5555..." */
uint8_t data[32] = {
0xfe, 0x8f, 0xc1, 0x14, 0x4b, 0x6f, 0x70, 0x2a,
0x80, 0x29, 0x78, 0xc0, 0x58, 0x81, 0x77, 0xaa,
0x66, 0x64, 0xfc, 0x96, 0x63, 0x97, 0x64, 0xee,
0x12, 0x53, 0x1d, 0xa9, 0x2d, 0xa9, 0x55, 0x55
};
/* "...the one's complement sum of all other header octets is 0xCD7A." */
assert(ntohs(csum(data, sizeof data - 2)) == 0xffff - 0xcd7a);
/* "...the header checksum would be:
HC = ~(0xCD7A + 0x5555)
= ~0x22D0
= 0xDD2F"
*/
assert(ntohs(csum(data, sizeof data)) == 0xdd2f);
/* "a 16-bit field m = 0x5555 changes to m' = 0x3285..." */
data[30] = 0x32;
data[31] = 0x85;
/* "The new checksum via recomputation is:
HC' = ~(0xCD7A + 0x3285)
= ~0xFFFF
= 0x0000"
*/
assert(ntohs(csum(data, sizeof data)) == 0x0000);
/* "Applying [Eqn. 3] to the example above, we get the correct result:
HC' = ~(C + (-m) + m')
= ~(0x22D0 + ~0x5555 + 0x3285)
= ~0xFFFF
= 0x0000" */
assert(recalc_csum16(htons(0xdd2f), htons(0x5555), htons(0x3285))
== htons(0x0000));
mark('#');
}
int main()
{int i;
//for(i=0;i<=1000;i++){
//printf("%d ",a[i]);
//}
//printf("%d")
int cnt=0;
for(i=2;i<=sqrt(n-1);i++)
{ if (a[i]==0)
mark(i);
}
for(i=2;i<=n-1;i++){
if (a[i]==0){cnt++;
}}
printf("%d",cnt);
}
void
gc(struct lisp0_state*state){
mark(state->env);
mark(state->x);
mark(state->y);
mark(state->z);
term_t *sp = state->sp, *bp = state->bp;
for(;bp;++sp){
for(;sp<bp;++sp)
mark(*sp);
bp = (term_t*)*sp++;
}
for(struct list_builder *builder=state->builder;builder;builder=builder->next)
for(struct list*list=(struct list*)(builder->result);list;list=(struct list*)list->tail)
mark(list->head);
struct gc_header **gch=&(state->gc_stack);
for(struct gc_header*current=state->gc_stack;current;){
if(MARK(current)){
gch = &(current->next);
MARK(current)=0;
switch(PTAG(current)){
case PTAG_LIST:
case PTAG_LAMBDA:
case PTAG_MACRO:
mark(CAR(current));
mark(CDR(current));
break;
default:
;
};
current = current -> next;
}else{
*gch = current->next;
mem_free(&(state->pool),current);
current = *gch;
}
}
}
// Support for intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value)
//
// Arguments:
//
// exchange_value - GR_I0
// dest - GR_I1
// compare_value - GR_I2
//
// Results:
//
// GR_RET - the value previously stored in dest
//
address generate_atomic_cmpxchg_ptr() {
StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_ptr");
const Register exchange_value = GR_I0;
const Register dest = GR_I1;
const Register compare_value = GR_I2;
address start = __ emit_fd();
__ mf();
__ mov(AR_CCV, compare_value);
__ cmpxchg8(GR_RET, dest, exchange_value, Assembler::acquire);
__ ret();
return start;
}
// Send a Mitsubishi message
//
// Args:
// data: Contents of the message to be sent.
// nbits: Nr. of bits of data to be sent. Typically MITSUBISHI_BITS.
// repeat: Nr. of additional times the message is to be sent.
//
// Status: ALPHA / untested.
//
// Notes:
// This protocol appears to have no header.
// Ref:
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Mitsubishi.cpp
// GlobalCache's Control Tower's Mitsubishi TV data.
void IRsend::sendMitsubishi(uint64_t data, uint16_t nbits, uint16_t repeat) {
enableIROut(33); // Set IR carrier frequency
IRtimer usecTimer = IRtimer();
for (uint16_t i = 0; i <= repeat; i++) {
usecTimer.reset();
// No header
// Data
sendData(MITSUBISHI_BIT_MARK, MITSUBISHI_ONE_SPACE,
MITSUBISHI_BIT_MARK, MITSUBISHI_ZERO_SPACE,
data, nbits, true);
// Footer
mark(MITSUBISHI_BIT_MARK);
space(std::max(MITSUBISHI_MIN_COMMAND_LENGTH - usecTimer.elapsed(),
MITSUBISHI_MIN_GAP));
}
}
bool BoardGenerator::guess(int round, int guessNumber){
int localGuessCount = 0;
int position = findPositionWithFewestPossibilities();
{for (int i=0; i<NUM_POSS; i++){
int valIndex = randomPossibilityArray[i];
int valPos = getPossibilityIndex(valIndex,position);
if (possibilities[valPos] == 0){
if (localGuessCount == guessNumber){
int value = valIndex+1;
if (recordHistory) addHistoryItem(new LogItem(round, LogItem::GUESS, value, position));
mark(position, round, value);
return true;
}
localGuessCount++;
}
}}
return false;
}
void ICACHE_FLASH_ATTR ir_remote_send_raw(uint16_t buf[], uint16_t len, uint16_t freq_hz)
{
set_carrier_frequence(SONY_FREQUENCY);
uint16_t i;
for (i = 0; i < len; i++)
{
if (i & 1)
{
space(buf[i]);
}
else
{
mark(buf[i]);
}
}
space(0);
}
/* obsluha zmacknuti klavesy */
void ArchiveViewer::keyPressEvent(QKeyEvent *e){
if(e->key() == Qt::Key_Insert)
mark(!marked);
else if(e->key() == Qt::Key_Shift){
std::string msg("Selecting items is not allowed in archives");
MyDialog::MsgBox(msg);
}else if(e->key() == Qt::Key_Backspace){
emit(chlayout());
setFocus();
}else if(e->key() == Qt::Key_Return){
currentItem()->setExpanded(!currentItem()->isExpanded());
}else if(e->key() == Qt::Key_F1)
emit(chlayout());
else if(e->key() == Qt::Key_F11)
emit(refresh());
else // zpracuj normalne
QTreeWidget::keyPressEvent(e);
}
void ICacheStubGenerator::generate_icache_flush(
ICache::flush_icache_stub_t* flush_icache_stub
) {
StubCodeMark mark(this, "ICache", "flush_icache_stub");
address start = __ pc();
Label L;
__ bind(L);
__ flush( O0, G0 );
__ deccc( O1 );
__ br(Assembler::positive, false, Assembler::pn, L);
__ delayed()->inc( O0, 8 );
__ retl(false);
__ delayed()->mov( O2, O0 ); // handshake with caller to make sure it happened!
// Must be set here so StubCodeMark destructor can call the flush stub.
*flush_icache_stub = (ICache::flush_icache_stub_t)start;
};
void CalcIncoherentScattering(const long long int iter_num,
const double energy_MeV,
SharedCompoundPtr target)
{
// Gen X axis
int graduation=50;
double radStep=180.0/(double)graduation;
std::vector<double> rad;
double sum=0.0;
for(int i=0; i<graduation; i++) {
rad.push_back(sum);
sum+=radStep;
}
// Gen Y axis
UniformRandomGenerator0to1 random(12345);
std::vector<double> hist(graduation, 0);
for(long long int i=0; i<iter_num; i++) {
RunLight(i,iter_num);
PointVector_t ray(1.0, 1.0, 1.0);
SharedPhotonPtr photon = Photon::CreatePhoton(energy_MeV, ray);
while(photon->IncoherentScattering(target, random) == MC_REJECTED) {}
for(int j=0; j<graduation; j++) {
if(photon->GetIncline_rad() < (double)(j *radStep)*M_PI/180.0 ) {
hist[j]++;
break;
}
}
}
double sumhist =std::accumulate(hist.begin(), hist.end(), 0.0);
for(int i=0; i<hist.size(); i++) {
hist[i] /=sumhist;
}
// Plot
std::cout << "\r" << " ";
std::string mark("*");
std::string xlabel("degree");
std::string ylabel("probability");
Plotter plotter(graduation, 18, xlabel, ylabel);
plotter.Plot(rad, hist, mark);
}
void ExprCopy::visit(const ExprVector& e) {
for (int i=0; i<e.nb_args; i++)
visit(e.arg(i));
if (fold) {
int i=0;
for (; i<e.nb_args; i++) {
if (!dynamic_cast<const ExprConstant*>(&ARG(i))) break;
}
if (i==e.nb_args) {
if (e.dim.is_vector()) {
IntervalVector v(e.dim.vec_size());
for (i=0; i<e.nb_args; i++) {
v[i]=((const ExprConstant&) ARG(i)).get_value();
}
clone.insert(e, &ExprConstant::new_vector(v,e.row_vector()));
} else if (e.dim.type()==Dim::MATRIX) {
IntervalMatrix m(e.dim.dim2,e.dim.dim3);
for (i=0; i<e.nb_args; i++) {
m.set_row(i,((const ExprConstant&) ARG(i)).get_vector_value());
}
clone.insert(e, &ExprConstant::new_matrix(m));
} else {
assert(e.dim.type()==Dim::MATRIX_ARRAY);
IntervalMatrixArray ma(e.dim.dim1,e.dim.dim2,e.dim.dim3);
for (i=0; i<e.nb_args; i++) {
ma[i]=((const ExprConstant&) ARG(i)).get_matrix_value();
}
clone.insert(e, &ExprConstant::new_matrix_array(ma));
}
return;
}
}
Array<const ExprNode> args2(e.nb_args);
for (int i=0; i<e.nb_args; i++) {
args2.set_ref(i,ARG(i));
// don't remove this node even if it is a constant because
// it is an element of this vector.
mark(e.arg(i));
}
clone.insert(e, &ExprVector::new_(args2,e.row_vector()));
}
void mark(CELLP cp, int n) {
char c = cp->id;
//既に処理済みの物は対象外
if(c & USED) {
return;
}
//nilもノータッチ
if(cp == (CELLP)nil) {
return;
}
// 以下は、atom、cell、numの新世代の2つの領域と旧世代領域、sysatom領域について同じ処理
switch(c) {
case _ATOM:
//if(prompt == (ATOMP)cp) { printf("[M prompt's id=%x] --> ", (int)(((ATOMP)cp)->id)); }
cp->id |= USED;
//if(prompt == (ATOMP)cp) { printf("[M prompt's id=%x]\n", (int)(((ATOMP)cp)->id)); }
mark(((ATOMP)cp)->value, n);
mark(((ATOMP)cp)->plist, n);
mark(((ATOMP)cp)->forwarding, n);
// if(!((((ATOMP)cp)->ftype) & NONMRK)) {
if(((ATOMP)cp)->ftype == _EXPR){
mark(((ATOMP)cp)->fptr, n);
}
break;
case _CELL:
cp->id |= USED;
mark(cp->forwarding, n);
mark(cp->car, n);
mark(cp->cdr, n);
break;
case _FIX:
case _FLT:
if(n) {
cp->id |= USED;
if(((NUMP)cp)->forwarding) mark(((NUMP)cp)->forwarding, n);
}
break;
}
return;
}
/* -----------------------------------------------------------------------------
* Handeling Commands
* ---------------------------------------------------------------------------*/
char * handleCommand(char * request) {
fprintf(stderr, "Recv from Socket: %s", request);
char *tokens[5]; char *token; int i = 0;
while ((token = nextToken(&request))) {
tokens[i] = token;
i++;
}
char * response = "Some arbitrary response back to the socket\0";
if (!strcmp(tokens[0], "dimensions"))
dimensions(tokens[1], tokens[2]);
if (!strcmp(tokens[0], "absorb"))
absorb(tokens[1], tokens[2]);
if (!strcmp(tokens[0], "containerize"))
containerize();
else if (!strcmp(tokens[0], "focus"))
focus(tokens[1], tokens[2]);
else if (!strcmp(tokens[0], "get"))
response = get(tokens[1]);
else if(!strcmp(tokens[0], "jump"))
jump(tokens[1]);
else if (!strcmp(tokens[0], "kill"))
kill();
else if (!strcmp(tokens[0], "layout"))
layout(tokens[1]);
else if (!strcmp(tokens[0], "mark"))
mark(tokens[1]);
else if (!strcmp(tokens[0], "set"))
set(tokens[1], tokens[2]);
else if (!strcmp(tokens[0], "shift"))
shift(tokens[1], atoi(tokens[2]));
else if (!strcmp(tokens[0], "swap"))
swap(tokens[1], tokens[2]);
else if (!strcmp(tokens[0], "zoom"))
zoom(atoi(tokens[1]));
XFlush(display);
return response;
}
size32_t aesEncryptWithRSAEncryptedKey(MemoryBuffer &out, size32_t inSz, const void *inBytes, const CLoadedKey &publicKey)
{
// create random AES key and IV
char randomAesKey[aesMaxKeySize];
char randomIV[aesBlockSize];
fillRandomData(aesMaxKeySize, randomAesKey);
fillRandomData(aesBlockSize, randomIV);
size32_t startSz = out.length();
DelayedSizeMarker mark(out);
publicKeyEncrypt(out, aesMaxKeySize, randomAesKey, publicKey);
mark.write();
out.append(aesBlockSize, randomIV);
DelayedSizeMarker aesSz(out);
aesEncrypt(out, inSz, inBytes, aesMaxKeySize, randomAesKey, randomIV);
aesSz.write();
return out.length()-startSz;
}
void AdaptiveRegularRefiner_MultiGrid::
perform_refinement()
{
// todo: copy refinement marks from closure elements to their parents
vector<GridObject*> parents;
Selector::status_t refMark = RM_REFINE | RM_ANISOTROPIC;
get_parents_of_marked_closure_elements<Vertex>(parents, refMark);
get_parents_of_marked_closure_elements<Edge>(parents, refMark);
get_parents_of_marked_closure_elements<Face>(parents, refMark);
get_parents_of_marked_closure_elements<Volume>(parents, refMark);
remove_closure_elements();
// mark parents of formerly marked closure elements for refinement
mark(parents.begin(), parents.end(), RM_REFINE);
HangingNodeRefiner_MultiGrid::perform_refinement();
create_closure_elements();
}
vector<int> spiralOrder(vector<vector<int> > &matrix) {
vector<int> vec; if (matrix.empty()) return vec;
int m = matrix.size(), n = matrix[0].size();
vector<vector<int> > mark(m, vector<int>(n, 0));
// right, down, left, up
const int dir[][2] = {{0, +1}, {+1, 0}, {0, -1}, {-1, 0}};
int r = 0, c = 0;
int x = 0;
for (int i = 0; i < m*n; ++i) {
int val = matrix[r][c]; vec.push_back(val); mark[r][c] = 1;
int r2 = r + dir[x][0], c2 = c + dir[x][1];
if (inbound(r2, c2, m, n) && !mark[r2][c2]) { r = r2; c = c2; }
else {
x = x+1; if (x >= 4) x = 0;
r += dir[x][0]; c += dir[x][1];
}
}
return vec;
}
/**
* Scans the specified Object +obj+ for references to other Objects, and
* marks those Objects as reachable. Understands how to read the inside of
* an Object and find all references located within. For each reference
* found, it marks the object pointed to as live (which may trigger
* movement of the object in a copying garbage collector), but does not
* recursively scan into the referenced object (since such recursion could
* be arbitrarily deep, depending on the object graph, and this could cause
* the stack to blow up).
* /param obj The Object to be scanned for references to other Objects.
*/
void GarbageCollector::scan_object(Object* obj) {
Object* slot;
#ifdef ENABLE_OBJECT_WATCH
if(watched_p(obj)) {
std::cout << "detected " << obj << " during scan_object.\n";
}
#endif
// Check and update an inflated header
if(obj->inflated_header_p()) {
obj->inflated_header()->reset_object(obj);
}
slot = saw_object(obj->klass());
if(slot) obj->klass(object_memory_, force_as<Class>(slot));
if(obj->ivars()->reference_p()) {
slot = saw_object(obj->ivars());
if(slot) obj->ivars(object_memory_, slot);
}
// Handle Tuple directly, because it's so common
if(Tuple* tup = try_as<Tuple>(obj)) {
int size = tup->num_fields();
for(int i = 0; i < size; i++) {
slot = tup->field[i];
if(slot->reference_p()) {
slot = saw_object(slot);
if(slot) {
tup->field[i] = slot;
object_memory_->write_barrier(tup, slot);
}
}
}
} else {
TypeInfo* ti = object_memory_->type_info[obj->type_id()];
ObjectMark mark(this);
ti->mark(obj, mark);
}
}
void cover_goals_extt::operator()()
{
_iterations=_number_covered=0;
decision_proceduret::resultt dec_result;
// We use incremental solving, so need to freeze some variables
// to prevent them from being eliminated.
freeze_goal_variables();
do
{
// We want (at least) one of the remaining goals, please!
_iterations++;
constraint();
dec_result=solver();
switch(dec_result)
{
case decision_proceduret::D_UNSATISFIABLE: // DONE
break;
case decision_proceduret::D_SATISFIABLE:
// mark the goals we got
mark();
// notify
assignment();
if(!all_properties)
return; // exit on first failure if requested
break;
default:
error() << "decision procedure has failed" << eom;
return;
}
}
while(dec_result==decision_proceduret::D_SATISFIABLE &&
number_covered()<size());
}
vector<hvec> trace(hvec stpoint)
/* Traces a contour. The start point, because of the way the iteration works,
* is the leftmost point of the bottom line, so it starts going right.
*/
{hvec dir(1), left(1,1), right(0,-1);
vector<hvec> contour;
while (isedge(stpoint) && !ismarked(stpoint))
{contour.push_back(stpoint);
mark(stpoint);
if (isedge(stpoint+dir))
;
else if (isedge(stpoint+dir*left))
dir*=left;
else
dir*=right;
stpoint+=dir;
}
return contour;
}
int main(int argc, char* argv[])
{
int max_len = -1;
long max_ind = -1;
std::vector<bool> mark(num+1,true);
for ( long i = 1 ; i <= num ; ++ i)
{
if(!mark[i])
continue;
int len = chainLength(i,mark);
if(len > max_len)
{
max_len = len;
max_ind = i;
}
}
std::cout<<max_len<<' '<<max_ind<<std::endl;
// std::cout<<divSummation(divs)<<std::endl;
}
int main()
{
int i,j,ct;
while( scanf("%d %d",&m,&n) ) {
if( m == 0 || n == 0 ) break;
for(i=0;i<m;i++)
scanf("%s", oil[i] );
ct = 0;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
if( oil[i][j]=='@') {
ct++;
mark(i,j);
}
printf("%d\n",ct);
}
return 0;
}
void rungc(void) {
if (_alloced_mem > _gc_threshold) {
#ifdef MINIZINC_GC_STATS
std::cerr << "GC\n\talloced " << (_alloced_mem/1024) << "\n\tfree " << (_free_mem/1024) << "\n\tdiff "
<< ((_alloced_mem-_free_mem)/1024)
<< "\n\tthreshold " << (_gc_threshold/1024)
<< "\n";
#endif
mark();
sweep();
_gc_threshold = static_cast<size_t>(_alloced_mem * 1.5);
#ifdef MINIZINC_GC_STATS
std::cerr << "done\n\talloced " << (_alloced_mem/1024) << "\n\tfree " << (_free_mem/1024) << "\n\tdiff "
<< ((_alloced_mem-_free_mem)/1024)
<< "\n\tthreshold " << (_gc_threshold/1024)
<< "\n";
#endif
}
}
// Buffer contains times for mark/space pairs
//
void EngduinoIRClass::sendRaw(unsigned int *buf, int len)
{
bool sending_temp = sending;
while (rcvstate == STATE_READING) // Wait until we're not receiving
;
sending = true;
for (int i = 0; i < len; i++) {
if ((i & 1) == 0)
mark(buf[i]);
else
space(buf[i]);
}
space(0); // Just in case the list isn't an even length
sending = sending_temp;
}
address generate_icache_flush() {
assert( (intptr_t)stubCode % ((sizeof (jint)) * 2) == 0, "must be doubleword aligned");
StubCodeMark mark(this, "ICache", "flush_icache_stub");
# define __ _masm->
address start = __ pc();
Label L;
__ bind(L);
__ flush( O0, G0 );
__ deccc( O1 );
__ br(Assembler::positive, false, Assembler::pn, L);
__ delayed()->inc( O0, 8 );
__ retl();
__ delayed()->mov( O2, O0 ); // handshake with caller to make sure it happened!
# undef __
stubCode_start = start;
return start;
};
void
inheritance::visit (t_target_definition &n)
{
if (done (n))
return;
mark (n);
// this target doesn't inherit anything
if (!n.derive ())
return;
std::string const &name = id (n.derive ()->as<t_inheritance> ().base ());
// find referenced template
generic_node_ptr base = lookup (name);
if (!base)
{
errors.add<semantic_error> (n.derive (), "no such template: " + C::quoted (name));
return;
}
// visit inherited templates, first
base->accept (*this);
// now copy all information from the base definition
t_target_definition &b = base->as<t_target_definition> ();
if (b.cond ())
{
assert (!n.cond ());
n.cond (b.cond ()->clone ());
}
if (b.dest ())
{
assert (!n.dest ());
n.dest (b.dest ()->clone ());
}
t_target_members &body = n.body ()->as<t_target_members> ();
foreach (node_ptr const &p, b.body ()->as<t_target_members> ().list)
body.add (p->clone ());
}
// void getPsrInfo(VM_Version::CpuidInfo* cpuid_info);
address generate_getPsrInfo() {
StubCodeMark mark(this, "VM_Version", "getPsrInfo_stub");
# define __ _masm->
address start = __ pc();
// rbx is callee-save on both unix and windows
// rcx and rdx are first and second argument registers on windows
__ pushq(rbx);
__ movq(r8, rarg0);
__ xorl(rax, rax);
__ cpuid();
__ leaq(r9, Address(r8, in_bytes(VM_Version::std_cpuid0_offset())));
__ movl(Address(r9, 0), rax);
__ movl(Address(r9, 4), rbx);
__ movl(Address(r9, 8), rcx);
__ movl(Address(r9, 12), rdx);
__ movl(rax, 1);
__ cpuid();
__ leaq(r9, Address(r8, in_bytes(VM_Version::std_cpuid1_offset())));
__ movl(Address(r9, 0), rax);
__ movl(Address(r9, 4), rbx);
__ movl(Address(r9, 8), rcx);
__ movl(Address(r9, 12), rdx);
__ movl(rax, 0x80000001);
__ cpuid();
__ leaq(r9, Address(r8, in_bytes(VM_Version::ext_cpuid1_offset())));
__ movl(Address(r9, 0), rax);
__ movl(Address(r9, 4), rbx);
__ movl(Address(r9, 8), rcx);
__ movl(Address(r9, 12), rdx);
__ popq(rbx);
__ ret(0);
return start;
}
/* Make sure we get the calculation in RFC 1624 section 4 correct. */
static void
test_rfc1624(void)
{
/* "...an IP packet header in which a 16-bit field m = 0x5555..." */
uint8_t data[32] =
"\xfe\x8f\xc1\x14\x4b\x6f\x70\x2a\x80\x29\x78\xc0\x58\x81\x77\xaa"
"\x66\x64\xfc\x96\x63\x97\x64\xee\x12\x53\x1d\xa9\x2d\xa9\x55\x55";
/* "...the one's complement sum of all other header octets is 0xCD7A." */
assert(ntohs(csum(data, sizeof data - 2)) == 0xffff - 0xcd7a);
/* "...the header checksum would be:
HC = ~(0xCD7A + 0x5555)
= ~0x22D0
= 0xDD2F"
*/
assert(ntohs(csum(data, sizeof data)) == 0xdd2f);
/* "a 16-bit field m = 0x5555 changes to m' = 0x3285..." */
data[30] = 0x32;
data[31] = 0x85;
/* "The new checksum via recomputation is:
HC' = ~(0xCD7A + 0x3285)
= ~0xFFFF
= 0x0000"
*/
assert(ntohs(csum(data, sizeof data)) == 0x0000);
/* "Applying [Eqn. 3] to the example above, we get the correct result:
HC' = ~(C + (-m) + m')
= ~(0x22D0 + ~0x5555 + 0x3285)
= ~0xFFFF
= 0x0000" */
assert(recalc_csum16(htons(0xdd2f), htons(0x5555), htons(0x3285))
== htons(0x0000));
mark('#');
}
//------------------------------------------------------------------------------------------------------------------------
// Return point for a Java call if there's an exception thrown in Java code.
// The exception is caught and transformed into a pending exception stored in
// JavaThread that can be tested from within the VM.
//
address generate_catch_exception() {
StubCodeMark mark(this, "StubRoutines", "catch_exception");
address start = __ pc();
// verify that thread corresponds
// __ verify_thread();
// set pending exception
// __ verify_oop(GR8_exception, "generate_catch_exception");
const Register pending_exception_addr = GR2_SCRATCH;
const Register exception_file_addr = GR3_SCRATCH;
const Register exception_line_addr = GR31_SCRATCH;
const Register exception_file = GR30_SCRATCH;
const Register exception_line = GR29_SCRATCH;
const Register call_stub_return_address = GR28_SCRATCH;
const BranchRegister call_stub_return_address_br = BR6_SCRATCH;
__ add(pending_exception_addr, thread_(pending_exception));
__ mova(exception_file, (address)__FILE__);
__ add(exception_file_addr, thread_(exception_file));
__ mova(exception_line, (address)__LINE__);
__ st8(pending_exception_addr, GR8_exception);
__ st8(exception_file_addr, exception_file);
__ add(exception_line_addr, thread_(exception_line));
__ st8(exception_line_addr, exception_line);
// complete return to VM
assert(StubRoutines::_call_stub_return_address != NULL, "must have been generated before");
__ mova(call_stub_return_address, StubRoutines::_call_stub_return_address);
__ mov(call_stub_return_address_br, call_stub_return_address);
__ br(call_stub_return_address_br);
__ flush_bundle();
return start;
}
/**
* Scans the specified Object +obj+ for references to other Objects, and
* marks those Objects as reachable. Understands how to read the inside of
* an Object and find all references located within. For each reference
* found, it marks the object pointed to as live (which may trigger
* movement of the object in a copying garbage collector), but does not
* recursively scan into the referenced object (since such recursion could
* be arbitrarily deep, depending on the object graph, and this could cause
* the stack to blow up).
* /param obj The Object to be scanned for references to other Objects.
*/
void GarbageCollector::scan_object(Object* obj) {
#ifdef ENABLE_OBJECT_WATCH
if(watched_p(obj)) {
std::cout << "detected " << obj << " during scan_object.\n";
}
#endif
// We set scanned here before we finish scanning the object.
// This is done so we don't have a race condition while we're
// scanning the object and another thread updates a field during
// the phase where the object is partially scanned.
scanned_object(obj);
if(Object* klass = saw_object(obj->klass())) {
obj->klass(object_memory_, force_as<Class>(klass));
}
if(obj->ivars()->reference_p()) {
if(Object* ivars = saw_object(obj->ivars())) {
obj->ivars(object_memory_, ivars);
}
}
// Handle Tuple directly, because it's so common
if(Tuple* tup = try_as<Tuple>(obj)) {
native_int size = tup->num_fields();
for(native_int i = 0; i < size; i++) {
Object* slot = tup->field[i];
if(slot->reference_p()) {
if(Object* moved = saw_object(slot)) {
tup->field[i] = moved;
object_memory_->write_barrier(tup, moved);
}
}
}
} else {
TypeInfo* ti = object_memory_->type_info[obj->type_id()];
ObjectMark mark(this);
ti->mark(obj, mark);
}
}
