void run_pipeline() {
if(Register::cycle == 59) {
printf("in main before WB ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
WB();
if(Register::cycle == 59) {
printf("in main before DM ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
DM();
if(Register::cycle == 59) {
printf("in main before EX ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
EX();
if(Register::cycle == 59) {
printf("in main before ID ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
ID();
if(Register::cycle == 59) {
printf("in main before IF ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
IF();
if(Register::cycle == 59) {
printf("in main after IF ID_EX.$rt_out = %d\n", ID_EX.$rt_out);
}
}
// This is always safe. We must /not/ use WBRC_NULL here, only the full WBRC functions that
// take the gc and container explicitly will be safe. See bugzilla 525875.
void HeapMultiname::setMultiname(MMgc::GC* gc, const void* container, const Multiname& that)
{
WBRC(gc, container, &name.name, that.name);
bool const this_nsset = name.isNsset() != 0;
bool const that_nsset = that.isNsset() != 0;
if (this_nsset != that_nsset)
{
// gc->rc or vice versa... we have to explicitly null out
// any existing value (before setting a new one) because WB/WBRC
// assume any existing value is a GCObject/RCObject respectively.
if (this_nsset)
WB_NULL(&name.ns); // WB_NULL is safe
else
WBRC(gc, container, &name.ns, NULL); // DO NOT USE WBRC_NULL
}
if (that_nsset)
{
WB(gc, container, &name.nsset, that.nsset);
}
else
{
WBRC(gc, container, &name.ns, that.ns);
}
name.flags = that.flags;
name.next_index = that.next_index;
}
int ccdl::ConstrainedWeightedLeastSquaresFit
( int const nobs, int const nparam,
double const * A_obs_by_param,
double * x_param,
double const * b_obs,
double const * w_obs,
int const ncon,
double const * D_con_by_param,
double const * c_con )
{
std::vector<double> sqrtw( w_obs, w_obs + nobs );
for ( int i=0; i<nobs; ++i )
if ( w_obs[i] > 1.e-14 )
sqrtw[i] = std::sqrt( w_obs[i] );
std::vector<double> WA( A_obs_by_param, A_obs_by_param + nparam*nobs );
for ( int j=0; j<nparam; ++j )
for ( int i=0; i<nobs; ++i )
WA[i+j*nobs] *= sqrtw[i];
std::vector<double> WB( b_obs, b_obs + nobs );
for ( int i=0; i<nobs; ++i )
WB[i] *= sqrtw[i];
return ccdl::ConstrainedLeastSquaresFit
( nobs, nparam, WA.data(), x_param, WB.data(),
ncon, D_con_by_param, c_con );
/*
// min (xt.At-bt).W.(A.x-b) s.t. D.x = c
std::vector<double> WA( A_obs_by_param, A_obs_by_param + nparam*nobs );
for ( int j=0; j<nparam; ++j )
for ( int i=0; i<nobs; ++i )
WA[i+j*nobs] *= w_obs[i];
std::vector<double> AtWtb( nparam, 0. );
double alpha = 1.;
double beta = 0.;
int inc = 1;
dgemv_( "T", &nobs, &nparam, &alpha,
WA.data(), &nobs, b_obs, &inc, &beta, AtWtb.data(), &inc );
std::vector<double> AtWtA( nparam*nparam, 0. );
dgemm_( "T","N", &nparam, &nparam, &nobs, &alpha,
WA.data(), &nobs, A_obs_by_param, &nobs, &beta, AtWtA.data(), &nparam );
return ccdl::ConstrainedLeastSquaresFit
( nparam, nparam, AtWtA.data(), x_param, AtWtb.data(),
ncon, D_con_by_param, c_con );
*/
}
void DictionaryObject::init(bool weakKeys)
{
GCAssert(vtable->traits->isDictionary());
MMgc::GC* gc = this->gc();
HeapHashtable* ht = weakKeys ? WeakKeyHashtable::create(gc) : HeapHashtable::create(gc);
//store pointer of newly created hashtable, encapsulated with writebarrier,
//at the hashtable offset address of the corresponding traits
union {
uint8_t* p;
HeapHashtable** hht;
};
p = (uint8_t*)this + vtable->traits->getHashtableOffset();
WB(gc, this, hht, ht);
}
void WordcodeEmitter::computeExceptionFixups()
{
if (info == NULL || info->exceptions == NULL)
return;
DELETE_LIST(catch_info, exception_fixes);
ExceptionHandlerTable* old_table = info->exceptions;
int exception_count = old_table->exception_count;
size_t extra = sizeof(ExceptionHandler)*(exception_count - 1);
ExceptionHandlerTable* new_table = new (core->GetGC(), extra) ExceptionHandlerTable(exception_count);
// Insert items in the exn list for from, to, and target, with the pc pointing
// to the correct triggering instruction in the ABC and the update loc
// pointing to the location to be patched; and a flag is_int_offset (if false
// it's a intptr_t).
for ( int i=0 ; i < exception_count ; i++ ) {
new_table->exceptions[i].traits = old_table->exceptions[i].traits;
new_table->exceptions[i].scopeTraits = old_table->exceptions[i].scopeTraits;
catch_info* p[3];
p[0] = new catch_info;
p[0]->pc = code_start + info->exceptions->exceptions[i].from;
p[0]->is_target = false;
p[0]->fixup_loc = (void*)&(new_table->exceptions[i].from);
p[1] = new catch_info;
p[1]->pc = code_start + info->exceptions->exceptions[i].to;
p[1]->is_target = false;
p[1]->fixup_loc = (void*)&(new_table->exceptions[i].to);
p[2] = new catch_info;
p[2]->pc = code_start + info->exceptions->exceptions[i].target;
p[2]->is_target = true;
p[2]->fixup_loc = (void*)&(new_table->exceptions[i].target);
if (p[0]->pc > p[1]->pc) {
catch_info* tmp = p[0];
p[0] = p[1];
p[1] = tmp;
}
if (p[1]->pc > p[2]->pc) {
catch_info* tmp = p[1];
p[1] = p[2];
p[2] = tmp;
}
if (p[0]->pc > p[1]->pc) {
catch_info* tmp = p[0];
p[0] = p[1];
p[1] = tmp;
}
int j=0;
catch_info* e = exception_fixes;
catch_info* ee = NULL;
while (j < 3 && e != NULL) {
if (e->pc > p[j]->pc) {
if (ee == NULL)
exception_fixes = p[j];
else
ee->next = p[j];
p[j]->next = e;
e = p[j];
j++;
}
else {
ee = e;
e = e->next;
}
}
while (j < 3) {
if (ee == NULL)
exception_fixes = p[j];
else
ee->next = p[j];
p[j]->next = e;
ee = p[j];
j++;
}
}
WB(core->GetGC(), info, &info->word_code.exceptions, new_table);
#ifdef _DEBUG
if (exception_fixes != NULL) {
catch_info* ee = exception_fixes;
catch_info* e = ee->next;
AvmAssert(ee->pc <= e->pc);
ee = e;
e = e->next;
}
#endif
}
int ccdl::WeightedLeastSquaresFit
( int const nobs, int const nparam,
double const * A_obs_by_param,
double * x_param,
double const * b_obs,
double const * w_obs,
double relative_accuracy_of_the_obs )
{
std::vector<double> sqrtw( w_obs, w_obs + nobs );
for ( int i=0; i<nobs; ++i )
if ( w_obs[i] > 1.e-14 )
sqrtw[i] = std::sqrt( w_obs[i] );
std::vector<double> WA( A_obs_by_param, A_obs_by_param + nparam*nobs );
for ( int j=0; j<nparam; ++j )
for ( int i=0; i<nobs; ++i )
WA[i+j*nobs] *= sqrtw[i];
std::vector<double> WB( b_obs, b_obs + nobs );
for ( int i=0; i<nobs; ++i )
WB[i] *= sqrtw[i];
return ccdl::LeastSquaresFit
( nobs, nparam, WA.data(), x_param, WB.data(),
relative_accuracy_of_the_obs );
/*
// min (xt.At-bt).W.(A.x-b)
// At.W.A.x = At.W.b
// A'.x = b'
// A' = At.W.A
// b' = At.W.b
std::vector<double> WA( A_obs_by_param, A_obs_by_param + nparam*nobs );
for ( int j=0; j<nparam; ++j )
for ( int i=0; i<nobs; ++i )
WA[i+j*nobs] *= w_obs[i];
std::vector<double> AtWtb( nparam, 0. );
double alpha = 1.;
double beta = 0.;
int inc = 1;
dgemv_( "T", &nobs, &nparam, &alpha,
WA.data(), &nobs, b_obs, &inc, &beta, AtWtb.data(), &inc );
std::vector<double> AtWtA( nparam*nparam, 0. );
dgemm_( "T","N", &nparam, &nparam, &nobs, &alpha,
WA.data(), &nobs, A_obs_by_param, &nobs, &beta, AtWtA.data(), &nparam );
int INFO = 0;
{
std::vector<int> ipiv( nparam, 0 );
int LWORK = -1;
dsysv_("U",&nparam,&inc,AtWtA.data(),&nparam,ipiv.data(),AtWtb.data(),
&nparam,WA.data(),&LWORK,&INFO);
LWORK = WA[0]+1;
WA.resize( LWORK );
#ifdef PDBG
std::printf("dsysv_\n");
#endif
dsysv_("U",&nparam,&inc,AtWtA.data(),&nparam,ipiv.data(),AtWtb.data(),
&nparam,WA.data(),&LWORK,&INFO);
#ifdef PDBG
std::printf("return %i\n",INFO);
#endif
if ( INFO > 0 )
throw ccdl::SingularMatrixException("ccdl::WeightedLeastSquaresFit");
std::copy( AtWtb.data(), AtWtb.data()+nparam, x_param );
}
return INFO;
*/
}
void MethodInfo::init_activationScope(const ScopeTypeChain* s)
{
AvmAssert(_activationScopeOrTraits & IS_TRAITS);
AvmAssert(((Traits*)(_activationScopeOrTraits & ~IS_TRAITS)) == s->traits());
WB(pool()->core->GetGC(), this, &_activationScopeOrTraits, uintptr_t(s));
}
void MethodInfo::init_activationTraits(Traits* t)
{
AvmAssert(_activationScopeOrTraits == (uintptr_t(0) | IS_TRAITS));
WB(pool()->core->GetGC(), this, &_activationScopeOrTraits, uintptr_t(t) | IS_TRAITS);
}
int crl2pkcs7_main(int argc, char **argv)
{
BIO *in = NULL, *out = NULL;
PKCS7 *p7 = NULL;
PKCS7_SIGNED *p7s = NULL;
STACK_OF(OPENSSL_STRING) *certflst = NULL;
STACK_OF(X509) *cert_stack = NULL;
STACK_OF(X509_CRL) *crl_stack = NULL;
X509_CRL *crl = NULL;
char *infile = NULL, *outfile = NULL, *prog, *certfile;
int i = 0, informat = FORMAT_PEM, outformat = FORMAT_PEM, ret = 1, nocrl =
0;
OPTION_CHOICE o;
prog = opt_init(argc, argv, crl2pkcs7_options);
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
case OPT_EOF:
case OPT_ERR:
opthelp:
BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
goto end;
case OPT_HELP:
opt_help(crl2pkcs7_options);
ret = 0;
goto end;
case OPT_INFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
goto opthelp;
break;
case OPT_OUTFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
goto opthelp;
break;
case OPT_IN:
infile = opt_arg();
break;
case OPT_OUT:
outfile = opt_arg();
break;
case OPT_NOCRL:
nocrl = 1;
break;
case OPT_CERTFILE:
if ((certflst == NULL)
&& (certflst = sk_OPENSSL_STRING_new_null()) == NULL)
goto end;
if (!sk_OPENSSL_STRING_push(certflst, *(++argv))) {
sk_OPENSSL_STRING_free(certflst);
goto end;
}
break;
}
}
argc = opt_num_rest();
argv = opt_rest();
if (!app_load_modules(NULL))
goto end;
if (!nocrl) {
in = bio_open_default(infile, RB(informat));
if (in == NULL)
goto end;
if (informat == FORMAT_ASN1)
crl = d2i_X509_CRL_bio(in, NULL);
else if (informat == FORMAT_PEM)
crl = PEM_read_bio_X509_CRL(in, NULL, NULL, NULL);
if (crl == NULL) {
BIO_printf(bio_err, "unable to load CRL\n");
ERR_print_errors(bio_err);
goto end;
}
}
if ((p7 = PKCS7_new()) == NULL)
goto end;
if ((p7s = PKCS7_SIGNED_new()) == NULL)
goto end;
p7->type = OBJ_nid2obj(NID_pkcs7_signed);
p7->d.sign = p7s;
p7s->contents->type = OBJ_nid2obj(NID_pkcs7_data);
if (!ASN1_INTEGER_set(p7s->version, 1))
goto end;
if ((crl_stack = sk_X509_CRL_new_null()) == NULL)
goto end;
p7s->crl = crl_stack;
if (crl != NULL) {
sk_X509_CRL_push(crl_stack, crl);
crl = NULL; /* now part of p7 for OPENSSL_freeing */
}
if ((cert_stack = sk_X509_new_null()) == NULL)
goto end;
p7s->cert = cert_stack;
if (certflst)
for (i = 0; i < sk_OPENSSL_STRING_num(certflst); i++) {
certfile = sk_OPENSSL_STRING_value(certflst, i);
if (add_certs_from_file(cert_stack, certfile) < 0) {
BIO_printf(bio_err, "error loading certificates\n");
ERR_print_errors(bio_err);
goto end;
}
}
sk_OPENSSL_STRING_free(certflst);
out = bio_open_default(outfile, WB(outformat));
if (out == NULL)
goto end;
if (outformat == FORMAT_ASN1)
i = i2d_PKCS7_bio(out, p7);
else if (outformat == FORMAT_PEM)
i = PEM_write_bio_PKCS7(out, p7);
if (!i) {
BIO_printf(bio_err, "unable to write pkcs7 object\n");
ERR_print_errors(bio_err);
goto end;
}
ret = 0;
end:
BIO_free(in);
BIO_free_all(out);
PKCS7_free(p7);
X509_CRL_free(crl);
return (ret);
}
int ecparam_main(int argc, char **argv)
{
BIGNUM *ec_gen = NULL, *ec_order = NULL, *ec_cofactor = NULL;
BIGNUM *ec_p = NULL, *ec_a = NULL, *ec_b = NULL;
BIO *in = NULL, *out = NULL;
EC_GROUP *group = NULL;
point_conversion_form_t form = POINT_CONVERSION_UNCOMPRESSED;
char *curve_name = NULL, *inrand = NULL;
char *infile = NULL, *outfile = NULL, *prog;
unsigned char *buffer = NULL;
OPTION_CHOICE o;
int asn1_flag = OPENSSL_EC_NAMED_CURVE, new_asn1_flag = 0;
int informat = FORMAT_PEM, outformat = FORMAT_PEM, noout = 0, C = 0, ret =
1;
int list_curves = 0, no_seed = 0, check = 0, new_form = 0;
int text = 0, i, need_rand = 0, genkey = 0;
prog = opt_init(argc, argv, ecparam_options);
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
case OPT_EOF:
case OPT_ERR:
opthelp:
BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
goto end;
case OPT_HELP:
opt_help(ecparam_options);
ret = 0;
goto end;
case OPT_INFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
goto opthelp;
break;
case OPT_IN:
infile = opt_arg();
break;
case OPT_OUTFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
goto opthelp;
break;
case OPT_OUT:
outfile = opt_arg();
break;
case OPT_TEXT:
text = 1;
break;
case OPT_C:
C = 1;
break;
case OPT_CHECK:
check = 1;
break;
case OPT_LIST_CURVES:
list_curves = 1;
break;
case OPT_NO_SEED:
no_seed = 1;
break;
case OPT_NOOUT:
noout = 1;
break;
case OPT_NAME:
curve_name = opt_arg();
break;
case OPT_CONV_FORM:
if (!opt_pair(opt_arg(), forms, &new_form))
goto opthelp;
form = new_form;
new_form = 1;
break;
case OPT_PARAM_ENC:
if (!opt_pair(opt_arg(), encodings, &asn1_flag))
goto opthelp;
new_asn1_flag = 1;
break;
case OPT_GENKEY:
genkey = need_rand = 1;
break;
case OPT_RAND:
inrand = opt_arg();
need_rand = 1;
break;
case OPT_ENGINE:
(void)setup_engine(opt_arg(), 0);
break;
}
}
argc = opt_num_rest();
argv = opt_rest();
in = bio_open_default(infile, RB(informat));
if (in == NULL)
goto end;
out = bio_open_default(outfile, WB(outformat));
if (out == NULL)
goto end;
if (list_curves) {
EC_builtin_curve *curves = NULL;
size_t crv_len = EC_get_builtin_curves(NULL, 0);
size_t n;
curves = app_malloc((int)sizeof(*curves) * crv_len, "list curves");
if (!EC_get_builtin_curves(curves, crv_len)) {
OPENSSL_free(curves);
goto end;
}
for (n = 0; n < crv_len; n++) {
const char *comment;
const char *sname;
comment = curves[n].comment;
sname = OBJ_nid2sn(curves[n].nid);
if (comment == NULL)
comment = "CURVE DESCRIPTION NOT AVAILABLE";
if (sname == NULL)
sname = "";
BIO_printf(out, " %-10s: ", sname);
BIO_printf(out, "%s\n", comment);
}
OPENSSL_free(curves);
ret = 0;
goto end;
}
if (curve_name != NULL) {
int nid;
/*
* workaround for the SECG curve names secp192r1 and secp256r1 (which
* are the same as the curves prime192v1 and prime256v1 defined in
* X9.62)
*/
if (strcmp(curve_name, "secp192r1") == 0) {
BIO_printf(bio_err, "using curve name prime192v1 "
"instead of secp192r1\n");
nid = NID_X9_62_prime192v1;
} else if (strcmp(curve_name, "secp256r1") == 0) {
BIO_printf(bio_err, "using curve name prime256v1 "
"instead of secp256r1\n");
nid = NID_X9_62_prime256v1;
} else
nid = OBJ_sn2nid(curve_name);
if (nid == 0)
nid = EC_curve_nist2nid(curve_name);
if (nid == 0) {
BIO_printf(bio_err, "unknown curve name (%s)\n", curve_name);
goto end;
}
group = EC_GROUP_new_by_curve_name(nid);
if (group == NULL) {
BIO_printf(bio_err, "unable to create curve (%s)\n", curve_name);
goto end;
}
EC_GROUP_set_asn1_flag(group, asn1_flag);
EC_GROUP_set_point_conversion_form(group, form);
} else if (informat == FORMAT_ASN1)
group = d2i_ECPKParameters_bio(in, NULL);
else
group = PEM_read_bio_ECPKParameters(in, NULL, NULL, NULL);
if (group == NULL) {
BIO_printf(bio_err, "unable to load elliptic curve parameters\n");
ERR_print_errors(bio_err);
goto end;
}
if (new_form)
EC_GROUP_set_point_conversion_form(group, form);
if (new_asn1_flag)
EC_GROUP_set_asn1_flag(group, asn1_flag);
if (no_seed) {
EC_GROUP_set_seed(group, NULL, 0);
}
if (text) {
if (!ECPKParameters_print(out, group, 0))
goto end;
}
if (check) {
if (group == NULL)
BIO_printf(bio_err, "no elliptic curve parameters\n");
BIO_printf(bio_err, "checking elliptic curve parameters: ");
if (!EC_GROUP_check(group, NULL)) {
BIO_printf(bio_err, "failed\n");
ERR_print_errors(bio_err);
} else
BIO_printf(bio_err, "ok\n");
}
if (C) {
size_t buf_len = 0, tmp_len = 0;
const EC_POINT *point;
int is_prime, len = 0;
const EC_METHOD *meth = EC_GROUP_method_of(group);
if ((ec_p = BN_new()) == NULL
|| (ec_a = BN_new()) == NULL
|| (ec_b = BN_new()) == NULL
|| (ec_gen = BN_new()) == NULL
|| (ec_order = BN_new()) == NULL
|| (ec_cofactor = BN_new()) == NULL) {
perror("Can't allocate BN");
goto end;
}
is_prime = (EC_METHOD_get_field_type(meth) == NID_X9_62_prime_field);
if (!is_prime) {
BIO_printf(bio_err, "Can only handle X9.62 prime fields\n");
goto end;
}
if (!EC_GROUP_get_curve_GFp(group, ec_p, ec_a, ec_b, NULL))
goto end;
if ((point = EC_GROUP_get0_generator(group)) == NULL)
goto end;
if (!EC_POINT_point2bn(group, point,
EC_GROUP_get_point_conversion_form(group),
ec_gen, NULL))
goto end;
if (!EC_GROUP_get_order(group, ec_order, NULL))
goto end;
if (!EC_GROUP_get_cofactor(group, ec_cofactor, NULL))
goto end;
if (!ec_p || !ec_a || !ec_b || !ec_gen || !ec_order || !ec_cofactor)
goto end;
len = BN_num_bits(ec_order);
if ((tmp_len = (size_t)BN_num_bytes(ec_p)) > buf_len)
buf_len = tmp_len;
if ((tmp_len = (size_t)BN_num_bytes(ec_a)) > buf_len)
buf_len = tmp_len;
if ((tmp_len = (size_t)BN_num_bytes(ec_b)) > buf_len)
buf_len = tmp_len;
if ((tmp_len = (size_t)BN_num_bytes(ec_gen)) > buf_len)
buf_len = tmp_len;
if ((tmp_len = (size_t)BN_num_bytes(ec_order)) > buf_len)
buf_len = tmp_len;
if ((tmp_len = (size_t)BN_num_bytes(ec_cofactor)) > buf_len)
buf_len = tmp_len;
buffer = app_malloc(buf_len, "BN buffer");
BIO_printf(out, "EC_GROUP *get_ec_group_%d(void)\n{\n", len);
print_bignum_var(out, ec_p, "ec_p", len, buffer);
print_bignum_var(out, ec_a, "ec_a", len, buffer);
print_bignum_var(out, ec_b, "ec_b", len, buffer);
print_bignum_var(out, ec_gen, "ec_gen", len, buffer);
print_bignum_var(out, ec_order, "ec_order", len, buffer);
print_bignum_var(out, ec_cofactor, "ec_cofactor", len, buffer);
BIO_printf(out, " int ok = 0;\n"
" EC_GROUP *group = NULL;\n"
" EC_POINT *point = NULL;\n"
" BIGNUM *tmp_1 = NULL;\n"
" BIGNUM *tmp_2 = NULL;\n"
" BIGNUM *tmp_3 = NULL;\n"
"\n");
BIO_printf(out, " if ((tmp_1 = BN_bin2bn(ec_p_%d, sizeof (ec_p_%d), NULL)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " if ((tmp_2 = BN_bin2bn(ec_a_%d, sizeof (ec_a_%d), NULL)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " if ((tmp_3 = BN_bin2bn(ec_b_%d, sizeof (ec_b_%d), NULL)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " if ((group = EC_GROUP_new_curve_GFp(tmp_1, tmp_2, tmp_3, NULL)) == NULL)\n"
" goto err;\n"
"\n");
BIO_printf(out, " /* build generator */\n");
BIO_printf(out, " if ((tmp_1 = BN_bin2bn(ec_gen_%d, sizeof (ec_gen_%d), tmp_1)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " point = EC_POINT_bn2point(group, tmp_1, NULL, NULL);\n");
BIO_printf(out, " if (point == NULL)\n"
" goto err;\n");
BIO_printf(out, " if ((tmp_2 = BN_bin2bn(ec_order_%d, sizeof (ec_order_%d), tmp_2)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " if ((tmp_3 = BN_bin2bn(ec_cofactor_%d, sizeof (ec_cofactor_%d), tmp_3)) == NULL)\n"
" goto err;\n", len, len);
BIO_printf(out, " if (!EC_GROUP_set_generator(group, point, tmp_2, tmp_3))\n"
" goto err;\n"
"ok = 1;"
"\n");
BIO_printf(out, "err:\n"
" BN_free(tmp_1);\n"
" BN_free(tmp_2);\n"
" BN_free(tmp_3);\n"
" EC_POINT_free(point);\n"
" if (!ok) {\n"
" EC_GROUP_free(group);\n"
" return NULL;\n"
" }\n"
" return (group);\n"
"}\n");
}
if (!noout) {
if (outformat == FORMAT_ASN1)
i = i2d_ECPKParameters_bio(out, group);
else
i = PEM_write_bio_ECPKParameters(out, group);
if (!i) {
BIO_printf(bio_err, "unable to write elliptic "
"curve parameters\n");
ERR_print_errors(bio_err);
goto end;
}
}
if (need_rand) {
app_RAND_load_file(NULL, (inrand != NULL));
if (inrand != NULL)
BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
app_RAND_load_files(inrand));
}
if (genkey) {
EC_KEY *eckey = EC_KEY_new();
if (eckey == NULL)
goto end;
assert(need_rand);
if (EC_KEY_set_group(eckey, group) == 0)
goto end;
if (!EC_KEY_generate_key(eckey)) {
EC_KEY_free(eckey);
goto end;
}
if (outformat == FORMAT_ASN1)
i = i2d_ECPrivateKey_bio(out, eckey);
else
i = PEM_write_bio_ECPrivateKey(out, eckey, NULL,
NULL, 0, NULL, NULL);
EC_KEY_free(eckey);
}
if (need_rand)
app_RAND_write_file(NULL);
ret = 0;
end:
BN_free(ec_p);
BN_free(ec_a);
BN_free(ec_b);
BN_free(ec_gen);
BN_free(ec_order);
BN_free(ec_cofactor);
OPENSSL_free(buffer);
BIO_free(in);
BIO_free_all(out);
EC_GROUP_free(group);
return (ret);
}
void VTable::resolveSignatures(ScopeChain* scope)
{
AvmAssert(scope != NULL);
if( this->linked )
return;
// don't mark as resolved until the end of the function:
// if traits->resolveSignatures() throws, we end up with the VTable as
// "resolved" but the Traits not, which makes us crash in unpredictable ways.
if (!traits->isResolved())
{
traits->resolveSignatures(toplevel());
traits->setDeclaringScopes(scope->scopeTraits());
}
#if defined(DEBUG) || defined(_DEBUG)
// have to use local variables for CodeWarrior
Traits* traitsBase = traits->base;
Traits* baseTraits = base ? base->traits : 0;
// make sure the traits of the base vtable matches the base traits
AvmAssert((base == NULL && traits->base == NULL) || (base != NULL && traitsBase == baseTraits));
#endif // DEBUG
AvmCore* core = traits->core;
MMgc::GC* gc = core->GetGC();
if (traits->init && !this->init)
{
this->init = makeMethodEnv(traits->init, scope);
}
// populate method table
const TraitsBindingsp td = traits->getTraitsBindings();
const TraitsBindingsp btd = td->base;
for (uint32_t i = 0, n = td->methodCount; i < n; i++)
{
MethodInfo* method = td->getMethod(i);
if (btd && i < btd->methodCount && method == btd->getMethod(i))
{
// inherited method
// this->methods[i] = base->methods[i];
WB(gc, this, &methods[i], base->methods[i]);
continue;
}
// new definition
if (method != NULL)
{
//this->methods[i] = new (gc) MethodEnv(method, this);
WB(gc, this, &methods[i], makeMethodEnv(method, scope));
continue;
}
#ifdef AVMPLUS_VERBOSE
if (traits->pool->isVerbose(VB_traits))
{
// why would the compiler assign sparse disp_id's?
traits->core->console << "WARNING: empty disp_id " << i << " on " << traits << "\n";
}
#endif
}
// this is done here b/c this property of the traits isn't set until the
// Dictionary's ClassClosure is called
if (base && base->traits->isDictionary())
traits->set_isDictionary();
traits->core->exec->notifyVTableResolved(this);
linked = true;
}
int main (int argc, char *argv[]) {
int sim_mode=0; // mode flag, 1 for single-cycle, 0 for batch
long pgm_c=0; // program counter
long sim_cycle=0; // simulation cycle counter
//define your own counter for the usage of each pipeline stage here
int test_counter=0;
// FILE setup
FILE *input; // Input a set of instructions
FILE *output; // Output the data
int i;
printf("The arguments are:");
for(i=1;i<argc;i++){
printf("%s ",argv[i]);
}
//choosing the simulation mode
printf("\n");
if (argc==7) {
if (strcmp("-s",argv[1])==0){
sim_mode=SINGLE;
} else if(strcmp("-b",argv[1])==0){
sim_mode=BATCH;
} else{
printf("Wrong sim mode chosen\n");
exit(0);
}
m=atoi(argv[2]); // number of cycles needed by miltiplication
n=atoi(argv[3]); // other operation
c=atoi(argv[4]); // memory access
input=fopen(argv[5],"r");
output=fopen(argv[6],"w");
} else {
printf("Usage: ./sim-mips -s m n c input_name output_name (single-sysle mode)\n or \n ./sim-mips -b m n c input_name output_name(batch mode)\n");
printf("m,n,c stand for number of cycles needed by multiplication, other operation, and memory access, respectively\n");
exit(0);
}
if (input == NULL) {
printf("Unable to open input or output file\n");
exit(0);
}
if (output == NULL) {
printf("Cannot create output file\n");
exit(0);
}
// parsing the file
int x = 0;
char buffer[40];
char *temp;
while ((temp = fgets(buffer, sizeof(buffer), input)) != NULL) {
instr_mem[x] = strdup(temp);
x++;
}
//initialize registers so displays as empty for single mode
if (sim_mode == 1) {
for (i=0;i<REG_NUM;i++){
mips_reg[i]=0;
}
}
if (sim_mode == 0) { // batch cycle
while (1) {
if (haltLatch.data.halt == 1) { break; }
WB();
MEM();
EX();
ID();
if (stallIF == 1) {
stallIF = 0;
} else {
IF();
}
}
// ----- Code 3 -----
// Add the following code to the end of the simulation,
// to output statistics in batch mode
fprintf(output,"program name: %s\n",argv[5]);
fprintf(output,"stage utilization: %f %f %f %f %f \n", ifUtil, idUtil, exUtil, memUtil, wbUtil);
// add the (double) stage_counter/sim_cycle for each
// stage following sequence IF ID EX MEM WB
fprintf(output,"register values ");
for (i=1;i<REG_NUM;i++){
fprintf(output,"%ld ", mips_reg[i]);
}
fprintf(output,"%ld\n", pgm_c);
} else { // single cycle
while (1) {
if (haltLatch.data.halt == 1) { break; }
WB();
MEM();
EX();
ID();
if (stallIF == 1) {
stallIF = 0;
} else {
IF();
}
printf("cycle: %ld ",sim_cycle);
if(sim_mode==1){
for (i=1;i<REG_NUM;i++){
printf("%ld ",mips_reg[i]);
}
}
printf("%ld\n",pgm_c);
pgm_c+=4;
sim_cycle+=1;
test_counter++;
printf("press ENTER to continue\n");
while (getchar() != '\n');
}
}
// Clean up
fclose(input);
fclose(output);
return 0;
}
int pkcs7_main(int argc, char **argv)
{
PKCS7 *p7 = NULL;
BIO *in = NULL, *out = NULL;
int informat = FORMAT_PEM, outformat = FORMAT_PEM;
char *infile = NULL, *outfile = NULL, *prog;
int i, print_certs = 0, text = 0, noout = 0, p7_print = 0, ret = 1;
OPTION_CHOICE o;
prog = opt_init(argc, argv, pkcs7_options);
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
case OPT_EOF:
case OPT_ERR:
opthelp:
BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
goto end;
case OPT_HELP:
opt_help(pkcs7_options);
ret = 0;
goto end;
case OPT_INFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
goto opthelp;
break;
case OPT_OUTFORM:
if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
goto opthelp;
break;
case OPT_IN:
infile = opt_arg();
break;
case OPT_OUT:
outfile = opt_arg();
break;
case OPT_NOOUT:
noout = 1;
break;
case OPT_TEXT:
text = 1;
break;
case OPT_PRINT:
p7_print = 1;
break;
case OPT_PRINT_CERTS:
print_certs = 1;
break;
case OPT_ENGINE:
(void)setup_engine(opt_arg(), 0);
break;
}
}
argc = opt_num_rest();
argv = opt_rest();
in = bio_open_default(infile, RB(informat));
if (in == NULL)
goto end;
if (informat == FORMAT_ASN1)
p7 = d2i_PKCS7_bio(in, NULL);
else
p7 = PEM_read_bio_PKCS7(in, NULL, NULL, NULL);
if (p7 == NULL) {
BIO_printf(bio_err, "unable to load PKCS7 object\n");
ERR_print_errors(bio_err);
goto end;
}
out = bio_open_default(outfile, WB(outformat));
if (out == NULL)
goto end;
if (p7_print)
PKCS7_print_ctx(out, p7, 0, NULL);
if (print_certs) {
STACK_OF(X509) *certs = NULL;
STACK_OF(X509_CRL) *crls = NULL;
i = OBJ_obj2nid(p7->type);
switch (i) {
case NID_pkcs7_signed:
certs = p7->d.sign->cert;
crls = p7->d.sign->crl;
break;
case NID_pkcs7_signedAndEnveloped:
certs = p7->d.signed_and_enveloped->cert;
crls = p7->d.signed_and_enveloped->crl;
break;
default:
break;
}
if (certs != NULL) {
X509 *x;
for (i = 0; i < sk_X509_num(certs); i++) {
x = sk_X509_value(certs, i);
if (text)
X509_print(out, x);
else
dump_cert_text(out, x);
if (!noout)
PEM_write_bio_X509(out, x);
BIO_puts(out, "\n");
}
}
if (crls != NULL) {
X509_CRL *crl;
for (i = 0; i < sk_X509_CRL_num(crls); i++) {
crl = sk_X509_CRL_value(crls, i);
X509_CRL_print(out, crl);
if (!noout)
PEM_write_bio_X509_CRL(out, crl);
BIO_puts(out, "\n");
}
}
ret = 0;
goto end;
}
if (!noout) {
if (outformat == FORMAT_ASN1)
i = i2d_PKCS7_bio(out, p7);
else
i = PEM_write_bio_PKCS7(out, p7);
if (!i) {
BIO_printf(bio_err, "unable to write pkcs7 object\n");
ERR_print_errors(bio_err);
goto end;
}
}
ret = 0;
end:
PKCS7_free(p7);
BIO_free(in);
BIO_free_all(out);
return (ret);
}
