/*-----------------------------------------------------------------*/
void
deallocLocal (symbol * csym)
{
symbol *sym;
for (sym = csym; sym; sym = sym->next)
{
if (sym->_isparm)
continue;
/* if it is on the stack */
if (sym->onStack)
{
if (options.useXstack)
xstackPtr -= getSize (sym->type);
else
stackPtr -= getSize (sym->type);
}
/* if not used give a warning */
if (!sym->isref && !IS_STATIC (sym->etype))
werror (W_NO_REFERENCE,
currFunc ? currFunc->name : "(unknown)",
"local variable", sym->name);
/* now delete it from the symbol table */
deleteSym (SymbolTab, sym, sym->name);
}
}
int
cdbWriteEndFunction (symbol *pSym, iCode *ic, int offset)
{
char debugSym[INITIAL_INLINEASM];
if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
fprintf (stderr, "cdbFile.c:cdbWriteEndFunction()\n");
if (!cdbFilePtr) return 0;
if (ic)
{
sprintf (debugSym, "C$%s$%d$%d$%d",
FileBaseName (ic->filename), pSym->lastLine,
ic->level, ic->block);
spacesToUnderscores (debugSym, debugSym, sizeof (debugSym));
emitDebuggerSymbol (debugSym);
}
if (IS_STATIC (pSym->etype))
sprintf (debugSym, "XF%s$%s$0$0", moduleName, pSym->name);
else
sprintf (debugSym, "XG$%s$0$0", pSym->name);
emitDebuggerSymbol (debugSym);
return 1;
}
void
StarterMgr::publish( ClassAd* ad, amask_t mask )
{
if( !(IS_STATIC(mask) && IS_PUBLIC(mask)) ) {
return;
}
Starter *tmp_starter;
StringList ability_list;
starters.Rewind();
while( starters.Next(tmp_starter) ) {
tmp_starter->publish( ad, mask, &ability_list );
}
// finally, print out all the abilities we added into the
// classad so that other folks can know what we did.
char* ability_str = ability_list.print_to_string();
// If our ability list is NULL it means that we have no starters.
// This is ok for hawkeye; nothing more to do here!
if ( NULL == ability_str ) {
ability_str = strdup("\0");
}
ASSERT(ability_str);
ad->Assign( ATTR_STARTER_ABILITY_LIST, ability_str );
free( ability_str );
}
void
Starter::publish( ClassAd* ad, amask_t mask, StringList* list )
{
if( !(IS_STATIC(mask) && IS_PUBLIC(mask)) ) {
return;
}
// Check for ATTR_STARTER_IGNORED_ATTRS. If defined,
// we insert all attributes from the starter ad except those
// in the list. If not, we fall back on our old behavior
// of only inserting attributes prefixed with "Has" or
// "Java". Either way, we only add the "Has" attributes
// into the StringList (the StarterAbilityList)
char* ignored_attrs = NULL;
StringList* ignored_attr_list = NULL;
if (s_ad->LookupString(ATTR_STARTER_IGNORED_ATTRS, &ignored_attrs)) {
ignored_attr_list = new StringList(ignored_attrs);
free(ignored_attrs);
// of course, we don't want ATTR_STARTER_IGNORED_ATTRS
// in either!
ignored_attr_list->append(ATTR_STARTER_IGNORED_ATTRS);
}
ExprTree *tree, *pCopy;
const char *lhstr = NULL;
s_ad->ResetExpr();
while( s_ad->NextExpr(lhstr, tree) ) {
pCopy=0;
if (ignored_attr_list) {
// insert every attr that's not in the ignored_attr_list
if (!ignored_attr_list->contains(lhstr)) {
pCopy = tree->Copy();
ad->Insert(lhstr, pCopy, false);
if (strncasecmp(lhstr, "Has", 3) == MATCH) {
list->append(lhstr);
}
}
}
else {
// no list of attrs to ignore - fallback on old behavior
if( strncasecmp(lhstr, "Has", 3) == MATCH ) {
pCopy = tree->Copy();
ad->Insert( lhstr, pCopy, false );
if( list ) {
list->append( lhstr );
}
} else if( strncasecmp(lhstr, "Java", 4) == MATCH ) {
pCopy = tree->Copy();
ad->Insert( lhstr, pCopy, false);
}
}
}
if (ignored_attr_list) {
delete ignored_attr_list;
}
}
void
AvailStats::compute( amask_t how_much )
{
if( !compute_avail_stats ) return;
if( IS_STATIC(how_much) && IS_SHARED(how_much) ) {
as_avail_confidence = param_double("STARTD_AVAIL_CONFIDENCE", as_avail_confidence, 0, 1);
as_max_avail_periods = param_integer("STARTD_MAX_AVAIL_PERIOD_SAMPLES", as_max_avail_periods);
}
if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) {
time_t current_time = time(0);
// only compute avail time estimate if we're in non-owner state
if( as_start_avail ) {
// first, skip over intervals less than our idle time so far
int current_idle_time = current_time - as_start_avail;
int num_intervals = as_num_avail_periods;
as_avail_periods.Rewind();
int item = 0;
as_avail_periods.Next(item);
while( num_intervals && item < current_idle_time ) {
as_avail_periods.Next(item);
num_intervals--;
}
if( !num_intervals ) {
// If this is the longest we've ever been idle, our
// historical data isn't too useful to us, so give an
// estimate based on how long we've been idle so far.
as_avail_estimate =
(int)floor(current_idle_time*(2.0-as_avail_confidence));
} else {
// Otherwise, find the record in our history at the
// requested confidence level.
int idx = (int)floor(num_intervals*(1.0-as_avail_confidence));
while( idx ) {
as_avail_periods.Next(item);
idx--;
}
as_avail_estimate = item;
}
as_avail_time =
float(as_tot_avail_time + current_idle_time) /
float(current_time - as_birthdate);
} else {
as_avail_time = float(as_tot_avail_time) /
float(current_time - as_birthdate);
}
}
}
void
CpuAttributes::publish( ClassAd* cp, amask_t how_much )
{
if( IS_UPDATE(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_VIRTUAL_MEMORY, (int)c_virt_mem );
cp->Assign( ATTR_TOTAL_DISK, (int)c_total_disk );
cp->Assign( ATTR_DISK, (int)c_disk );
}
if( IS_TIMEOUT(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_CONDOR_LOAD_AVG, rint(c_condor_load * 100) / 100.0 );
cp->Assign( ATTR_LOAD_AVG, rint((c_owner_load + c_condor_load) * 100) / 100.0 );
cp->Assign( ATTR_KEYBOARD_IDLE, (int)c_idle );
// ConsoleIdle cannot be determined on all platforms; thus, only
// advertise if it is not -1.
if( c_console_idle != -1 ) {
cp->Assign( ATTR_CONSOLE_IDLE, (int)c_console_idle );
}
}
if( IS_STATIC(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_MEMORY, c_phys_mem );
cp->Assign( ATTR_CPUS, c_num_cpus );
cp->Assign( ATTR_TOTAL_SLOT_MEMORY, c_slot_mem );
cp->Assign( ATTR_TOTAL_SLOT_DISK, (int)c_slot_disk );
cp->Assign( ATTR_TOTAL_SLOT_CPUS, c_num_slot_cpus );
// publish local resource quantities for this slot
for (slotres_map_t::iterator j(c_slotres_map.begin()); j != c_slotres_map.end(); ++j) {
string rname(j->first.c_str());
*(rname.begin()) = toupper(*(rname.begin()));
string attr;
formatstr(attr, "%s%s", "", rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
formatstr(attr, "%s%s", ATTR_TOTAL_SLOT_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(c_slottot_map[j->first]));
}
}
}
static COMMAND_FUNC( do_protect )
{
Data_Obj *dp;
dp=pick_obj("");
if( dp == NULL ) return;
if( IS_STATIC(dp) ){
sprintf(ERROR_STRING,"do_protect: Object %s is already static!?",OBJ_NAME(dp));
warn(ERROR_STRING);
return;
}
SET_OBJ_FLAG_BITS(dp,DT_STATIC);
}
int
cdbWriteFunction (symbol *pSym, iCode *ic)
{
char debugSym[INITIAL_INLINEASM];
if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
fprintf (stderr, "cdbFile.c:cdbWriteFunction()\n");
if (!cdbFilePtr) return 0;
if (IS_STATIC (pSym->etype))
sprintf (debugSym, "F%s$%s$0$0", moduleName, pSym->name);
else
sprintf (debugSym, "G$%s$0$0", pSym->name);
emitDebuggerSymbol (debugSym);
return cdbWriteBasicSymbol (pSym, FALSE, TRUE);
}
Field* rvmAddField(Env* env, Class* clazz, const char* name, const char* desc, jint access, jint offset, void* attributes) {
Field* field = rvmAllocateMemory(env, IS_STATIC(access) ? sizeof(ClassField) : sizeof(InstanceField));
if (!field) return NULL;
field->clazz = clazz;
field->name = name;
field->desc = desc;
field->access = access;
field->attributes = attributes;
if (clazz->_fields == &FIELDS_NOT_LOADED) {
clazz->_fields = NULL;
}
field->next = clazz->_fields;
clazz->_fields = field;
if (access & ACC_STATIC) {
((ClassField*) field)->address = ((jbyte*) clazz) + offset;
} else {
((InstanceField*) field)->offset = offset;
}
return field;
}
/*-----------------------------------------------------------------*/
void
allocLocal (symbol * sym)
{
/* generate an unique name */
SNPRINTF (sym->rname, sizeof(sym->rname),
"%s%s_%s_%d_%d",
port->fun_prefix,
currFunc->name, sym->name, sym->level, sym->block);
sym->islocal = 1;
sym->localof = currFunc;
/* if this is a static variable */
if (IS_STATIC (sym->etype))
{
allocGlobal (sym);
sym->allocreq = 1;
return;
}
/* if volatile then */
if (IS_VOLATILE (sym->etype))
sym->allocreq = 1;
/* this is automatic */
/* if it's to be placed on the stack */
if (options.stackAuto || reentrant)
{
sym->onStack = 1;
if (options.useXstack)
{
/* PENDING: stack direction for xstack */
SPEC_OCLS (sym->etype) = xstack;
SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
xstackPtr += getSize (sym->type);
}
else
{
SPEC_OCLS (sym->etype) = istack;
if (port->stack.direction > 0)
{
SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
stackPtr += getSize (sym->type);
}
else
{
stackPtr -= getSize (sym->type);
SPEC_STAK (sym->etype) = sym->stack = stackPtr;
}
}
allocIntoSeg (sym);
return;
}
/* else depending on the storage class specified */
/* if this is a function then assign code space */
if (IS_FUNC (sym->type))
{
SPEC_OCLS (sym->etype) = code;
return;
}
/* if this is a bit variable and no storage class */
if (bit && IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT)
{
SPEC_SCLS (sym->type) = S_BIT;
SPEC_OCLS (sym->type) = bit;
allocIntoSeg (sym);
return;
}
if ((SPEC_SCLS (sym->etype) == S_DATA) || (SPEC_SCLS (sym->etype) == S_REGISTER))
{
SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
allocIntoSeg (sym);
return;
}
if (allocDefault (sym))
{
return;
}
/* again note that we have put it into the overlay segment
will remove and put into the 'data' segment if required after
overlay analysis has been done */
if (options.model == MODEL_SMALL)
{
SPEC_OCLS (sym->etype) =
(options.noOverlay ? port->mem.default_local_map : overlay);
}
else
{
SPEC_OCLS (sym->etype) = port->mem.default_local_map;
}
allocIntoSeg (sym);
}
/*-----------------------------------------------------------------*/
static void
pic14emitOverlay (struct dbuf_s * aBuf)
{
set *ovrset;
/* if (!elementsInSet (ovrSetSets))*/
/* the hack below, fixes translates for devices which
* only have udata_shr memory */
dbuf_printf (aBuf, "%s\t%s\n",
(elementsInSet(ovrSetSets)?"":";"),
port->mem.overlay_name);
/* for each of the sets in the overlay segment do */
for (ovrset = setFirstItem (ovrSetSets); ovrset;
ovrset = setNextItem (ovrSetSets))
{
symbol *sym;
if (elementsInSet (ovrset))
{
/* this dummy area is used to fool the assembler
otherwise the assembler will append each of these
declarations into one chunk and will not overlay
sad but true */
/* I don't think this applies to us. We are using gpasm. CRF */
dbuf_printf (aBuf, ";\t.area _DUMMY\n");
/* output the area informtion */
dbuf_printf (aBuf, ";\t.area\t%s\n", port->mem.overlay_name); /* MOF */
}
for (sym = setFirstItem (ovrset); sym;
sym = setNextItem (ovrset))
{
/* if extern then do nothing */
if (IS_EXTERN (sym->etype))
continue;
/* if allocation required check is needed
then check if the symbol really requires
allocation only for local variables */
if (!IS_AGGREGATE (sym->type) &&
!(sym->_isparm && !IS_REGPARM (sym->etype))
&& !sym->allocreq && sym->level)
continue;
/* if global variable & not static or extern
and addPublics allowed then add it to the public set */
if ((sym->_isparm && !IS_REGPARM (sym->etype))
&& !IS_STATIC (sym->etype))
addSetHead (&publics, sym);
/* if extern then do nothing or is a function
then do nothing */
if (IS_FUNC (sym->type))
continue;
/* print extra debug info if required */
if (options.debug || sym->level == 0)
{
if (!sym->level)
{ /* global */
if (IS_STATIC (sym->etype))
dbuf_printf (aBuf, "F%s_", moduleName); /* scope is file */
else
dbuf_printf (aBuf, "G_"); /* scope is global */
}
else
/* symbol is local */
dbuf_printf (aBuf, "L%s_",
(sym->localof ? sym->localof->name : "-null-"));
dbuf_printf (aBuf, "%s_%d_%d", sym->name, sym->level, sym->block);
}
/* if is has an absolute address then generate
an equate for this no need to allocate space */
if (SPEC_ABSA (sym->etype))
{
if (options.debug || sym->level == 0)
dbuf_printf (aBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype));
dbuf_printf (aBuf, "%s\t=\t0x%04x\n",
sym->rname,
SPEC_ADDR (sym->etype));
}
else
{
if (options.debug || sym->level == 0)
dbuf_printf (aBuf, "==.\n");
/* allocate space */
dbuf_printf (aBuf, "%s:\n", sym->rname);
dbuf_printf (aBuf, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
}
}
}
}
static void
pic14_constructAbsMap (struct dbuf_s *oBuf, struct dbuf_s *gloBuf)
{
memmap *maps[] = { data, sfr, NULL };
int i;
hTab *ht = NULL;
symbol *sym;
set *aliases;
int addr, min=-1, max=-1;
int size;
for (i=0; maps[i] != NULL; i++)
{
for (sym = (symbol *)setFirstItem (maps[i]->syms);
sym; sym = setNextItem (maps[i]->syms))
{
if (IS_DEFINED_HERE(sym) && SPEC_ABSA(sym->etype))
{
addr = SPEC_ADDR(sym->etype);
/* handle CONFIG words here */
if (IS_CONFIG_ADDRESS( addr ))
{
//fprintf( stderr, "%s: assignment to CONFIG@0x%x found\n", __FUNCTION__, addr );
//fprintf( stderr, "ival: %p (0x%x)\n", sym->ival, (int)list2int( sym->ival ) );
if (sym->ival) {
pic14_assignConfigWordValue( addr, (int)list2int( sym->ival ) );
} else {
fprintf( stderr, "ERROR: Symbol %s, which is covering a __CONFIG word must be initialized!\n", sym->name );
}
continue;
}
if (max == -1 || addr > max) max = addr;
if (min == -1 || addr < min) min = addr;
//fprintf (stderr, "%s: sym %s @ 0x%x\n", __FUNCTION__, sym->name, addr);
aliases = hTabItemWithKey (ht, addr);
if (aliases) {
/* May not use addSetHead, as we cannot update the
* list's head in the hastable `ht'. */
addSet (&aliases, sym);
#if 0
fprintf( stderr, "%s: now %d aliases for %s @ 0x%x\n",
__FUNCTION__, elementsInSet(aliases), sym->name, addr);
#endif
} else {
addSet (&aliases, sym);
hTabAddItem (&ht, addr, aliases);
} // if
} // if
} // for sym
} // for i
/* now emit definitions for all absolute symbols */
dbuf_printf (oBuf, "%s", iComments2);
dbuf_printf (oBuf, "; absolute symbol definitions\n");
dbuf_printf (oBuf, "%s", iComments2);
for (addr=min; addr <= max; addr++)
{
size = 1;
aliases = hTabItemWithKey (ht, addr);
if (aliases && elementsInSet(aliases)) {
/* Make sure there is no initialized value at this location! */
for (sym = setFirstItem(aliases); sym; sym = setNextItem(aliases)) {
if (sym->ival) break;
} // for
if (sym) continue;
dbuf_printf (oBuf, "UD_abs_%s_%x\tudata_ovr\t0x%04x\n",
moduleName, addr, addr);
for (sym = setFirstItem (aliases); sym;
sym = setNextItem (aliases))
{
if (getSize(sym->type) > size) {
size = getSize(sym->type);
}
/* initialized values are handled somewhere else */
if (sym->ival) continue;
/* emit STATUS as well as _STATUS, required for SFRs only */
//dbuf_printf (oBuf, "%s\tres\t0\n", sym->name);
dbuf_printf (oBuf, "%s\n", sym->rname);
if (IS_GLOBAL(sym) && !IS_STATIC(sym->etype)) {
//emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->name);
emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->rname);
} // if
} // for
dbuf_printf (oBuf, "\tres\t%d\n", size);
} // if
} // for i
}
/*
* Emit a set of symbols.
* type - 0: have symbol tell whether it is local, extern or global
* 1: assume all symbols in set to be global
* 2: assume all symbols in set to be extern
*/
static void
emitSymbolSet(set *s, int type)
{
symbol *sym;
initList *list;
unsigned sectionNr = 0;
for (sym = setFirstItem(s); sym; sym = setNextItem(s)) {
#if 0
fprintf (stdout, "; name %s, rname %s, level %d, block %d, key %d, local %d, ival %p, static %d, cdef %d, used %d\n",
sym->name, sym->rname, sym->level, sym->block, sym->key, sym->islocal, sym->ival, IS_STATIC(sym->etype), sym->cdef, sym->used);
#endif
if (sym->etype && SPEC_ABSA(sym->etype)
&& IS_CONFIG_ADDRESS(SPEC_ADDR(sym->etype))
&& sym->ival)
{
// handle config words
pic14_assignConfigWordValue(SPEC_ADDR(sym->etype),
(int)list2int(sym->ival));
pic14_stringInSet(sym->rname, &emitted, 1);
continue;
}
if (sym->isstrlit) {
// special case: string literals
emitInitVal(ivalBuf, sym, sym->type, NULL);
continue;
}
if (type != 0 || sym->cdef
|| (!IS_STATIC(sym->etype)
&& IS_GLOBAL(sym)))
{
// bail out for ___fsadd and friends
if (sym->cdef && !sym->used) continue;
/* export or import non-static globals */
if (!pic14_stringInSet(sym->rname, &emitted, 0)) {
if (type == 2 || IS_EXTERN(sym->etype) || sym->cdef)
{
/* do not add to emitted set, it might occur again! */
//if (!sym->used) continue;
// declare symbol
emitIfNew (extBuf, &emitted, "\textern\t%s\n", sym->rname);
} else {
// declare symbol
emitIfNew (gloBuf, &emitted, "\tglobal\t%s\n", sym->rname);
if (!sym->ival && !IS_FUNC(sym->type)) {
// also define symbol
if (IS_ABSOLUTE(sym->etype)) {
// absolute location?
//dbuf_printf (gloDefBuf, "UD_%s_%u\tudata\t0x%04X\n", moduleName, sectionNr++, SPEC_ADDR(sym->etype));
// deferred to pic14_constructAbsMap
} else {
dbuf_printf (gloDefBuf, "UD_%s_%u\tudata\n", moduleName, sectionNr++);
dbuf_printf (gloDefBuf, "%s\tres\t%d\n\n", sym->rname, getSize(sym->type));
}
} // if
} // if
pic14_stringInSet(sym->rname, &emitted, 1);
} // if
} // if
list = sym->ival;
//if (list) showInitList(list, 0);
if (list) {
resolveIvalSym( list, sym->type );
emitInitVal(ivalBuf, sym, sym->type, sym->ival);
dbuf_printf (ivalBuf, "\n");
}
} // for sym
}
void
MachAttributes::publish( ClassAd* cp, amask_t how_much)
{
if( IS_STATIC(how_much) || IS_PUBLIC(how_much) ) {
// STARTD_IP_ADDR
cp->Assign( ATTR_STARTD_IP_ADDR,
daemonCore->InfoCommandSinfulString() );
cp->Assign( ATTR_ARCH, m_arch );
cp->Assign( ATTR_OPSYS, m_opsys );
if (m_opsysver) {
cp->Assign( ATTR_OPSYSVER, m_opsysver );
}
cp->Assign( ATTR_OPSYS_AND_VER, m_opsys_and_ver );
if (m_opsys_major_ver) {
cp->Assign( ATTR_OPSYS_MAJOR_VER, m_opsys_major_ver );
}
if (m_opsys_name) {
cp->Assign( ATTR_OPSYS_NAME, m_opsys_name );
}
if (m_opsys_long_name) {
cp->Assign( ATTR_OPSYS_LONG_NAME, m_opsys_long_name );
}
if (m_opsys_short_name) {
cp->Assign( ATTR_OPSYS_SHORT_NAME, m_opsys_short_name );
}
if (m_opsys_legacy) {
cp->Assign( ATTR_OPSYS_LEGACY, m_opsys_legacy );
}
cp->Assign( ATTR_UID_DOMAIN, m_uid_domain );
cp->Assign( ATTR_FILE_SYSTEM_DOMAIN, m_filesystem_domain );
cp->Assign( ATTR_HAS_IO_PROXY, true );
cp->Assign( ATTR_CHECKPOINT_PLATFORM, m_ckptpltfrm );
#if defined ( WIN32 )
// publish the Windows version information
if ( m_got_windows_version_info ) {
cp->Assign( ATTR_WINDOWS_MAJOR_VERSION,
(int)m_window_version_info.dwMajorVersion );
cp->Assign( ATTR_WINDOWS_MINOR_VERSION,
(int)m_window_version_info.dwMinorVersion );
cp->Assign( ATTR_WINDOWS_BUILD_NUMBER,
(int)m_window_version_info.dwBuildNumber );
// publish the extended Windows version information if we
// have it at our disposal
if ( sizeof ( OSVERSIONINFOEX ) ==
m_window_version_info.dwOSVersionInfoSize ) {
cp->Assign( ATTR_WINDOWS_SERVICE_PACK_MAJOR,
(int)m_window_version_info.wServicePackMajor );
cp->Assign( ATTR_WINDOWS_SERVICE_PACK_MINOR,
(int)m_window_version_info.wServicePackMinor );
cp->Assign( ATTR_WINDOWS_PRODUCT_TYPE,
(int)m_window_version_info.wProductType );
}
}
/*
Publish .Net versions installed on current machine assuming
the option is turned on..
*/
if(param_boolean("STARTD_PUBLISH_DOTNET", true))
{
if(m_dot_Net_Versions)
cp->Assign(ATTR_DOTNET_VERSIONS, m_dot_Net_Versions);
}
// publish values from the window's registry as specified
// in the STARTD_PUBLISH_WINREG param.
//
m_lst_static.Rewind();
while (AttribValue *pav = m_lst_static.Next()) {
if (pav) pav->AssignToClassAd(cp);
}
/*
char * pubreg_param = param("STARTD_PUBLISH_WINREG");
if (pubreg_param) {
StringList reg_list(pubreg_param, ";");
reg_list.rewind();
while(char * reg_item = reg_list.next()) {
// if the reg_item is of the form attr_name=reg_path;
// then skip over the attr_name and '=' and trailing
// whitespace. But if the = is after the first \, then
// it's a part of the reg_path, so ignore it.
//
const char * pkey = strchr(reg_item, '=');
const char * pbs = strchr(reg_item, '\\');
if (pkey && ( ! pbs || pkey < pbs)) {
++pkey; // skip the '='
} else {
pkey = reg_item;
}
// skip any leading whitespace in the reg_path
while (isspace(pkey[0]))
++pkey;
// if the keyname begins with 32 or 64, use that to designate either
// the WOW64 or WOW32 view of the registry, but don't pass the
// leading number on to the lower level code.
int options = 0;
if (isdigit(pkey[0])) {
options = atoi(pkey);
while (isdigit(pkey[0])) {
++pkey;
}
}
// get the registry value of the given key, and assign it
// to the given attribute name, or a generated name.
//
char * value = get_windows_reg_value(pkey, NULL, options);
if (value) {
char * attr_name = generate_reg_key_attr_name("WINREG_", reg_item);
if (attr_name) {
cp->Assign(attr_name, value);
free (attr_name);
}
free(value);
}
}
free (pubreg_param);
}
*/
#endif // defined ( WIN32 )
}
if( IS_UPDATE(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_TOTAL_VIRTUAL_MEMORY, (int)m_virt_mem );
cp->Assign( ATTR_TOTAL_CPUS, m_num_cpus );
cp->Assign( ATTR_TOTAL_MEMORY, m_phys_mem );
// KFLOPS and MIPS are only conditionally computed; thus, only
// advertise them if we computed them.
if ( m_kflops > 0 ) {
cp->Assign( ATTR_KFLOPS, m_kflops );
}
if ( m_mips > 0 ) {
cp->Assign( ATTR_MIPS, m_mips );
}
#if defined(WIN32)
if ( m_local_credd != NULL ) {
cp->Assign(ATTR_LOCAL_CREDD, m_local_credd);
}
#endif
string machine_resources = "cpus memory disk swap";
// publish any local resources
for (slotres_map_t::iterator j(m_machres_map.begin()); j != m_machres_map.end(); ++j) {
string rname(j->first.c_str());
*(rname.begin()) = toupper(*(rname.begin()));
string attr;
formatstr(attr, "%s%s", ATTR_DETECTED_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
formatstr(attr, "%s%s", ATTR_TOTAL_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
machine_resources += " ";
machine_resources += j->first;
}
cp->Assign(ATTR_MACHINE_RESOURCES, machine_resources.c_str());
}
// We don't want this inserted into the public ad automatically
if( IS_UPDATE(how_much) || IS_TIMEOUT(how_much) ) {
cp->Assign( ATTR_LAST_BENCHMARK, (unsigned)m_last_benchmark );
}
if( IS_TIMEOUT(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_TOTAL_LOAD_AVG, rint(m_load * 100) / 100.0);
cp->Assign( ATTR_TOTAL_CONDOR_LOAD_AVG,
rint(m_condor_load * 100) / 100.0);
cp->Assign( ATTR_CLOCK_MIN, m_clock_min );
cp->Assign( ATTR_CLOCK_DAY, m_clock_day );
m_lst_dynamic.Rewind();
while (AttribValue *pav = m_lst_dynamic.Next() ) {
if (pav) pav->AssignToClassAd(cp);
}
}
// temporary attributes for raw utsname info
cp->Assign( ATTR_UTSNAME_SYSNAME, m_utsname_sysname );
cp->Assign( ATTR_UTSNAME_NODENAME, m_utsname_nodename );
cp->Assign( ATTR_UTSNAME_RELEASE, m_utsname_release );
cp->Assign( ATTR_UTSNAME_VERSION, m_utsname_version );
cp->Assign( ATTR_UTSNAME_MACHINE, m_utsname_machine );
// Advertise chroot information
if ( m_named_chroot.size() > 0 ) {
cp->Assign( "NamedChroot", m_named_chroot.c_str() );
}
}
void
MachAttributes::compute( amask_t how_much )
{
// the startd doesn't normally call the init() method (bug?),
// it just starts calling compute, so in order to gurantee that
// init happens, we put check here to see if user settings have been initialized
if ( ! m_user_settings_init)
init_user_settings();
if( IS_STATIC(how_much) && IS_SHARED(how_much) ) {
// Since we need real values for them as soon as a
// MachAttributes object is instantiated, we handle number
// of CPUs and physical memory in the constructor, not
// here. -Derek Wright 2/5/99
// Arch, OpSys, FileSystemDomain and UidDomain. Note:
// these will always return something, since config() will
// insert values if we don't have them in the config file.
if( m_arch ) {
free( m_arch );
}
m_arch = param( "ARCH" );
if( m_opsys ) {
free( m_opsys );
}
m_opsys = param( "OPSYS" );
m_opsysver = param_integer( "OPSYSVER", 0 );
if( m_opsys_and_ver ) {
free( m_opsys_and_ver );
}
m_opsys_and_ver = param( "OPSYSANDVER" );
m_opsys_major_ver = param_integer( "OPSYSMAJORVER", 0 );
if( m_opsys_name ) {
free( m_opsys_name );
}
m_opsys_name = param( "OPSYSNAME" );
if( m_opsys_long_name ) {
free( m_opsys_long_name );
}
m_opsys_long_name = param( "OPSYSLONGNAME" );
if( m_opsys_short_name ) {
free( m_opsys_short_name );
}
m_opsys_short_name = param( "OPSYSSHORTNAME" );
if( m_opsys_legacy ) {
free( m_opsys_legacy );
}
m_opsys_legacy = param( "OPSYSLEGACY" );
// temporary attributes for raw utsname info
if( m_utsname_sysname ) {
free( m_utsname_sysname );
}
if( m_utsname_nodename ) {
free( m_utsname_nodename );
}
if( m_utsname_release ) {
free( m_utsname_release );
}
if( m_utsname_version ) {
free( m_utsname_version );
}
if( m_utsname_machine ) {
free( m_utsname_machine );
}
m_utsname_sysname = param( "UTSNAME_SYSNAME" );
m_utsname_nodename = param( "UTSNAME_NODENAME" );
m_utsname_release = param( "UTSNAME_RELEASE" );
m_utsname_version = param( "UTSNAME_VERSION" );
m_utsname_machine = param( "UTSNAME_MACHINE" );
if( m_uid_domain ) {
free( m_uid_domain );
}
m_uid_domain = param( "UID_DOMAIN" );
dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_UID_DOMAIN,
m_uid_domain );
if( m_filesystem_domain ) {
free( m_filesystem_domain );
}
m_filesystem_domain = param( "FILESYSTEM_DOMAIN" );
dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_FILE_SYSTEM_DOMAIN,
m_filesystem_domain );
m_idle_interval = param_integer( "IDLE_INTERVAL", -1 );
// checkpoint platform signature
if (m_ckptpltfrm) {
free(m_ckptpltfrm);
}
const char * ckptpltfrm = param( ATTR_CHECKPOINT_PLATFORM );
if( ckptpltfrm == NULL ) {
ckptpltfrm = sysapi_ckptpltfrm();
}
m_ckptpltfrm = strdup( ckptpltfrm );
pair_strings_vector root_dirs = root_dir_list();
std::stringstream result;
unsigned int chroot_count = 0;
for (pair_strings_vector::const_iterator it=root_dirs.begin();
it != root_dirs.end();
++it, ++chroot_count) {
if (chroot_count) {
result << ", ";
}
result << it->first;
}
if (chroot_count > 1) {
std::string result_str = result.str();
dprintf(D_FULLDEBUG, "Named chroots: %s\n", result_str.c_str() );
m_named_chroot = result_str;
}
}
if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) {
m_virt_mem = sysapi_swap_space();
dprintf( D_FULLDEBUG, "Swap space: %lu\n", m_virt_mem );
#if defined(WIN32)
credd_test();
#endif
}
if( IS_TIMEOUT(how_much) && IS_SHARED(how_much) ) {
m_load = sysapi_load_avg();
sysapi_idle_time( &m_idle, &m_console_idle );
time_t my_timer;
struct tm *the_time;
time( &my_timer );
the_time = localtime(&my_timer);
m_clock_min = (the_time->tm_hour * 60) + the_time->tm_min;
m_clock_day = the_time->tm_wday;
if (m_last_keypress < my_timer - m_idle) {
if (m_idle_interval >= 0) {
int duration = my_timer - m_last_keypress;
if (duration > m_idle_interval) {
if (m_seen_keypress) {
dprintf(D_IDLE, "end idle interval of %d sec.\n",
duration);
} else {
dprintf(D_IDLE,
"first keyboard event %d sec. after startup\n",
duration);
}
}
}
m_last_keypress = my_timer;
m_seen_keypress = true;
}
#ifdef WIN32
update_all_WinPerf_results();
#endif
AttribValue *pav = NULL;
m_lst_dynamic.Rewind();
while ((pav = m_lst_dynamic.Next()) ) {
if (pav) {
#ifdef WIN32
if ( ! update_WinPerf_Value(pav))
pav->vtype = AttribValue_DataType_Max; // undefined vtype
#else
if (pav->pquery) {
// insert code to update pav from pav->pquery
}
#endif
}
}
}
if( IS_TIMEOUT(how_much) && IS_SUMMED(how_much) ) {
m_condor_load = resmgr->sum( &Resource::condor_load );
if( m_condor_load > m_load ) {
m_condor_load = m_load;
}
}
}
int
cdbWriteBasicSymbol (symbol *sym, int isStructSym, int isFunc)
{
memmap *map;
symbol *sym2;
if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
fprintf (stderr, "cdbFile.c:cdbWriteBasicSymbol()\n");
if (!cdbFilePtr) return 0;
if (!sym) return 0;
/* WRITE HEADER, Function or Symbol */
if (isFunc)
fprintf (cdbFilePtr, "F:");
else
fprintf (cdbFilePtr, "S:");
/* STRUCTS do not have scope info.. */
if (!isStructSym)
{
if (sym->level && sym->localof) /* symbol is local */
{
fprintf (cdbFilePtr, "L%s.%s$", moduleName, sym->localof->name);
}
else if (IS_STATIC (sym->etype)) /* scope is file */
{
fprintf (cdbFilePtr, "F%s$", moduleName);
}
else /* scope is global */
{
fprintf (cdbFilePtr, "G$");
}
}
else
{
fprintf (cdbFilePtr, "S$"); /* scope is structure */
}
/* print the name, & mangled name */
fprintf (cdbFilePtr, "%s$%d$%d(", sym->name, sym->level, sym->block);
cdbTypeInfo (sym->type);
fprintf (cdbFilePtr, "),");
/* CHECK FOR REGISTER SYMBOL... */
if (!sym->allocreq && sym->reqv)
{
int a;
symbol *TempSym = OP_SYMBOL (sym->reqv);
if (!TempSym->isspilt || TempSym->remat)
{
fprintf (cdbFilePtr, "R,0,0,[");
for (a = 0; a < 4; a++)
{
if (TempSym->regs[a])
{
fprintf (cdbFilePtr, "%s%s", port->getRegName(TempSym->regs[a]),
((a < 3) && (TempSym->regs[a+1])) ? "," : "");
}
}
fprintf (cdbFilePtr, "]");
sym2 = NULL;
}
else
{
sym2 = TempSym->usl.spillLoc;
}
}
else
{
sym2 = sym;
}
if (sym2)
{
/* print the address space */
map = SPEC_OCLS (sym2->etype);
fprintf (cdbFilePtr, "%c,%d,%d",
(map ? map->dbName : 'Z'), sym2->onStack, SPEC_STAK (sym2->etype));
}
/* if assigned to registers then output register names */
/* if this is a function then print
if is it an interrupt routine & interrupt number
and the register bank it is using */
if (isFunc)
fprintf (cdbFilePtr, ",%d,%d,%d", FUNC_ISISR (sym->type),
FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
/* alternate location to find this symbol @ : eg registers
or spillocation */
if (!isStructSym)
fprintf (cdbFilePtr, "\n");
return 1;
}
