/*
* Fixup struct/unions depending on attributes.
*/
void
gcc_tcattrfix(NODE *p)
{
struct symtab *sp;
struct attr *ap;
int sz, coff, csz, al;
if ((ap = attr_find(p->n_ap, GCC_ATYP_PACKED)) == NULL)
return; /* nothing to fix */
al = ap->iarg(0);
/* Must repack struct */
coff = csz = 0;
for (sp = strmemb(ap); sp; sp = sp->snext) {
if (sp->sclass & FIELD)
sz = sp->sclass&FLDSIZ;
else
sz = (int)tsize(sp->stype, sp->sdf, sp->sap);
SETOFF(sz, al);
sp->soffset = coff;
coff += sz;
if (coff > csz)
csz = coff;
if (p->n_type == UNIONTY)
coff = 0;
}
SETOFF(csz, al); /* Roundup to whatever */
ap = attr_find(p->n_ap, ATTR_BASETYP);
ap->atypsz = csz;
ap->aalign = al;
}
/*
* AMD64 parameter classification.
*/
static int
argtyp(TWORD t, union dimfun *df, struct attr *ap)
{
int cl = 0;
if (t <= ULONG || ISPTR(t) || t == BOOL) {
cl = ngpr < 6 ? INTEGER : INTMEM;
} else if (t == FLOAT || t == DOUBLE || t == FIMAG || t == IMAG) {
cl = nsse < 8 ? SSE : SSEMEM;
} else if (t == LDOUBLE || t == LIMAG) {
cl = X87; /* XXX */
} else if (t == STRTY || t == UNIONTY) {
int sz = tsize(t, df, ap);
if (sz <= 2*SZLONG && attr_find(ap, ATTR_COMPLEX) != NULL) {
cl = nsse < 7 ? STRCPX : STRMEM;
} else if (sz > 2*SZLONG || ((sz+SZLONG)/SZLONG)+ngpr > 6 ||
attr_find(ap, GCC_ATYP_PACKED) != NULL)
cl = STRMEM;
else
cl = STRREG;
} else
cerror("FIXME: classify");
return cl;
}
/*
* The "initial exec" tls model.
*/
static NODE *
tlsinitialexec(NODE *p)
{
NODE *q, *r, *s;
char *s1, *s2;
/*
* movq %fs:0,%rax
* addq x@GOTTPOFF(%rip),%rax
*/
q = bcon(0);
q->n_type = STRTY;
s = ccopy(r = tempnode(0, INCREF(p->n_type), p->n_df, p->n_ap));
r = mkx("=r", r);
r = block(XASM, r, q, INT, 0, 0);
s1 = "movq %%fs:0,%0\n\taddq ";
s2 = "@GOTTPOFF(%%rip),%0";
if (attr_find(p->n_sp->sap, ATTR_SONAME) == NULL) {
p->n_sp->sap = attr_add(p->n_sp->sap, attr_new(ATTR_SONAME, 1));
p->n_sp->sap->sarg(0) = p->n_sp->sname;
}
r->n_name = mk3str(s1,
attr_find(p->n_sp->sap, ATTR_SONAME)->sarg(0), s2);
r = block(COMOP, r, s, INCREF(p->n_type), p->n_df, p->n_ap);
r = buildtree(UMUL, r, NIL);
tfree(p);
return r;
}
idattr_check_isuser (
Operation *op,
Entry *user,
AttributeDescription *searchAttr,
idattr_t *id)
{
int rc = LDAP_INSUFFICIENT_ACCESS;
Attribute *theAttr = NULL;
if (id->idattr_type == SELFWRITE_TYPE || id->idattr_type == OWNER_TYPE || id->idattr_type == USERS_TYPE) {
if ((op->o_conn->c_authz.c_sai_krb5_auth_data_provisioned && (id->idattr_type == OWNER_TYPE || id->idattr_type == USERS_TYPE))
|| (user != NULL)) {
rc = LDAP_SUCCESS;
} else {
rc = LDAP_INSUFFICIENT_ACCESS;
}
} else if (op->o_conn->c_authz.c_sai_krb5_auth_data_provisioned) {
if (ber_bvcmp(&op->o_conn->c_authz.c_sai_krb5_pac_id , &id->idattr_pat) == 0) {
rc = LDAP_SUCCESS;
} else {
rc = LDAP_INSUFFICIENT_ACCESS;
}
} else {
theAttr = attr_find( user->e_attrs, searchAttr);
if ( !theAttr || !BER_BVISNULL( &theAttr->a_nvals[ 1 ] ) ) {
rc = LDAP_NO_SUCH_ATTRIBUTE;
} else {
// check user match
rc = value_find_ex( searchAttr,
SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
theAttr->a_nvals, &(id->idattr_pat),
op->o_tmpmemctx );
Debug( LDAP_DEBUG_ACL, "#####idattr_check_isuser <Find By ID> value_find_ex [%d]#####\n", rc, 0, 0);
#ifdef PAC_PROXY_USERS
if (rc != LDAP_SUCCESS) {
theAttr = attr_find( user->e_attrs, idattr_memberships);
if ( !theAttr || !BER_BVISNULL( &theAttr->a_nvals[ 1 ] ) ) {
rc = LDAP_NO_SUCH_ATTRIBUTE;
} else {
rc = value_find_ex( idattr_memberships,
SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
theAttr->a_nvals, &(id->idattr_pat),
op->o_tmpmemctx );
Debug( LDAP_DEBUG_ACL, "#####idattr_check_isuser <Find By GROUP ID> value_find_ex [%d]#####\n", rc, 0, 0);
}
}
#endif
}
}
return rc;
}
CK_RV attr_find2(CK_ATTRIBUTE_PTR pTemp1, CK_ULONG ulCount1,
CK_ATTRIBUTE_PTR pTemp2, CK_ULONG ulCount2, CK_ULONG type, void *ptr, size_t * sizep)
{
CK_RV rv;
rv = attr_find(pTemp1, ulCount1, type, ptr, sizep);
if (rv != CKR_OK)
rv = attr_find(pTemp2, ulCount2, type, ptr, sizep);
return rv;
}
static void
mdb_modify_idxflags(
Operation *op,
AttributeDescription *desc,
int got_delete,
Attribute *newattrs,
Attribute *oldattrs )
{
struct berval ix_at;
AttrInfo *ai;
/* check if modified attribute was indexed
* but not in case of NOOP... */
ai = mdb_index_mask( op->o_bd, desc, &ix_at );
if ( ai ) {
if ( got_delete ) {
Attribute *ap;
struct berval ix2;
ap = attr_find( oldattrs, desc );
if ( ap ) ap->a_flags |= SLAP_ATTR_IXDEL;
/* ITS#8678 FIXME
* If using 32bit hashes, or substring index, must account for
* possible index collisions. If no substring index, and using
* 64bit hashes, assume we don't need to check for collisions.
*
* In 2.5 use refcounts and avoid all of this mess.
*/
/* FIXME: use t1ha2_64() */
#ifdef LUTIL_HASH64_BYTES
const int hash32width = !slap_hash64(-1);
#else
const int hash32width = 1;
#endif
if (hash32width || (ai->ai_indexmask & SLAP_INDEX_SUBSTR)) {
/* Find all other attrs that index to same slot */
for ( ap = newattrs; ap; ap = ap->a_next ) {
ai = mdb_index_mask( op->o_bd, ap->a_desc, &ix2 );
if ( ai && ix2.bv_val == ix_at.bv_val )
ap->a_flags |= SLAP_ATTR_IXADD;
}
}
} else {
Attribute *ap;
ap = attr_find( newattrs, desc );
if ( ap ) ap->a_flags |= SLAP_ATTR_IXADD;
}
}
}
static int
ldap_back_monitor_update(
Operation *op,
SlapReply *rs,
Entry *e,
void *priv )
{
ldapinfo_t *li = (ldapinfo_t *)priv;
Attribute *a;
/* update olmDbURIList */
a = attr_find( e->e_attrs, ad_olmDbURIList );
if ( a != NULL ) {
struct berval bv;
assert( a->a_vals != NULL );
assert( !BER_BVISNULL( &a->a_vals[ 0 ] ) );
assert( BER_BVISNULL( &a->a_vals[ 1 ] ) );
ldap_pvt_thread_mutex_lock( &li->li_uri_mutex );
if ( li->li_uri ) {
ber_str2bv( li->li_uri, 0, 0, &bv );
if ( !bvmatch( &a->a_vals[ 0 ], &bv ) ) {
ber_bvreplace( &a->a_vals[ 0 ], &bv );
}
}
ldap_pvt_thread_mutex_unlock( &li->li_uri_mutex );
}
return SLAP_CB_CONTINUE;
}
int
monitor_subsys_thread_update(
struct monitorinfo *mi,
Entry *e
)
{
Attribute *a;
struct berval bv[2], *b = NULL;
char buf[1024];
bv[1].bv_val = NULL;
snprintf( buf, sizeof( buf ), "backload=%d",
ldap_pvt_thread_pool_backload( &connection_pool ) );
if ( ( a = attr_find( e->e_attrs, monitor_ad_desc ) ) != NULL ) {
for ( b = a->a_vals; b[0].bv_val != NULL; b++ ) {
if ( strncmp( b[0].bv_val, "backload=",
sizeof( "backload=" ) - 1 ) == 0 ) {
free( b[0].bv_val );
ber_str2bv( buf, 0, 1, &b[0] );
break;
}
}
}
if ( b == NULL || b[0].bv_val == NULL ) {
bv[0].bv_val = buf;
bv[0].bv_len = strlen( buf );
attr_merge( e, monitor_ad_desc, bv );
}
return( 0 );
}
/*
* Create a reference for an extern variable.
*/
static NODE *
picext(NODE *p)
{
NODE *q, *r;
struct symtab *sp;
char *name;
q = tempnode(gotnr, PTR|VOID, 0, 0);
name = getexname(p->n_sp);
#ifdef notdef
struct attr *ga;
if ((ga = attr_find(p->n_sp->sap, GCC_ATYP_VISIBILITY)) &&
strcmp(ga->sarg(0), "hidden") == 0) {
/* For hidden vars use GOTOFF */
sp = picsymtab("", name, "@GOTOFF");
r = xbcon(0, sp, INT);
q = buildtree(PLUS, q, r);
q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
q->n_sp = p->n_sp; /* for init */
nfree(p);
return q;
}
#endif
sp = picsymtab("", name, "@GOT");
r = xbcon(0, sp, INT);
q = buildtree(PLUS, q, r);
q = block(UMUL, q, 0, PTR|VOID, 0, 0);
q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
q->n_sp = p->n_sp; /* for init */
nfree(p);
return q;
}
/* Read the old USN from the underlying DB. This code is
* stolen from the syncprov overlay.
*/
static int
usn_db_open(
BackendDB *be,
ConfigReply *cr)
{
slap_overinst *on = (slap_overinst *) be->bd_info;
usn_info_t *ui = (usn_info_t *)on->on_bi.bi_private;
Connection conn = { 0 };
OperationBuffer opbuf;
Operation *op;
Entry *e = NULL;
Attribute *a;
int rc;
void *thrctx = NULL;
thrctx = ldap_pvt_thread_pool_context();
connection_fake_init( &conn, &opbuf, thrctx );
op = &opbuf.ob_op;
op->o_bd = be;
op->o_dn = be->be_rootdn;
op->o_ndn = be->be_rootndn;
rc = overlay_entry_get_ov( op, be->be_nsuffix, NULL,
slap_schema.si_ad_contextCSN, 0, &e, on );
if ( e ) {
a = attr_find( e->e_attrs, ad_usnChanged );
if ( a ) {
ui->ui_current = atoi( a->a_vals[0].bv_val );
}
overlay_entry_release_ov( op, e, 0, on );
}
return 0;
}
static char *
getsoname(struct symtab *sp)
{
struct attr *ap;
return (ap = attr_find(sp->sap, ATTR_SONAME)) ?
ap->sarg(0) : sp->sname;
}
int
monitor_back_operational(
Operation *op,
SlapReply *rs )
{
Attribute **ap;
assert( rs->sr_entry != NULL );
for ( ap = &rs->sr_operational_attrs; *ap; ap = &(*ap)->a_next ) {
if ( (*ap)->a_desc == slap_schema.si_ad_hasSubordinates ) {
break;
}
}
if ( *ap == NULL &&
attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_hasSubordinates ) == NULL &&
( SLAP_OPATTRS( rs->sr_attr_flags ) ||
ad_inlist( slap_schema.si_ad_hasSubordinates, rs->sr_attrs ) ) )
{
int hs;
monitor_entry_t *mp;
mp = ( monitor_entry_t * )rs->sr_entry->e_private;
assert( mp != NULL );
hs = MONITOR_HAS_CHILDREN( mp );
*ap = slap_operational_hasSubordinate( hs );
assert( *ap != NULL );
ap = &(*ap)->a_next;
}
return LDAP_SUCCESS;
}
/*
* sets the supported operational attributes (if required)
*/
int
wt_operational(
Operation *op,
SlapReply *rs )
{
Attribute **ap;
assert( rs->sr_entry != NULL );
for ( ap = &rs->sr_operational_attrs; *ap; ap = &(*ap)->a_next ) {
if ( (*ap)->a_desc == slap_schema.si_ad_hasSubordinates ) {
break;
}
}
if ( *ap == NULL &&
attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_hasSubordinates ) == NULL &&
( SLAP_OPATTRS( rs->sr_attr_flags ) ||
ad_inlist( slap_schema.si_ad_hasSubordinates, rs->sr_attrs ) ) )
{
int hasSubordinates, rc;
rc = wt_hasSubordinates( op, rs->sr_entry, &hasSubordinates );
if ( rc == LDAP_SUCCESS ) {
*ap = slap_operational_hasSubordinate( hasSubordinates == LDAP_COMPARE_TRUE );
assert( *ap != NULL );
ap = &(*ap)->a_next;
}
}
return LDAP_SUCCESS;
}
static const char *room_attr_get(struct room *r, const char *name) {
static char numbuf[22]; /* big enough for a signed 64-bit decimal */
if(!strcasecmp("id", name)) {
snprintf(numbuf, sizeof numbuf, "%u", r->id);
return numbuf;
} else if(!strcasecmp("name.short", name))
return r->name.short_str;
else if(!strcasecmp("name.long", name))
return r->name.long_str;
else if(!strcasecmp("desc.short", name))
return r->desc.short_str;
else if(!strcasecmp("desc.long", name))
return r->desc.long_str;
else if(!strcasecmp("creator", name))
return r->creator;
else if(!strcasecmp("owner", name))
return r->owner;
else {
struct attr_entry *at;
at=attr_find(&r->extra_values, name);
if(at) return at->value;
}
return NULL; /* failure - not found. */
}
/*
* Create a reference for an extern variable or function.
*/
static NODE *
picext(NODE *p)
{
#if defined(ELFABI)
NODE *q;
struct symtab *sp;
char *c;
if (p->n_sp->sflags & SBEENHERE)
return p;
#ifdef GCC_COMPAT
struct attr *ga;
if ((ga = attr_find(p->n_sp->sap, GCC_ATYP_VISIBILITY)) &&
strcmp(ga->sarg(0), "hidden") == 0)
return p; /* no GOT reference */
#endif
c = getexname(p->n_sp);
sp = picsymtab("", c, "@GOTPCREL");
sp->sflags |= SBEENHERE;
q = block(NAME, NIL, NIL, INCREF(p->n_type), p->n_df, p->n_ap);
q->n_sp = sp;
q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
q->n_sp = sp;
nfree(p);
return q;
#elif defined(MACHOABI)
return p;
#endif
}
static int
argsiz(NODE *p)
{
TWORD t;
int size = 0;
int sz = 0;
if (p->n_op == CM) {
size = argsiz(p->n_left);
p = p->n_right;
}
t = p->n_type;
if (t < LONGLONG || t > BTMASK)
sz = 4;
else if (DEUNSIGN(t) == LONGLONG)
sz = 8;
else if (t == DOUBLE || t == LDOUBLE)
sz = 8;
else if (t == FLOAT)
sz = 4;
else if (t == STRTY || t == UNIONTY)
sz = attr_find(p->n_ap, ATTR_P2STRUCT)->iarg(0);
if (p->n_type == STRTY || p->n_type == UNIONTY) {
return (size + sz);
}
/* alignment */
if (sz == 8 && (size & 7) != 0)
sz += 4;
// printf("size=%d, sz=%d -> %d\n", size, sz, size + sz);
return (size + sz);
}
/*
* Called when a identifier has been declared.
*/
void
fixdef(struct symtab *sp)
{
struct attr *ga;
#ifdef HAVE_WEAKREF
/* not many as'es have this directive */
if ((ga = attr_find(sp->sap, GCC_ATYP_WEAKREF)) != NULL) {
char *wr = ga->sarg(0);
char *sn = getsoname(sp);
if (wr == NULL) {
if ((ga = attr_find(sp->sap, GCC_ATYP_ALIAS))) {
wr = ga->sarg(0);
}
}
if (wr == NULL)
printf("\t.weak %s\n", sn);
else
printf("\t.weakref %s,%s\n", sn, wr);
} else
if ((ga = attr_find(sp->sap, GCC_ATYP_ALIAS)) != NULL) {
char *an = ga->sarg(0);
char *sn = getsoname(sp);
char *v;
v = attr_find(sp->sap, GCC_ATYP_WEAK) ? "weak" : "globl";
printf("\t.%s %s\n", v, sn);
printf("\t.set %s,%s\n", sn, an);
}
if (alias != NULL && (sp->sclass != PARAM)) {
char *name = getexname(sp);
printf("\t.globl %s\n", name);
printf("%s = ", name);
printf("%s\n", exname(alias));
alias = NULL;
}
if ((constructor || destructor) && (sp->sclass != PARAM)) {
NODE *p = p1alloc();
p->n_op = NAME;
p->n_sp =
(struct symtab *)(constructor ? "constructor" : "destructor");
sp->sap = attr_add(sp->sap, gcc_attr_parse(p));
constructor = destructor = 0;
}
#endif
}
/*
* Create a reference for a TLS variable.
* This is the "General dynamic" version.
*/
static NODE *
tlspic(NODE *p)
{
NODE *q, *r, *s;
char *s1, *s2;
/*
* .byte 0x66
* leaq x@TLSGD(%rip),%rdi
* .word 0x6666
* rex64
* call __tls_get_addr@PLT
*/
/* Need the .byte stuff around. Why? */
/* Use inline assembler */
q = mkx("%rdx", bcon(0));
q = cmop(q, mkx("%rcx", bcon(0)));
q = cmop(q, mkx("%rsi", bcon(0)));
q = cmop(q, mkx("%rdi", bcon(0)));
q = cmop(q, mkx("%r8", bcon(0)));
q = cmop(q, mkx("%r9", bcon(0)));
q = cmop(q, mkx("%r10", bcon(0)));
q = cmop(q, mkx("%r11", bcon(0)));
s = ccopy(r = tempnode(0, INCREF(p->n_type), p->n_df, p->n_ap));
r = mkx("=a", r);
r = block(XASM, r, q, INT, 0, 0);
/* Create the magic string */
s1 = ".byte 0x66\n\tleaq ";
s2 = "@TLSGD(%%rip),%%rdi\n"
"\t.word 0x6666\n\trex64\n\tcall __tls_get_addr@PLT";
if (attr_find(p->n_sp->sap, ATTR_SONAME) == NULL) {
p->n_sp->sap = attr_add(p->n_sp->sap, attr_new(ATTR_SONAME, 1));
p->n_sp->sap->sarg(0) = p->n_sp->sname;
}
r->n_name = addstring(mk3str(s1,
attr_find(p->n_sp->sap, ATTR_SONAME)->sarg(0), s2));
r = block(COMOP, r, s, INCREF(p->n_type), p->n_df, p->n_ap);
r = buildtree(UMUL, r, NIL);
tfree(p);
return r;
}
static unsigned
constraint_count_attr(Entry *e, AttributeDescription *ad)
{
struct Attribute *a;
if ((a = attr_find(e->e_attrs, ad)) != NULL)
return a->a_numvals;
return 0;
}
/*
* Fixup struct/unions depending on attributes.
*/
void
gcc_tcattrfix(NODE *p)
{
struct symtab *sp;
struct attr *ap;
int sz, coff, csz, al, oal, mxal;
if (!ISSOU(p->n_type)) /* only for structs or unions */
return;
if ((ap = attr_find(p->n_ap, GCC_ATYP_PACKED)) == NULL)
return; /* nothing to fix */
al = ap->iarg(0);
mxal = 0;
/* Must repack struct */
coff = csz = 0;
for (sp = strmemb(ap); sp; sp = sp->snext) {
oal = talign(sp->stype, sp->sap);
if (oal > al)
oal = al;
if (mxal < oal)
mxal = oal;
if (sp->sclass & FIELD)
sz = sp->sclass&FLDSIZ;
else
sz = (int)tsize(sp->stype, sp->sdf, sp->sap);
sp->soffset = upoff(sz, oal, &coff);
if (coff > csz)
csz = coff;
if (p->n_type == UNIONTY)
coff = 0;
}
if (mxal < ALCHAR)
mxal = ALCHAR; /* for bitfields */
SETOFF(csz, mxal); /* Roundup to whatever */
ap = attr_find(p->n_ap, ATTR_STRUCT);
ap->amsize = csz;
ap = attr_find(p->n_ap, ATTR_ALIGNED);
ap->iarg(0) = mxal;
}
BerVarray get_entry_referrals(
Operation *op,
Entry *e )
{
Attribute *attr;
BerVarray refs;
unsigned i;
struct berval *iv, *jv;
AttributeDescription *ad_ref = slap_schema.si_ad_ref;
attr = attr_find( e->e_attrs, ad_ref );
if( attr == NULL ) return NULL;
for( i=0; attr->a_vals[i].bv_val != NULL; i++ ) {
/* count references */
}
if( i < 1 ) return NULL;
refs = ch_malloc( (i + 1) * sizeof(struct berval));
for( iv=attr->a_vals, jv=refs; iv->bv_val != NULL; iv++ ) {
unsigned k;
ber_dupbv( jv, iv );
/* trim the label */
for( k=0; k<jv->bv_len; k++ ) {
if( isspace( (unsigned char) jv->bv_val[k] ) ) {
jv->bv_val[k] = '\0';
jv->bv_len = k;
break;
}
}
if( jv->bv_len > 0 ) {
jv++;
} else {
free( jv->bv_val );
}
}
if( jv == refs ) {
free( refs );
refs = NULL;
} else {
jv->bv_val = NULL;
}
/* we should check that a referral value exists... */
return refs;
}
static int
monitor_subsys_conn_update(
Operation *op,
SlapReply *rs,
Entry *e )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
long n = -1;
static struct berval total_bv = BER_BVC( "cn=total" ),
current_bv = BER_BVC( "cn=current" );
struct berval rdn;
assert( mi != NULL );
assert( e != NULL );
dnRdn( &e->e_nname, &rdn );
if ( dn_match( &rdn, &total_bv ) ) {
n = connections_nextid();
} else if ( dn_match( &rdn, ¤t_bv ) ) {
Connection *c;
ber_socket_t connindex;
for ( n = 0, c = connection_first( &connindex );
c != NULL;
n++, c = connection_next( c, &connindex ) )
{
/* No Op */ ;
}
connection_done( c );
}
if ( n != -1 ) {
Attribute *a;
char buf[LDAP_PVT_INTTYPE_CHARS(long)];
ber_len_t len;
a = attr_find( e->e_attrs, mi->mi_ad_monitorCounter );
if ( a == NULL ) {
return( -1 );
}
snprintf( buf, sizeof( buf ), "%ld", n );
len = strlen( buf );
if ( len > a->a_vals[ 0 ].bv_len ) {
a->a_vals[ 0 ].bv_val = ber_memrealloc( a->a_vals[ 0 ].bv_val, len + 1 );
}
a->a_vals[ 0 ].bv_len = len;
memcpy( a->a_vals[ 0 ].bv_val, buf, len + 1 );
/* FIXME: touch modifyTimestamp? */
}
/*
* Print out variable attributes.
*/
void
varattrib(char *name, struct attr *sap)
{
extern char *nextsect;
struct attr *ga;
if ((ga = attr_find(sap, GCC_ATYP_SECTION)) != NULL)
nextsect = ga->sarg(0);
if ((ga = attr_find(sap, GCC_ATYP_WEAK)) != NULL)
printf(" .weak %s\n", name);
if (attr_find(sap, GCC_ATYP_DESTRUCTOR)) {
printf("\t.section\t.dtors,\"aw\",@progbits\n");
printf("\t.align 8\n\t.quad\t%s\n", name);
lastloc = -1;
}
if (attr_find(sap, GCC_ATYP_CONSTRUCTOR)) {
printf("\t.section\t.ctors,\"aw\",@progbits\n");
printf("\t.align 8\n\t.quad\t%s\n", name);
lastloc = -1;
}
if ((ga = attr_find(sap, GCC_ATYP_VISIBILITY)) &&
strcmp(ga->sarg(0), "default"))
printf("\t.%s %s\n", ga->sarg(0), name);
if ((ga = attr_find(sap, GCC_ATYP_ALIASWEAK))) {
printf(" .weak %s\n", ga->sarg(0));
printf(" .set %s,%s\n", ga->sarg(0), name);
}
}
static int
pguid_op_rename( Operation *op, SlapReply *rs )
{
slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
Entry *e = NULL;
Attribute *a;
int rc;
if ( op->orr_nnewSup == NULL ) {
return SLAP_CB_CONTINUE;
}
rc = overlay_entry_get_ov( op, op->orr_nnewSup, NULL, slap_schema.si_ad_entryUUID, 0, &e, on );
if ( rc != LDAP_SUCCESS || e == NULL ) {
Debug( LDAP_DEBUG_ANY, "%s: pguid_op_rename: unable to get newSuperior entry DN=\"%s\" (%d)\n",
op->o_log_prefix, op->orr_newSup->bv_val, rc );
return SLAP_CB_CONTINUE;
}
a = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID );
if ( a == NULL ) {
Debug( LDAP_DEBUG_ANY, "%s: pguid_op_rename: unable to find entryUUID of newSuperior entry DN=\"%s\" (%d)\n",
op->o_log_prefix, op->orr_newSup->bv_val, rc );
} else {
Modifications *mod;
assert( a->a_numvals == 1 );
mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
mod->sml_flags = SLAP_MOD_INTERNAL;
mod->sml_op = LDAP_MOD_REPLACE;
mod->sml_desc = ad_parentUUID;
mod->sml_type = ad_parentUUID->ad_cname;
mod->sml_values = ch_malloc( sizeof( struct berval ) * 2 );
mod->sml_nvalues = NULL;
mod->sml_numvals = 1;
ber_dupbv( &mod->sml_values[0], &a->a_vals[0] );
BER_BVZERO( &mod->sml_values[1] );
mod->sml_next = op->orr_modlist;
op->orr_modlist = mod;
}
if ( e != NULL ) {
(void)overlay_entry_release_ov( op, e, 0, on );
}
return SLAP_CB_CONTINUE;
}
/*
* Push a structure on stack as argument.
* the scratch registers are already free here
*/
static void
starg(NODE *p)
{
struct attr *ap;
NODE *q = p->n_left;
ap = attr_find(p->n_ap, ATTR_P2STRUCT);
printf(" subl $%d,%%esp\n", (ap->iarg(0) + 3) & ~3);
p->n_left = mklnode(OREG, 0, ESP, INT);
zzzcode(p, 'Q');
tfree(p->n_left);
p->n_left = q;
}
static int
vernum_op_add( Operation *op, SlapReply *rs )
{
slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
vernum_t *vn = (vernum_t *)on->on_bi.bi_private;
Attribute *a, **ap;
int rc;
/* NOTE: should we accept an entry still in mods format? */
assert( op->ora_e != NULL );
if ( BER_BVISEMPTY( &op->ora_e->e_nname ) ) {
return SLAP_CB_CONTINUE;
}
a = attr_find( op->ora_e->e_attrs, vn->vn_attr );
if ( a == NULL ) {
return SLAP_CB_CONTINUE;
}
if ( attr_find( op->ora_e->e_attrs, vn->vn_vernum ) != NULL ) {
/* already present - leave it alone */
return SLAP_CB_CONTINUE;
}
a = attr_alloc( vn->vn_vernum );
value_add_one( &a->a_vals, &val_init );
a->a_nvals = a->a_vals;
a->a_numvals = 1;
for ( ap = &op->ora_e->e_attrs; *ap != NULL; ap = &(*ap)->a_next )
/* goto tail */ ;
*ap = a;
return SLAP_CB_CONTINUE;
}
/*
* Return ap if this node is a TI node, else NULL.
*/
struct attr *
isti(NODE *p)
{
struct attr *ap;
if (p->n_type != STRTY)
return NULL;
if ((ap = attr_find(p->n_ap, GCC_ATYP_MODE)) == NULL)
return NULL;
if (strcmp(ap->sarg(0), TISTR))
return NULL;
return ap;
}
/*
* Check if we may have to do a cast to/from TI.
*/
NODE *
gcc_eval_ticast(int op, NODE *p1, NODE *p2)
{
struct attr *a1, *a2;
int t;
a2 = NULL; /* XXX flow analysis */
if ((a1 = isti(p1)) == NULL && (a2 = isti(p2)) == NULL)
return NIL;
if (op == RETURN)
p1 = p1tcopy(p1);
if (a1 == NULL) {
if (a2 == NULL)
cerror("gcc_eval_ticast error");
switch (p1->n_type) {
case LDOUBLE:
p2 = doacall(floatuntixfsp,
nametree(floatuntixfsp), p2);
tfree(p1);
break;
case ULONG:
case LONG:
p2 = cast(structref(p2, DOT, loti), p1->n_type, 0);
tfree(p1);
break;
case VOID:
return NIL;
default:
uerror("gcc_eval_ticast: %d", p1->n_type);
}
return p2;
}
/* p2 can be anything, but we must cast it to p1 */
t = a1->iarg(1);
if (p2->n_type == STRTY &&
(a2 = attr_find(p2->n_ap, GCC_ATYP_MODE)) &&
strcmp(a2->sarg(0), TISTR) == 0) {
/* Already TI, just add extra mode bits */
a2 = attr_new(GCC_ATYP_MODE, 3);
a2->sarg(0) = TISTR;
a2->iarg(1) = t;
p2->n_ap = attr_add(p2->n_ap, a2);
} else {
p2 = ticast(p2, t);
}
tfree(p1);
return p2;
}
static int
usn_operational(
Operation *op,
SlapReply *rs )
{
slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
usn_info_t *ui = (usn_info_t *)on->on_bi.bi_private;
if ( rs->sr_entry &&
dn_match( &rs->sr_entry->e_nname, op->o_bd->be_nsuffix )) {
if ( SLAP_OPATTRS( rs->sr_attr_flags ) ||
ad_inlist( ad_usnChanged, rs->sr_attrs )) {
Attribute *a, **ap = NULL;
char intbuf[64];
struct berval bv;
int my_usn;
for ( a=rs->sr_entry->e_attrs; a; a=a->a_next ) {
if ( a->a_desc == ad_usnChanged )
break;
}
if ( !a ) {
for ( ap = &rs->sr_operational_attrs; *ap;
ap=&(*ap)->a_next );
a = attr_alloc( ad_usnChanged );
*ap = a;
}
if ( !ap ) {
if ( rs_entry2modifiable( op,rs, on )) {
a = attr_find( rs->sr_entry->e_attrs,
ad_usnChanged );
}
ber_bvarray_free( a->a_vals );
a->a_vals = NULL;
a->a_numvals = 0;
}
ldap_pvt_thread_mutex_lock( &ui->ui_mutex );
my_usn = ui->ui_current;
ldap_pvt_thread_mutex_unlock( &ui->ui_mutex );
bv.bv_len = snprintf( intbuf, sizeof(intbuf), "%d", my_usn );
bv.bv_val = intbuf;
attr_valadd( a, &bv, NULL, 1 );
}
}
return SLAP_CB_CONTINUE;
}
/*
* Push a structure on stack as argument.
*/
static void
starg(NODE *p)
{
int sz = attr_find(p->n_ap, ATTR_P2STRUCT)->iarg(0);
//assert(p->n_rval == A1);
printf("\tsubu %s,%s,%d\n", rnames[SP], rnames[SP], sz);
/* A0 = dest, A1 = src, A2 = len */
printf("\tmove %s,%s\n", rnames[A0], rnames[SP]);
printf("\tli %s,%d\t# structure size\n", rnames[A2], sz);
printf("\tsubu %s,%s,16\n", rnames[SP], rnames[SP]);
printf("\tjal %s\t# structure copy\n", exname("memcpy"));
printf("\tnop\n");
printf("\taddiu %s,%s,16\n", rnames[SP], rnames[SP]);
}