Java’s control message, a cardinal power travel mechanics, frequently puzzles builders with its show traits, particularly once dealing with contiguous integer values. Wherefore does including much lawsuit statements generally look to velocity ahead execution? This seemingly counterintuitive behaviour isn’t astir the figure of circumstances themselves, however instead the underlying bytecode optimizations that the Java compiler and JIT compiler employment. Knowing these optimizations is important for penning businesslike Java codification and leveraging the afloat possible of the control message. This station dives into the mechanics down this development, exploring however the compiler interprets control statements into antithetic bytecode constructions and however these constructions contact show.
Tableswitch vs. Lookupswitch
The cardinal to knowing the show quality lies successful the 2 bytecode directions the Java compiler makes use of to instrumentality control statements: tableswitch and lookupswitch. tableswitch is utilized once the lawsuit values are contiguous oregon adjacent to contiguous. It creates a leap array, permitting for changeless-clip lookups, making it precise businesslike. Connected the another manus, lookupswitch is employed once the lawsuit values are sparse. It makes use of a binary hunt attack, ensuing successful logarithmic clip complexity.
Including much contiguous lawsuit statements tin typically end the compiler’s determination from utilizing lookupswitch to tableswitch. This control to a much businesslike leap array is what leads to the perceived show betterment. It’s not the further instances themselves that increase velocity, however the alteration successful the underlying bytecode implementation.
For illustration, a control with circumstances 1, 5, and 10 mightiness usage lookupswitch. Including instances 2, three, and four might brand the compiler control to tableswitch, bettering show equal although much instances are immediate.
The Function of the JIT Compiler
The Conscionable-Successful-Clip (JIT) compiler performs a important function successful additional optimizing control message show. It analyzes the runtime behaviour of the codification and tin execute further optimizations based mostly connected the existent organisation of lawsuit values. For case, if a peculiar lawsuit is deed cold much often than others, the JIT compiler tin reorder the leap array oregon equal make specialised codification to grip that circumstantial lawsuit much effectively.
This dynamic optimization makes it hard to foretell the direct show contact of including oregon deleting lawsuit statements. Show investigating and profiling are important for knowing the existent behaviour of your codification successful a exhibition situation.
See a script wherever a control message handles person enter. The JIT compiler mightiness optimize the codification primarily based connected the about communal person decisions, starring to sooner execution for these circumstantial circumstances.
Benchmarking and Profiling
To precisely measure the contact of including lawsuit statements connected control show, benchmarking and profiling are indispensable. Instruments similar JMH (Java Microbenchmark Harness) tin supply exact measurements, serving to you place show bottlenecks and optimize your codification efficaciously.
Retrieve, microbenchmarks ought to beryllium cautiously designed to debar communal pitfalls and guarantee close outcomes. Direction connected lifelike situations and typical workloads.
For case, benchmarking a control message with uniformly distributed random inputs mightiness output antithetic outcomes in contrast to benchmarking with existent-planet person information, wherever definite circumstances mightiness beryllium importantly much predominant.
Champion Practices for Control Statements
Piece knowing the underlying mechanisms is crucial, pursuing champion practices tin aid you compose businesslike control statements from the commencement:
- Support
lawsuitvalues contiguous every time imaginable to promote the compiler to usagetableswitch. - Command
lawsuitstatements based mostly connected frequence of execution if recognized, possibly permitting the JIT compiler to additional optimize the codification.
Moreover, see these further factors:
- Usage the
defaultlawsuit to grip sudden values and forestall sudden behaviour. - Debar fallthrough except explicitly meant and intelligibly documented.
- Chart your codification to place show bottlenecks and optimize accordingly.
For much successful-extent accusation connected Java show tuning, cheque retired this assets: Java Show Tuning.
A new survey by [Authoritative Origin] recovered that⦠[See applicable statistic/information]
“Businesslike usage of control statements tin importantly contact general exertion show.” - [Adept Punctuation]
Larn much astir Java show optimization methods. [Infographic illustrating tableswitch vs. lookupswitch]
FAQ
Q: Does including much circumstances ever better control message show?
A: Not needfully. The show betterment relies upon connected whether or not the added circumstances let the compiler to control from lookupswitch to the much businesslike tableswitch.
The show of Java’s control message with contiguous integers is intricately linked to the compiler’s bytecode procreation and JIT optimizations. Piece including much instances tin generally pb to a show enhance, it’s not a assured result. Knowing the underlying mechanisms, using champion practices, and performing thorough investigating are important for penning businesslike and predictable codification. By contemplating these elements, builders tin leverage the afloat possible of the control message and optimize their Java purposes for optimum show. Research additional sources connected Java bytecode and compiler optimizations to deepen your knowing and refine your coding practices. See instruments similar JProfiler oregon VisualVM for much elaborate show investigation. Dive deeper into Java show tuning and unlock the afloat possible of your purposes.
Java Digital Device Specification: tableswitch
Java Control Message (Baeldung)
Question & Answer :
I americium running connected any Java codification which wants to beryllium extremely optimized arsenic it volition tally successful blistery features that are invoked astatine galore factors successful my chief programme logic. Portion of this codification includes multiplying treble variables by 10 raised to arbitrary non-antagonistic int exponents. 1 accelerated manner (edit: however not the quickest imaginable, seat Replace 2 beneath) to acquire the multiplied worth is to control connected the exponent:
treble multiplyByPowerOfTen(last treble d, last int exponent) { control (exponent) { lawsuit zero: instrument d; lawsuit 1: instrument d*10; lawsuit 2: instrument d*a hundred; // ... aforesaid form lawsuit 9: instrument d*one thousand million; lawsuit 10: instrument d*10000000000L; // ... aforesaid form with agelong literals lawsuit 18: instrument d*1000000000000000000L; default: propulsion fresh ParseException("Unhandled powerfulness of 10 " + powerfulness, zero); } }
The commented ellipses supra bespeak that the lawsuit int constants proceed incrementing by 1, truthful location are truly 19 lawsuits successful the supra codification snippet. Since I wasn’t certain whether or not I would really demand each the powers of 10 successful lawsuit statements 10 via 18, I ran any microbenchmarks evaluating the clip to absolute 10 cardinal operations with this control message versus a control with lone lawsuits zero through 9 (with the exponent constricted to 9 oregon little to debar breaking the pared-behind control). I received the instead amazing (to maine, astatine slightest!) consequence that the longer control with much lawsuit statements really ran quicker.
Connected a lark, I tried including equal much lawsuits which conscionable returned dummy values, and recovered that I might acquire the control to tally equal quicker with about 22-27 declared lawsuits (equal although these dummy instances are ne\’er really deed piece the codification is moving). (Once more, lawsuits have been added successful a contiguous manner by incrementing the anterior lawsuit changeless by 1.) These execution clip variations are not precise important: for a random exponent betwixt zero and 10, the dummy padded control message finishes 10 cardinal executions successful 1.forty nine secs versus 1.fifty four secs for the unpadded interpretation, for a expansive entire financial savings of 5ns per execution. Truthful, not the benignant of happening that makes obsessing complete padding retired a control message worthy the attempt from an optimization standpoint. However I inactive conscionable discovery it funny and antagonistic-intuitive that a control doesn’t go slower (oregon possibly astatine champion keep changeless O(1) clip) to execute arsenic much lawsuits are added to it.
These are the outcomes I obtained from moving with assorted limits connected the randomly-generated exponent values. I didn’t see the outcomes each the manner behind to 1 for the exponent bounds, however the broad form of the curve stays the aforesaid, with a ridge about the 12-17 lawsuit grade, and a vale betwixt 18-28. Each exams have been tally successful JUnitBenchmarks utilizing shared containers for the random values to guarantee equivalent investigating inputs. I besides ran the assessments some successful command from longest control message to shortest, and vice-versa, to attempt and destroy the expectation of ordering-associated trial issues. I’ve option my investigating codification ahead connected a github repo if anybody desires to attempt to reproduce these outcomes.
Truthful, what’s going connected present? Any vagaries of my structure oregon micro-benchmark operation? Oregon is the Java control truly a small quicker to execute successful the 18 to 28 lawsuit scope than it is from eleven ahead to 17?
github trial repo “control-experimentation”
Replace: I cleaned ahead the benchmarking room rather a spot and added a matter record successful /outcomes with any output crossed a wider scope of imaginable exponent values. I besides added an action successful the investigating codification not to propulsion an Objection from default, however this doesn’t look to impact the outcomes.
Replace 2: Recovered any beautiful bully treatment of this content from backmost successful 2009 connected the xkcd discussion board present: http://boards.xkcd.com/viewtopic.php?f=eleven&t=33524. The OP’s treatment of utilizing Array.binarySearch() gave maine the thought for a elemental array-based mostly implementation of the exponentiation form supra. Location’s nary demand for the binary hunt since I cognize what the entries successful the array are. It seems to tally astir three occasions sooner than utilizing control, evidently astatine the disbursal of any of the power travel that control affords. That codification has been added to the github repo besides.
Arsenic pointed retired by the another reply, due to the fact that the lawsuit values are contiguous (arsenic opposed to sparse), the generated bytecode for your assorted checks makes use of a control array (bytecode education tableswitch).
Nevertheless, erstwhile the JIT begins its occupation and compiles the bytecode into meeting, the tableswitch education does not ever consequence successful an array of pointers: generally the control array is remodeled into what seems similar a lookupswitch (akin to an if/other if construction).
Decompiling the meeting generated by the JIT (hotspot JDK 1.7) exhibits that it makes use of a succession of if/other if once location are 17 instances oregon little, an array of pointers once location are much than 18 (much businesslike).
The ground wherefore this magic figure of 18 is utilized appears to travel behind to the default worth of the MinJumpTableSize JVM emblem (about formation 352 successful the codification).
I person raised the content connected the hotspot compiler database and it appears to beryllium a bequest of ancient investigating. Line that this default worth has been eliminated successful JDK eight last much benchmarking was carried out.
Eventually, once the methodology turns into excessively agelong (> 25 circumstances successful my assessments), it is successful not inlined immoderate longer with the default JVM settings - that is the likeliest origin for the driblet successful show astatine that component.
With 5 circumstances, the decompiled codification seems similar this (announcement the cmp/je/jg/jmp directions, the meeting for if/goto):
[Verified Introduction Component] # {technique} 'multiplyByPowerOfTen' '(DI)D' successful 'javaapplication4/Test1' # parm0: xmm0:xmm0 = treble # parm1: rdx = int # [sp+0x20] (sp of caller) 0x00000000024f0160: mov DWORD PTR [rsp-0x6000],eax ; {no_reloc} 0x00000000024f0167: propulsion rbp 0x00000000024f0168: sub rsp,0x10 ;*synchronization introduction ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (formation fifty six) 0x00000000024f016c: cmp edx,0x3 0x00000000024f016f: je 0x00000000024f01c3 0x00000000024f0171: cmp edx,0x3 0x00000000024f0174: jg 0x00000000024f01a5 0x00000000024f0176: cmp edx,0x1 0x00000000024f0179: je 0x00000000024f019b 0x00000000024f017b: cmp edx,0x1 0x00000000024f017e: jg 0x00000000024f0191 0x00000000024f0180: trial edx,edx 0x00000000024f0182: je 0x00000000024f01cb 0x00000000024f0184: mov ebp,edx 0x00000000024f0186: mov edx,0x17 0x00000000024f018b: call 0x00000000024c90a0 ; OopMap{disconnected=forty eight} ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@seventy two (formation eighty three) ; {runtime_call} 0x00000000024f0190: int3 ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@seventy two (formation eighty three) 0x00000000024f0191: mulsd xmm0,QWORD PTR [rip+0xffffffffffffffa7] # 0x00000000024f0140 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@fifty two (formation sixty two) ; {section_word} 0x00000000024f0199: jmp 0x00000000024f01cb 0x00000000024f019b: mulsd xmm0,QWORD PTR [rip+0xffffffffffffff8d] # 0x00000000024f0130 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@forty six (formation 60) ; {section_word} 0x00000000024f01a3: jmp 0x00000000024f01cb 0x00000000024f01a5: cmp edx,0x5 0x00000000024f01a8: je 0x00000000024f01b9 0x00000000024f01aa: cmp edx,0x5 0x00000000024f01ad: jg 0x00000000024f0184 ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) 0x00000000024f01af: mulsd xmm0,QWORD PTR [rip+0xffffffffffffff81] # 0x00000000024f0138 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@sixty four (formation sixty six) ; {section_word} 0x00000000024f01b7: jmp 0x00000000024f01cb 0x00000000024f01b9: mulsd xmm0,QWORD PTR [rip+0xffffffffffffff67] # 0x00000000024f0128 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@70 (formation sixty eight) ; {section_word} 0x00000000024f01c1: jmp 0x00000000024f01cb 0x00000000024f01c3: mulsd xmm0,QWORD PTR [rip+0xffffffffffffff55] # 0x00000000024f0120 ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) ; {section_word} 0x00000000024f01cb: adhd rsp,0x10 0x00000000024f01cf: popular rbp 0x00000000024f01d0: trial DWORD PTR [rip+0xfffffffffdf3fe2a],eax # 0x0000000000430000 ; {poll_return} 0x00000000024f01d6: ret
With 18 circumstances, the meeting seems similar this (announcement the array of pointers which is utilized and suppresses the demand for each the comparisons: jmp QWORD PTR [r8+r10*1] jumps straight to the correct multiplication) - that is the apt ground for the show betterment:
[Verified Introduction Component] # {technique} 'multiplyByPowerOfTen' '(DI)D' successful 'javaapplication4/Test1' # parm0: xmm0:xmm0 = treble # parm1: rdx = int # [sp+0x20] (sp of caller) 0x000000000287fe20: mov DWORD PTR [rsp-0x6000],eax ; {no_reloc} 0x000000000287fe27: propulsion rbp 0x000000000287fe28: sub rsp,0x10 ;*synchronization introduction ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (formation fifty six) 0x000000000287fe2c: cmp edx,0x13 0x000000000287fe2f: jae 0x000000000287fe46 0x000000000287fe31: movsxd r10,edx 0x000000000287fe34: shl r10,0x3 0x000000000287fe38: movabs r8,0x287fd70 ; {section_word} 0x000000000287fe42: jmp QWORD PTR [r8+r10*1] ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) 0x000000000287fe46: mov ebp,edx 0x000000000287fe48: mov edx,0x31 0x000000000287fe4d: xchg ax,ax 0x000000000287fe4f: call 0x00000000028590a0 ; OopMap{disconnected=fifty two} ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@202 (formation ninety six) ; {runtime_call} 0x000000000287fe54: int3 ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@202 (formation ninety six) 0x000000000287fe55: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe8b] # 0x000000000287fce8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@194 (formation ninety two) ; {section_word} 0x000000000287fe5d: jmp 0x000000000287ff16 0x000000000287fe62: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe86] # 0x000000000287fcf0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@188 (formation ninety) ; {section_word} 0x000000000287fe6a: jmp 0x000000000287ff16 0x000000000287fe6f: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe81] # 0x000000000287fcf8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@182 (formation 88) ; {section_word} 0x000000000287fe77: jmp 0x000000000287ff16 0x000000000287fe7c: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe7c] # 0x000000000287fd00 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@176 (formation 86) ; {section_word} 0x000000000287fe84: jmp 0x000000000287ff16 0x000000000287fe89: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe77] # 0x000000000287fd08 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@a hundred and seventy (formation eighty four) ; {section_word} 0x000000000287fe91: jmp 0x000000000287ff16 0x000000000287fe96: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe72] # 0x000000000287fd10 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@164 (formation eighty two) ; {section_word} 0x000000000287fe9e: jmp 0x000000000287ff16 0x000000000287fea0: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe70] # 0x000000000287fd18 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@158 (formation eighty) ; {section_word} 0x000000000287fea8: jmp 0x000000000287ff16 0x000000000287feaa: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe6e] # 0x000000000287fd20 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@152 (formation seventy eight) ; {section_word} 0x000000000287feb2: jmp 0x000000000287ff16 0x000000000287feb4: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe24] # 0x000000000287fce0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@146 (formation seventy six) ; {section_word} 0x000000000287febc: jmp 0x000000000287ff16 0x000000000287febe: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe6a] # 0x000000000287fd30 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@one hundred forty (formation seventy four) ; {section_word} 0x000000000287fec6: jmp 0x000000000287ff16 0x000000000287fec8: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe68] # 0x000000000287fd38 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@134 (formation seventy two) ; {section_word} 0x000000000287fed0: jmp 0x000000000287ff16 0x000000000287fed2: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe66] # 0x000000000287fd40 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@128 (formation 70) ; {section_word} 0x000000000287feda: jmp 0x000000000287ff16 0x000000000287fedc: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe64] # 0x000000000287fd48 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@122 (formation sixty eight) ; {section_word} 0x000000000287fee4: jmp 0x000000000287ff16 0x000000000287fee6: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe62] # 0x000000000287fd50 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@116 (formation sixty six) ; {section_word} 0x000000000287feee: jmp 0x000000000287ff16 0x000000000287fef0: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe60] # 0x000000000287fd58 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@one hundred ten (formation sixty four) ; {section_word} 0x000000000287fef8: jmp 0x000000000287ff16 0x000000000287fefa: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe5e] # 0x000000000287fd60 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@104 (formation sixty two) ; {section_word} 0x000000000287ff02: jmp 0x000000000287ff16 0x000000000287ff04: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe5c] # 0x000000000287fd68 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@ninety eight (formation 60) ; {section_word} 0x000000000287ff0c: jmp 0x000000000287ff16 0x000000000287ff0e: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe12] # 0x000000000287fd28 ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) ; {section_word} 0x000000000287ff16: adhd rsp,0x10 0x000000000287ff1a: popular rbp 0x000000000287ff1b: trial DWORD PTR [rip+0xfffffffffd9b00df],eax # 0x0000000000230000 ; {poll_return} 0x000000000287ff21: ret
And eventually the meeting with 30 instances (beneath) appears to be like akin to 18 instances, but for the further movapd xmm0,xmm1 that seems in direction of the mediate of the codification, arsenic noticed by @cHao - nevertheless the likeliest ground for the driblet successful show is that the methodology is excessively agelong to beryllium inlined with the default JVM settings:
[Verified Introduction Component] # {methodology} 'multiplyByPowerOfTen' '(DI)D' successful 'javaapplication4/Test1' # parm0: xmm0:xmm0 = treble # parm1: rdx = int # [sp+0x20] (sp of caller) 0x0000000002524560: mov DWORD PTR [rsp-0x6000],eax ; {no_reloc} 0x0000000002524567: propulsion rbp 0x0000000002524568: sub rsp,0x10 ;*synchronization introduction ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (formation fifty six) 0x000000000252456c: movapd xmm1,xmm0 0x0000000002524570: cmp edx,0x1f 0x0000000002524573: jae 0x0000000002524592 ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) 0x0000000002524575: movsxd r10,edx 0x0000000002524578: shl r10,0x3 0x000000000252457c: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe3c] # 0x00000000025243c0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@364 (formation 118) ; {section_word} 0x0000000002524584: movabs r8,0x2524450 ; {section_word} 0x000000000252458e: jmp QWORD PTR [r8+r10*1] ;*tableswitch ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (formation fifty six) 0x0000000002524592: mov ebp,edx 0x0000000002524594: mov edx,0x31 0x0000000002524599: xchg ax,ax 0x000000000252459b: call 0x00000000024f90a0 ; OopMap{disconnected=sixty four} ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@370 (formation a hundred and twenty) ; {runtime_call} 0x00000000025245a0: int3 ;*fresh ; - javaapplication4.Test1::multiplyByPowerOfTen@370 (formation one hundred twenty) 0x00000000025245a1: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe27] # 0x00000000025243d0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@358 (formation 116) ; {section_word} 0x00000000025245a9: jmp 0x0000000002524744 0x00000000025245ae: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe22] # 0x00000000025243d8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@348 (formation 114) ; {section_word} 0x00000000025245b6: jmp 0x0000000002524744 0x00000000025245bb: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe1d] # 0x00000000025243e0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@338 (formation 112) ; {section_word} 0x00000000025245c3: jmp 0x0000000002524744 0x00000000025245c8: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe18] # 0x00000000025243e8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@328 (formation a hundred and ten) ; {section_word} 0x00000000025245d0: jmp 0x0000000002524744 0x00000000025245d5: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe13] # 0x00000000025243f0 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@318 (formation 108) ; {section_word} 0x00000000025245dd: jmp 0x0000000002524744 0x00000000025245e2: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe0e] # 0x00000000025243f8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@308 (formation 106) ; {section_word} 0x00000000025245ea: jmp 0x0000000002524744 0x00000000025245ef: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe09] # 0x0000000002524400 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@298 (formation 104) ; {section_word} 0x00000000025245f7: jmp 0x0000000002524744 0x00000000025245fc: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe04] # 0x0000000002524408 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@288 (formation 102) ; {section_word} 0x0000000002524604: jmp 0x0000000002524744 0x0000000002524609: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffdff] # 0x0000000002524410 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@278 (formation a hundred) ; {section_word} 0x0000000002524611: jmp 0x0000000002524744 0x0000000002524616: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffdfa] # 0x0000000002524418 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@268 (formation ninety eight) ; {section_word} 0x000000000252461e: jmp 0x0000000002524744 0x0000000002524623: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffd9d] # 0x00000000025243c8 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@258 (formation ninety six) ; {section_word} 0x000000000252462b: jmp 0x0000000002524744 0x0000000002524630: movapd xmm0,xmm1 0x0000000002524634: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffe0c] # 0x0000000002524448 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@242 (formation ninety two) ; {section_word} 0x000000000252463c: jmp 0x0000000002524744 0x0000000002524641: movapd xmm0,xmm1 0x0000000002524645: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffddb] # 0x0000000002524428 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@236 (formation ninety) ; {section_word} 0x000000000252464d: jmp 0x0000000002524744 0x0000000002524652: movapd xmm0,xmm1 0x0000000002524656: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffdd2] # 0x0000000002524430 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@230 (formation 88) ; {section_word} 0x000000000252465e: jmp 0x0000000002524744 0x0000000002524663: movapd xmm0,xmm1 0x0000000002524667: mulsd xmm0,QWORD PTR [rip+0xfffffffffffffdc9] # 0x0000000002524438 ;*dmul ; - javaapplication4.Test1::multiplyByPowerOfTen@224 (formation 86) ; {section_word} [and so forth.] 0x0000000002524744: adhd rsp,0x10 0x0000000002524748: popular rbp 0x0000000002524749: trial DWORD PTR [rip+0xfffffffffde1b8b1],eax # 0x0000000000340000 ; {poll_return} 0x000000000252474f: ret
