Lines Matching defs:code
6 // * Redistributions of source code must retain the above copyright
53 // code.
110 // Get the stop code.
111 uint32_t code = instr->SvcValue() & kStopCodeMask;
119 if (isWatchedStop(code) && !watched_stops[code].desc) {
120 watched_stops[code].desc = msg;
142 // Get the stop code.
143 uint32_t code = instr->SvcValue() & kStopCodeMask;
148 if (sim_->isWatchedStop(code) && !sim_->watched_stops[code].desc) {
149 sim_->watched_stops[code].desc = msg;
151 // Print the stop message and code if it is not the default code.
152 if (code != kMaxStopCode) {
153 PrintF("Simulator hit stop %u: %s\n", code, msg);
229 // Not setting the breakpoint instruction in the code itself. It will be set
579 PrintF(" disassemble code, default is 10 instructions\n");
603 PrintF(" stop info all/<code> : print infos about number <code>\n");
605 PrintF(" stop enable/disable all/<code> : enables / disables\n");
606 PrintF(" all or number <code> stop(s)\n");
786 // When the generated code calls an external reference we need to catch that in
883 // Stupid code added to avoid bug in GCC.
886 // End stupid code.
1050 // system running directly on the host system and only generated code is
1644 // Note: To be able to return two values from some calls the code in runtime.cc
1646 // 64-bit value. With the code below we assume that all runtime calls return
1785 uint32_t code = svc & kStopCodeMask;
1786 if (isWatchedStop(code)) {
1787 IncreaseStopCounter(code);
1791 if (isEnabledStop(code)) {
1798 // This is not a valid svc code.
1813 bool Simulator::isWatchedStop(uint32_t code) {
1814 ASSERT(code <= kMaxStopCode);
1815 return code < kNumOfWatchedStops;
1819 bool Simulator::isEnabledStop(uint32_t code) {
1820 ASSERT(code <= kMaxStopCode);
1822 return !isWatchedStop(code) ||
1823 !(watched_stops[code].count & kStopDisabledBit);
1827 void Simulator::EnableStop(uint32_t code) {
1828 ASSERT(isWatchedStop(code));
1829 if (!isEnabledStop(code)) {
1830 watched_stops[code].count &= ~kStopDisabledBit;
1835 void Simulator::DisableStop(uint32_t code) {
1836 ASSERT(isWatchedStop(code));
1837 if (isEnabledStop(code)) {
1838 watched_stops[code].count |= kStopDisabledBit;
1843 void Simulator::IncreaseStopCounter(uint32_t code) {
1844 ASSERT(code <= kMaxStopCode);
1845 ASSERT(isWatchedStop(code));
1846 if ((watched_stops[code].count & ~(1 << 31)) == 0x7fffffff) {
1847 PrintF("Stop counter for code %i has overflowed.\n"
1848 "Enabling this code and reseting the counter to 0.\n", code);
1849 watched_stops[code].count = 0;
1850 EnableStop(code);
1852 watched_stops[code].count++;
1858 void Simulator::PrintStopInfo(uint32_t code) {
1859 ASSERT(code <= kMaxStopCode);
1860 if (!isWatchedStop(code)) {
1863 const char* state = isEnabledStop(code) ? "Enabled" : "Disabled";
1864 int32_t count = watched_stops[code].count & ~kStopDisabledBit;
1867 if (watched_stops[code].desc) {
1869 code, code, state, count, watched_stops[code].desc);
1872 code, code, state, count);
2848 // Check for overflow. This code works because 32bit integers can be
2903 // We are playing with code close to the C++ standard's limits below,
2904 // hence the very simple code and heavy checks.
3209 // Compute position of stack on entry to generated code.
3222 // Prepare to execute the code at entry
3230 // The code below assumes that r9 is not used as sb (static base) in
3231 // simulator code and therefore is regarded as a callee-saved register.
