PcDesc* nmethod::containingPcDescOrNULL(char* pc) { // returns PcDesc that is closest one before or == to pc, or NULL if // no stored pcDesc exists // called a lot, so watch out for performance bugs assert(contains(pc), "nmethod must contain pc into frame"); int32 offset = pc - insts(); PcDesc* start = pcs(); PcDesc* end = pcsEnd() - 1; // Skim the cream if only one pcDesc is present. if (start == end) return start; assert(start < end, "no PcDescs to search"); if (start->pc > offset) // in prologue; caller has to deal with this return NULL; // binary search to find approx. location PcDesc* middle; int32 l = 0, h = end - start; do { // avoid pointer arithmetic -- gcc uses a division for PcDesc* - PcDesc* int32 m = l + (h - l) / 2; middle = &start[m]; if (middle->pc < offset) { l = m + 1; } else { h = m - 1; } } while (middle->pc != offset && l < h); // may not have found exact offset, so search for closest match while (middle->pc <= offset && middle < end ) middle++; while (middle->pc > offset && middle > start) middle--; assert(start <= middle && middle <= end, "should have found a pcDesc"); # if GENERATE_DEBUGGING_AIDS if (CheckAssertions) { PcDesc* d = pcs(); PcDesc* closest = d; for (; d <= end; d ++) { if (d->pc <= offset && (closest == NULL || closest->pc <= d->pc)) { closest = d; } } assert(closest == middle, "found different pcDesc"); } # endif return middle; }
TEST(NumLib, DISABLED_Extrapolation) #endif { /* In this test a random vector x of nodal values is created. * This vector is interpolated to the integration points using each * element's the shape functions. * Afterwards the integration point values y are extrapolated to the mesh * nodes again. * Since y have been obtained from x via interpolation, it is expected, that * the interpolation result nearly exactly matches the original nodal values * x. */ const double mesh_length = 1.0; const std::size_t mesh_elements_in_each_direction = 5; // generate mesh std::unique_ptr<MeshLib::Mesh> mesh( MeshLib::MeshGenerator::generateRegularHexMesh( mesh_length, mesh_elements_in_each_direction)); for (unsigned integration_order : {2, 3, 4}) { namespace LinAlg = MathLib::LinAlg; auto const nnodes = mesh->getNumberOfNodes(); auto const nelements = mesh->getNumberOfElements(); DBUG("number of nodes: %lu, number of elements: %lu", nnodes, nelements); ExtrapolationTest::ExtrapolationTestProcess pcs(*mesh, integration_order); // generate random nodal values MathLib::MatrixSpecifications spec{nnodes, nnodes, nullptr, nullptr}; auto x = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(spec); fillVectorRandomly(*x); pcs.interpolateNodalValuesToIntegrationPoints(*x); // test extrapolation of a quantity that is stored in the local // assembler ExtrapolationTest::extrapolate( pcs, &ExtrapolationTest::LocalAssemblerDataInterface::getStoredQuantity, *x, nnodes, nelements); // expect 2*x as extraplation result for derived quantity auto two_x = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(*x); LinAlg::axpy(*two_x, 1.0, *x); // two_x = x + x // test extrapolation of a quantity that is derived from some // integration point values ExtrapolationTest::extrapolate( pcs, &ExtrapolationTest::LocalAssemblerDataInterface::getDerivedQuantity, *two_x, nnodes, nelements); } }
pcstack* new_pcstack() { pcstack* pcs((pcstack*)malloc(sizeof(pcstack))); memset((void*)pcs,0,sizeof(pcstack)); pcs->size=0; pcs->first=0; return pcs; }
bool nmethod::encompasses(void* p) { return includes(p, this, this + 1) || includes(p, deps(), depsEnd()) || includes(p, insts(), instsEnd()) || includes(p, locs(), locsEnd()) || scopes->includes((ScopeDesc*) p) || includes(p, pcs(), pcsEnd()); }
void __attribute__ ((noinline)) i2c_write_bit(uint8_t val) { if ( val ) pcs(pcs_i2c_write_1); else pcs(pcs_i2c_write_0); /* if (val) i2c_read_sda(); else i2c_clear_sda(); i2c_delay(); i2c_read_scl_and_delay(); i2c_clear_scl(); */ }
void nmethod::printPcs() { ResourceMark m; // in case methods get printed from gdb printIndent(); lprintf("pc-bytecode offsets:\n"); Indent ++; for (PcDesc* p = pcs(); p < pcsEnd(); p ++) p->print(this); Indent --; }
Data_Splitter<INTERVALCONTAINER,IDXTYPE>::Data_Splitter(const Data_Splitter& dsp) { notify("Data_Splitter strong copy constructor begin."); csplit.clear(); for(typename std::vector<PClassSplitter>::const_iterator c=dsp.csplit.begin();c!=dsp.csplit.end();c++) {PClassSplitter pcs(new TClassSplitter(*(*c))); this->csplit.push_back(pcs);} notify("Data_Splitter strong copy constructor end."); }
void PluginsManager::addInMenuFromPMIndex(int i) { std::vector<PluginCmdShortcut> & pluginCmdSCList = (NppParameters::getInstance())->getPluginCommandList(); ::InsertMenu(_hPluginsMenu, i, MF_BYPOSITION | MF_POPUP, (UINT_PTR)_pluginInfos[i]->_pluginMenu, _pluginInfos[i]->_pFuncGetName()); unsigned short j = 0; for ( ; j < _pluginInfos[i]->_nbFuncItem ; j++) { if (_pluginInfos[i]->_funcItems[j]._pFunc == NULL) { ::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION | MF_SEPARATOR, 0, TEXT("")); continue; } _pluginsCommands.push_back(PluginCommand(_pluginInfos[i]->_moduleName.c_str(), j, _pluginInfos[i]->_funcItems[j]._pFunc)); int cmdID = ID_PLUGINS_CMD + (_pluginsCommands.size() - 1); _pluginInfos[i]->_funcItems[j]._cmdID = cmdID; generic_string itemName = _pluginInfos[i]->_funcItems[j]._itemName; if (_pluginInfos[i]->_funcItems[j]._pShKey) { ShortcutKey & sKey = *(_pluginInfos[i]->_funcItems[j]._pShKey); PluginCmdShortcut pcs(Shortcut(itemName.c_str(), sKey._isCtrl, sKey._isAlt, sKey._isShift, sKey._key), cmdID, _pluginInfos[i]->_moduleName.c_str(), j); pluginCmdSCList.push_back(pcs); itemName += TEXT("\t"); itemName += pcs.toString(); } else { //no ShortcutKey is provided, add an disabled shortcut (so it can still be mapped, Paramaters class can still index any changes and the toolbar wont funk out Shortcut sc(itemName.c_str(), false, false, false, 0x00); PluginCmdShortcut pcs(sc, cmdID, _pluginInfos[i]->_moduleName.c_str(), j); //VK_NULL and everything disabled, the menu name is left alone pluginCmdSCList.push_back(pcs); } ::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, cmdID, itemName.c_str()); if (_pluginInfos[i]->_funcItems[j]._init2Check) ::CheckMenuItem(_hPluginsMenu, cmdID, MF_BYCOMMAND | MF_CHECKED); } /*UNLOAD ::InsertMenu(_pluginInfos[i]->_pluginMenu, j++, MF_BYPOSITION | MF_SEPARATOR, 0, TEXT("")); ::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, ID_PLUGINS_REMOVING + i, TEXT("Remove this plugin")); */ }
ExLockSync::ExLockSync() { #ifdef DEBUG m_lockOwner = 0; #endif CASSERT( sizeof( m_data ) == sizeof( CRITICAL_SECTION ) ); CASSERT( __alignof( Data ) == __alignof( CRITICAL_SECTION ) ); InitializeCriticalSection( pcs( &m_data ) ); }
void i2c_start(void) { if ( i2c_started != 0 ) { /* if already started: do restart */ //i2c_read_sda(); /* SDA = 1 */ //i2c_delay(); //i2c_read_scl_and_delay(); pcs(pcs_i2c_restart); } //i2c_read_sda(); /* send the start condition, both lines go from 1 to 0 */ //i2c_clear_sda(); //i2c_delay(); //i2c_clear_scl(); pcs(pcs_i2c_start); i2c_started = 1; }
void ExLockSync::claimLock() // nofail { EnterCriticalSection( pcs( &m_data ) ); #ifdef DEBUG dbgAssert( !m_lockOwner ); m_lockOwner = GetCurrentThreadId(); #endif }
void ExLockSync::releaseLock() // nofail { #ifdef DEBUG dbgAssert( m_lockOwner == GetCurrentThreadId() ); m_lockOwner = 0; #endif LeaveCriticalSection( pcs( &m_data ) ); }
void Data_Splitter<INTERVALCONTAINER,IDXTYPE>::set_n(const unsigned int _clsidx, const IDXTYPE _n) { assert(_n>0); assert(_clsidx>=0); try { while(csplit.size()<=_clsidx) {PClassSplitter pcs(new TClassSplitter); csplit.push_back(pcs);} csplit[_clsidx]->n=_n; } catch(...) { throw fst_error("Data_Splitter::assign() out-of-index? error."); } }
void Data_Splitter<INTERVALCONTAINER,IDXTYPE>::assign(const unsigned int _clsidx, const PIntervaller _train, const PIntervaller _test) { assert(_clsidx>=0); assert(_train); assert(_test); try { while(csplit.size()<=_clsidx) {PClassSplitter pcs(new TClassSplitter); csplit.push_back(pcs);} csplit[_clsidx]->train=_train; csplit[_clsidx]->test=_test; } catch(...) { throw fst_error("Data_Splitter::assign() out-of-index? error."); } }
void UnionScan::executePlanOperation() { const auto& tables = input.getTables(); std::vector<std::shared_ptr<const storage::PointerCalculator>> pcs(tables.size()); std::transform(begin(tables), end(tables), begin(pcs), [](decltype(*begin(tables)) table) { return std::dynamic_pointer_cast<const storage::PointerCalculator>(table); }); if (std::all_of(begin(pcs), end(pcs), [](decltype(*begin(tables)) pc) { return pc != nullptr; })) { addResult(storage::PointerCalculator::unite_many(begin(pcs), end(pcs))); } else { throw std::runtime_error(_planOperationName + " is only supported for PointerCalculators (UnionScan.cpp)"); // We need to implement duplicate elimination here to make this a true union // If you tripped over this error, you probably meant to use UnionAll. // addResult(std::make_shared<const HorizontalTable>(tables)); } }
unsigned __attribute__ ((noinline)) i2c_read_bit(void) { return pcs(pcs_i2c_read_bit); //uint8_t val; /* do not drive SDA */ /* i2c_read_sda(); i2c_delay(); i2c_read_scl_and_delay(); val = i2c_read_sda(); i2c_delay(); i2c_clear_scl(); return val; */ }
void i2c_stop(void) { /* set SDA to 0 */ //i2c_clear_sda(); //i2c_delay(); /* now release all lines */ //i2c_read_scl_and_delay(); /* set SDA to 1 */ //i2c_read_sda(); //i2c_delay(); pcs(pcs_i2c_stop); i2c_started = 0; }
bool SearchCProcs(var &result, var head, var body) { stdext::hash_map<Var,CProc>::const_iterator iter = CProcs.find(head); if(iter != CProcs.end()) { PushCProcSymbol pcs(head); if (Verbose >= 3) { wcerr << _W("Enter cproc for "); Println(Ex(head, body), wcerr); } try { result = iter->second(body); } catch (UserException&) { throw; } // catch (std::exception& e) { // wcerr << L"std::exception thrown: " << mbs2wcs(e.what()) << std::endl; // wcerr << "CProc error while eval "; // Println(Ex(head, body), wcerr); // return false; // } catch (...) { wcerr << "CProc error while eval "; Println(Ex(head, body), wcerr); throw; } if (result) { if (TraceRuleSymbols.count(head) != 0) { // FIXME: rewrite this after we implement the kernel message infrastructure Print(head); wcout << _W("::tracer : "); Print(Ex(head, body)); wcout << _W(" :> "); Println(result); } if (Verbose >= 3) { wcerr << _W("Result is "); Println(result, wcerr); } return true; } } return false; }
// Cutting point of three planes Foam::point Foam::plane::planePlaneIntersect ( const plane& plane2, const plane& plane3 ) const { List<scalarList> pcs(3); pcs[0]= planeCoeffs(); pcs[1]= plane2.planeCoeffs(); pcs[2]= plane3.planeCoeffs(); tensor a ( pcs[0][0],pcs[0][1],pcs[0][2], pcs[1][0],pcs[1][1],pcs[1][2], pcs[2][0],pcs[2][1],pcs[2][2] ); vector b(pcs[0][3],pcs[1][3],pcs[2][3]); return (inv(a) & (-b)); }
Android_PushEvent(); } void Java_in_celest_xash3d_XashActivity_nativeString(JNIEnv* env, jclass cls, jobject string) { char* str = (char *) (*env)->GetStringUTFChars(env, string, NULL); Android_Lock(); strncat( events.inputtext, str, 256 ); Android_Unlock(); (*env)->ReleaseStringUTFChars(env, string, str); } #ifdef SOFTFP_LINK void Java_in_celest_xash3d_XashActivity_nativeTouch(JNIEnv* env, jclass cls, jint finger, jint action, jfloat x, jfloat y ) __attribute__((pcs("aapcs"))); #endif void Java_in_celest_xash3d_XashActivity_nativeTouch(JNIEnv* env, jclass cls, jint finger, jint action, jfloat x, jfloat y ) { float dx, dy; event_t *event; // if something wrong with android event if( finger > MAX_FINGERS ) return; // not touch action? if( !( action >=0 && action <= 2 ) ) return; // 0.0f .. 1.0f
// REQUIRES: arm-registered-target // RUN: %clang_cc1 -triple arm-none-linux-gnueabi -emit-llvm -w -o - < %s | FileCheck %s typedef int __attribute__((pcs("aapcs"))) (*aapcs_fn)(void); typedef int __attribute__((pcs("aapcs-vfp"))) (*aapcs_vfp_fn)(void); aapcs_fn bar; int foo(aapcs_vfp_fn baz) { // CHECK-LABEL: define i32 @foo // CHECK: call arm_aapcscc // CHECK: call arm_aapcs_vfpcc return bar() + baz(); }
/* maybe this can be optimized */ void i2c_init(void) { pcs(pcs_i2c_init); }
void simple_load_balancer::run_lb(app_info& info, partition_configuration& pc, bool is_stateful) { if (_state->freezed() && is_stateful) return; configuration_update_request proposal; proposal.config = pc; proposal.info = info; if (is_stateful) { if (pc.primary.is_invalid()) { if (pc.secondaries.size() > 0) { if (s_lb_for_test) { std::vector< ::dsn::rpc_address> tmp(pc.secondaries); std::sort(tmp.begin(), tmp.end()); proposal.node = tmp[0]; } else { proposal.node = pc.secondaries[dsn_random32(0, static_cast<int>(pc.secondaries.size()) - 1)]; } proposal.type = config_type::CT_UPGRADE_TO_PRIMARY; } else if (pc.last_drops.size() == 0) { proposal.node = find_minimal_load_machine(true); proposal.type = config_type::CT_ASSIGN_PRIMARY; } // DDD else { proposal.node = *pc.last_drops.rbegin(); proposal.type = config_type::CT_ASSIGN_PRIMARY; derror("%s.%d.%d enters DDD state, we are waiting for its last primary node %s to come back ...", info.app_type.c_str(), pc.pid.get_app_id(), pc.pid.get_partition_index(), proposal.node.to_string() ); } if (proposal.node.is_invalid() == false) { send_proposal(proposal.node, proposal); } } else if (static_cast<int>(pc.secondaries.size()) + 1 < pc.max_replica_count) { proposal.type = config_type::CT_ADD_SECONDARY; proposal.node = find_minimal_load_machine(false); if (proposal.node.is_invalid() == false && proposal.node != pc.primary && std::find(pc.secondaries.begin(), pc.secondaries.end(), proposal.node) == pc.secondaries.end()) { send_proposal(pc.primary, proposal); } } else { // it is healthy, nothing to do } } // stateless else { partition_configuration_stateless pcs(pc); if (static_cast<int>(pcs.worker_replicas().size()) < pc.max_replica_count) { proposal.type = config_type::CT_ADD_SECONDARY; proposal.node = find_minimal_load_machine(false); if (proposal.node.is_invalid() == false) { bool send = true; for (auto& s : pc.secondaries) { // not on the same machine if (s == proposal.node) { send = false; break; } } if (send) { send_proposal(proposal.node, proposal); } } } else { // it is healthy, nothing to do } } }
void __attribute__ ((noinline)) i2c_clear_scl(void) { /* set open collector and drive low */ pcs(pcs_i2c_clear_scl); }
/* actually, the scl line is not observed, so this procedure does not return a value */ void i2c_read_scl_and_delay(void) { pcs(pcs_i2c_read_scl_and_delay); }
uint8_t __attribute__ ((noinline)) i2c_read_sda(void) { //Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 0); return pcs(pcs_i2c_read_sda); //return Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 0); }
bool nmethod::verify() { bool r = true; ResourceMark rm; r &= OopNCode::verify2("nmethod"); if (insts() != (char*)(this + 1)) { error1("nmethod at 0x%lx has incorrect insts pointer", this); r = false; } if (!Memory->code->contains(this)) { error1("nmethod at 0x%lx not in zone", this); r = false; } if (!zoneLink.verify_list_integrity()) { lprintf("\tof zoneLink of nmethod 0x%lx\n", this); r = false; } { FOR_MY_CODETABLE_ENTRIES(e) if (e->nm != this) { error1("bad code table link for nmethod %#lx\n", this); r = false; } } bool isAligned = (frame_size & (frame_word_alignment-1)) == 0; if (!isAligned) { lprintf("nmethod at %#lx: frame size is not multiple of %d words\n", (long unsigned)this, frame_word_alignment); r = false; } if (codeTableLink != NULL) { nmethod *tableResult = isDebug() ? Memory->code->debugTable->lookup(key) : Memory->code->table ->lookup(key); if (tableResult != this) { error1("nmethod at %#lx: code table lookup failed", this); r = false; } } if (!key.verify()) { lprintf("\tof key of nmethod 0x%lx\n", this); r = false; } { FOR_MY_CODETABLE_ENTRIES(e) if (!e->key.verify()) { lprintf("\tof code table key %#lx of nmethod 0x%lx\n", (long unsigned)&e->key, (long unsigned)this); r = false; } } if (!linkedSends.verify_list_integrity()) { lprintf("\tof linkedSends of nmethod 0x%lx\n", this); r = false; } if (!diLink.verify_list_integrity()) { lprintf("\tof diLink of nmethod 0x%lx\n", this); r = false; } r &= scopes->verify(); for (PcDesc* p = pcs(); p < pcsEnd(); p++) { if (! p->verify(this)) { lprintf("\t\tin nmethod at %#lx (pcs)\n", this); r = false; } } // more checks in ncode::verify called above bool shouldBeDI = diLink.notEmpty(); for (addrDesc* l = locs(); l < locsEnd(); l++) { if (l->isDIDesc()) { shouldBeDI = true; } } if (shouldBeDI && !isDI()) { error1("nmethod %#lx should be marked isDI", this); r = false; } else if (!shouldBeDI && isDI()) { error1("nmethod %#lx should not be marked isDI", this); r = false; } if (! key.receiverMap()->is_block() ) { for (nmln* d = deps(); d < depsEnd(); d++) { if (! d->verify_list_integrity()) { lprintf("\tin nmethod at %#lx (deps)\n", this); r = false; } } } if (frame_chain != NoFrameChain) { error1("nmethod %#lx has non-zero frame chain value", this); r = false; } if (findNMethod( instsEnd() - oopSize) != this) { error1("findNMethod did not find this nmethod (%#lx)", this); r = false; } return r; }
void __attribute__ ((noinline)) i2c_clear_sda(void) { /* set open collector and drive low */ pcs(pcs_i2c_clear_sda); // Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 0); }
// See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file tests __aeabi_drsub for the compiler_rt library. // //===----------------------------------------------------------------------===// #include <stdio.h> #include <stdlib.h> #include <math.h> #if __arm__ extern __attribute__((pcs("aapcs"))) double __aeabi_drsub(double a, double b); int test__aeabi_drsub(double a, double b, double expected) { double actual = __aeabi_drsub(a, b); if (actual != expected) printf("error in __aeabi_drsub(%f, %f) = %f, expected %f\n", a, b, actual, expected); return actual != expected; } #endif int main() { #if __arm__ if (test__aeabi_drsub(1.0, 1.0, 0.0))
// //===----------------------------------------------------------------------===// // // This file tests __aeabi_cfcmpeq for the compiler_rt library. // //===----------------------------------------------------------------------===// #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <math.h> #if __arm__ #include "call_apsr.h" extern __attribute__((pcs("aapcs"))) void __aeabi_cfcmpeq(float a, float b); int test__aeabi_cfcmpeq(float a, float b, int expected) { uint32_t cpsr_value = call_apsr_f(a, b, __aeabi_cfcmpeq); union cpsr cpsr = { .value = cpsr_value }; if (expected != cpsr.flags.z) { printf("error in __aeabi_cfcmpeq(%f, %f) => Z = %d, expected %d\n", a, b, cpsr.flags.z, expected); return 1; } return 0; } #endif int main()