Beispiel #1
0
char* lookupTypeName(LookupType l) {
  char* name = NEW_RESOURCE_ARRAY(char, 80);
  switch (withoutExtraBits(l)) {
   case NormalLookupType:
    strcpy(name, "NormalLookup");
    break;
   case SelfLookupType:
    strcpy(name, "SelfLookup");
    break;
   case SuperLookupType:
    strcpy(name, "SuperLookup");
    break;
   default:
    fatal("Unknown lookupType");
   }
  bool hasFlag = false;
  switch (countType(l)) {
   case NonCounting: break;
   case Counting:    addFlag(hasFlag, name, "counting "); break;
   case Comparing:   addFlag(hasFlag, name, "comparing "); break;
   default: 	     fatal1("invalid count type %ld", countType(l));
  }
  if (isSet(l, DirtySendBit)) addFlag(hasFlag, name, "dirty ");
  if (isSet(l, OptimizedSendBit)) addFlag(hasFlag, name, "optimized ");
  if (isSet(l, UninlinableSendBit)) addFlag(hasFlag, name, "uninlinable ");
  if (hasFlag) strcat(name, "}");
    
  return name;
}
Beispiel #2
0
 pc_t CountStub::jump_addr() {
   CountCodePattern* patt = CountStub::pattern[countType()];
   int32* p = (int32*)insts();
   assert(isSetHi(p + patt->nm_sethi_offset), "wrong pattern");
   assert(isJump (p + patt->nm_jmp_offset), "wrong pattern");
   pc_t n = (pc_t)getSetHiImm(p + patt->nm_sethi_offset);
   n += getArithImm(p + patt->nm_jmp_offset);
   return n;
 }
bool Rule::isPreWinState(State *state, char oponent){
	if (2 == countType(state->getStateString().at(0), state->getStateString().at(1), state->getStateString().at(2))
		&& 1 == countDash(state->getStateString().at(0), state->getStateString().at(1), state->getStateString().at(2))
			&& hasOponent(state->getStateString().at(0), state->getStateString().at(1), state->getStateString().at(2), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(3), state->getStateString().at(4), state->getStateString().at(5))
		&& 1 == countDash(state->getStateString().at(3), state->getStateString().at(4), state->getStateString().at(5))
			&& hasOponent(state->getStateString().at(3), state->getStateString().at(4), state->getStateString().at(5), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(6), state->getStateString().at(7), state->getStateString().at(8))
		&& 1 == countDash(state->getStateString().at(6), state->getStateString().at(7), state->getStateString().at(8))
			&& hasOponent(state->getStateString().at(6), state->getStateString().at(7), state->getStateString().at(8), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(0), state->getStateString().at(3), state->getStateString().at(6))
		&& 1 == countDash(state->getStateString().at(0), state->getStateString().at(3), state->getStateString().at(6))
			&& hasOponent(state->getStateString().at(0), state->getStateString().at(3), state->getStateString().at(6), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(1), state->getStateString().at(4), state->getStateString().at(7))
		&& 1 == countDash(state->getStateString().at(1), state->getStateString().at(4), state->getStateString().at(7))
			&& hasOponent(state->getStateString().at(1), state->getStateString().at(4), state->getStateString().at(7), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(2), state->getStateString().at(5), state->getStateString().at(8))
		&& 1 == countDash(state->getStateString().at(2), state->getStateString().at(5), state->getStateString().at(8))
			&& hasOponent(state->getStateString().at(2), state->getStateString().at(5), state->getStateString().at(8), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(0), state->getStateString().at(4), state->getStateString().at(8))
		&& 1 == countDash(state->getStateString().at(0), state->getStateString().at(4), state->getStateString().at(8))
			&& hasOponent(state->getStateString().at(0), state->getStateString().at(4), state->getStateString().at(8), oponent))
			return true;

	else if (2 == countType(state->getStateString().at(2), state->getStateString().at(4), state->getStateString().at(6))
		&& 1 == countDash(state->getStateString().at(2), state->getStateString().at(4), state->getStateString().at(6))
			&& hasOponent(state->getStateString().at(2), state->getStateString().at(4), state->getStateString().at(6), oponent))
			return true;

	else
		return false;
}
bool Rule::isTerminal(char cell0, char cell1, char cell2){
	if (1 == countType(cell0, cell1, cell2)
		&& 0 == countDash(cell0, cell1, cell2))
		return true;
	return false;
}
Beispiel #5
0
// rebind the sendDesc to nm at addr, with cs_from_pic if non-NULL
void sendDesc::rebind(nmethod* nm, char* addr, CountStub *cs_from_pic) {
  if (VerifyZoneOften) {
    nm->linkedSends.verify_list_integrity();
    if (dependency()->next == NULL  &&  dependency()->prev == NULL)
      ; // not initted yet
    else
      verify();
  }
  if (addr == NULL) addr= nm->entryPointFor(this);
  assert(pic() == NULL, "shouldn't call");
  assert(nm->key.selector
         == static_or_dynamic_selector(nm->key.selector, nm->key.lookupType),
         "mismatched selector");
  nmethod* current= target();
  assert(   RecompilationInProgress
         || current != nm
         || nm->isYoung(),  // rebind to insert aging stub
         "why rebind?? (maybe I-cache did not get flushed)");

  if (nm->isDI() && countType() != NonCounting) {
    // turn off counting/comparing flag - cannot inline DI nmethods yet
    setCounting(NonCounting);
    assert(countType() == NonCounting, "oops");
  }
  CountStub *oldcs= countStub();
  assert(cs_from_pic == NULL || oldcs == NULL,
         "got count stub from pic and count stub from sendDesc");

  if (cs_from_pic) {
    assert(   nm->isYoung() && cs_from_pic->isAgingStub()
           || isCounting()  && cs_from_pic->isCountStub(),
              "count stub from pic doesn't match send desc");
    set_jump_addr(cs_from_pic->insts());
    dependency()->rebind(&cs_from_pic->sdLink);
    cs_from_pic->set_callee((int32)addr);
  } else if (UseAgingStubs && nm->isYoung()) {
    // need to insert an aging stub
    if (oldcs) {
      oldcs->deallocate();
    } else if (current) {
      dependency()->remove();
    }
    CountStub *newcs= new AgingStub(nm, addr, dependency());
    set_jump_addr(newcs->insts());
  } else if (UseAgingStubs && oldcs) {
    // change target of existing count stub
    oldcs->rebind(nm, addr);
  } else if (UseAgingStubs && isCounting()) {
    // create count stub
    if (current) dependency()->remove();        // unlink current target
    CountStub *newcs = 
      CountStub::new_CountStub(nm, addr, dependency(), countType()); 
    set_jump_addr(newcs->insts());
  } else {
    // rebind inline cache
    set_jump_addr(addr);
    dependency()->rebind(&nm->linkedSends);
  }
  if (VerifyZoneOften) verify();
  MachineCache::flush_instruction_cache_for_debugging();
}
Beispiel #6
0
 pc_t CountStub::jump_addr() {
   CountCodePattern* patt = CountStub::pattern[countType()];
   int32* p = (int32*)(int32(insts()) + patt->nmAddr_offset);
   return (pc_t) *p + int32(p) + sizeof(int32);
 }
Beispiel #7
0
char* lookupTypeName(LookupType l) {
  char* name = NEW_RESOURCE_ARRAY(char, 80);
  switch (l) {
   case NormalLookupType:
    strcpy(name, "NormalLookup");
    break;
   case StaticNormalLookupType:
    strcpy(name, "StaticNormalLookup");
    break;
   case ImplicitSelfLookupType:
    strcpy(name, "ImplicitSelfLookup");
    break;
   case ResendLookupType:
    strcpy(name, "ResendLookup");
    break;
   case DirectedResendLookupType:
    strcpy(name, "DirectedResendLookup");
    break;
   case NormalPerformType:
    strcpy(name, "NormalPerform");
    break;
   case ResendPerformType:
    strcpy(name, "ResendPerform");
    break;
   case DelegatedPerformType:
    strcpy(name, "DelegatedPerform");
    break;
   default:
    char* baseName;
    switch (baseLookupType(l)) {
     case NormalBaseLookupType:
      baseName ="NormalBaseLookup "; break;
     case ResendBaseLookupType:
      baseName ="ResendBaseLookup "; break;
     case DirectedResendBaseLookupType:
      baseName ="DirectedResendBaseLookup "; break;
     case DelegatedBaseLookupType:
      baseName ="DelegatedBaseLookup "; break;
     default: fatal("unexpected base lookup type");
    }
    strcpy(name, baseName);
    if (l & SelectorStaticBit) {
      strcat(name, "<selector static> ");
    }
    if (l & DelegateeStaticBit) {
      strcat(name, "<delegatee static> ");
    }
    if (l & ReceiverStaticBit) {
      strcat(name, "<receiver map static> ");
    }
  }
  bool hasFlag = false;
  switch (countType(l)) {
   case NonCounting: break;
   case Counting:    addFlag(hasFlag, name, "counting "); break;
   case Comparing:   addFlag(hasFlag, name, "comparing "); break;
   default:          fatal1("invalid count type %ld", countType(l));
  }
  if (isSet(l, DirtySendBit)) addFlag(hasFlag, name, "dirty ");
  if (isSet(l, OptimizedSendBit)) addFlag(hasFlag, name, "optimized ");
  if (isSet(l, UninlinableSendBit)) addFlag(hasFlag, name, "uninlinable ");
  if (hasFlag) strcat(name, "}");
    
  return name;
}