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); }