summary refs log blame commit diff stats
path: root/examples/rifle_different_file_opener.conf
blob: 695f27c67becce3eca71511d92c6a99f4574378c (plain) (tree)
1
2
3
4
5
6
7
8
9
                                            
 






                                                                               
# Compatible with ranger 1.6.0 through 1.7.*
#
# Replace your rifle.conf with this file to use xdg-open as your file opener.
# This is, of course, adaptable for use with any other file opener.
else = xdg-open "$1"

# You need an "editor" and "pager" in order to use certain functions in ranger:
label editor = "$EDITOR" -- "$@"
label pager  = "$PAGER" -- "$@"
#n258'>258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - subx/010---vm.cc</title>
<meta name="Generator" content="Vim/8.0">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="cpp">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.cSpecial { color: #008000; }
.LineNr { }
.Constant { color: #008787; }
.CommentedCode { color: #8a8a8a; }
.Delimiter { color: #c000c0; }
.Special { color: #d70000; }
.Identifier { color: #af5f00; }
.Normal { color: #000000; background-color: #c6c6c6; padding-bottom: 1px; }
.Comment { color: #005faf; }
.SalientComment { color: #0000af; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/subx/010---vm.cc'>https://github.com/akkartik/mu/blob/master/subx/010---vm.cc</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="Comment">//: Core data structures for simulating the SubX VM (subset of an x86 processor)</span>
<span id="L2" class="LineNr">  2 </span><span class="Comment">//:</span>
<span id="L3" class="LineNr">  3 </span><span class="Comment">//: At the lowest level (&quot;level 1&quot;) of abstraction, SubX executes x86</span>
<span id="L4" class="LineNr">  4 </span><span class="Comment">//: instructions provided in the form of an array of bytes, loaded into memory</span>
<span id="L5" class="LineNr">  5 </span><span class="Comment">//: starting at a specific address.</span>
<span id="L6" class="LineNr">  6 </span>
<span id="L7" class="LineNr">  7 </span><span class="SalientComment">//:: registers</span>
<span id="L8" class="LineNr">  8 </span><span class="Comment">//: assume segment registers are hard-coded to 0</span>
<span id="L9" class="LineNr">  9 </span><span class="Comment">//: no floating-point, MMX, etc. yet</span>
<span id="L10" class="LineNr"> 10 </span>
<span id="L11" class="LineNr"> 11 </span><span class="Delimiter">:(before &quot;End Types&quot;)</span>
<span id="L12" class="LineNr"> 12 </span><span class="Normal">enum</span> <span class="Delimiter">{</span>
<span id="L13" class="LineNr"> 13 </span>  <a href='010---vm.cc.html#L13'>EAX</a><span class="Delimiter">,</span>
<span id="L14" class="LineNr"> 14 </span>  <a href='010---vm.cc.html#L14'>ECX</a><span class="Delimiter">,</span>
<span id="L15" class="LineNr"> 15 </span>  <a href='010---vm.cc.html#L15'>EDX</a><span class="Delimiter">,</span>
<span id="L16" class="LineNr"> 16 </span>  <a href='010---vm.cc.html#L16'>EBX</a><span class="Delimiter">,</span>
<span id="L17" class="LineNr"> 17 </span>  <a href='010---vm.cc.html#L17'>ESP</a><span class="Delimiter">,</span>
<span id="L18" class="LineNr"> 18 </span>  <a href='010---vm.cc.html#L18'>EBP</a><span class="Delimiter">,</span>
<span id="L19" class="LineNr"> 19 </span>  <a href='010---vm.cc.html#L19'>ESI</a><span class="Delimiter">,</span>
<span id="L20" class="LineNr"> 20 </span>  <a href='010---vm.cc.html#L20'>EDI</a><span class="Delimiter">,</span>
<span id="L21" class="LineNr"> 21 </span>  <a href='010---vm.cc.html#L21'>NUM_INT_REGISTERS</a><span class="Delimiter">,</span>
<span id="L22" class="LineNr"> 22 </span><span class="Delimiter">};</span>
<span id="L23" class="LineNr"> 23 </span><span class="Normal">union</span> <a href='010---vm.cc.html#L23'>reg</a> <span class="Delimiter">{</span>
<span id="L24" class="LineNr"> 24 </span>  <span class="Normal">int32_t</span> i<span class="Delimiter">;</span>
<span id="L25" class="LineNr"> 25 </span>  <span class="Normal">uint32_t</span> u<span class="Delimiter">;</span>
<span id="L26" class="LineNr"> 26 </span><span class="Delimiter">};</span>
<span id="L27" class="LineNr"> 27 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L28" class="LineNr"> 28 </span><a href='010---vm.cc.html#L23'>reg</a> <span class="Special"><a href='010---vm.cc.html#L28'>Reg</a></span>[NUM_INT_REGISTERS] = <span class="Delimiter">{</span> <span class="Delimiter">{</span><span class="Constant">0</span><span class="Delimiter">}</span> <span class="Delimiter">};</span>
<span id="L29" class="LineNr"> 29 </span><span class="Normal">uint32_t</span> EIP = <span class="Constant">1</span><span class="Delimiter">;</span>  <span class="Comment">// preserve null pointer</span>
<span id="L30" class="LineNr"> 30 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span>
<span id="L31" class="LineNr"> 31 </span>bzero<span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L28'>Reg</a></span><span class="Delimiter">,</span> <span class="Normal">sizeof</span><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L28'>Reg</a></span><span class="Delimiter">));</span>
<span id="L32" class="LineNr"> 32 </span>EIP = <span class="Constant">1</span><span class="Delimiter">;</span>  <span class="Comment">// preserve null pointer</span>
<span id="L33" class="LineNr"> 33 </span>
<span id="L34" class="LineNr"> 34 </span><span class="Delimiter">:(before &quot;End <a href='001help.cc.html#L53'>Help</a> Contents&quot;)</span>
<span id="L35" class="LineNr"> 35 </span>cerr &lt;&lt; <span class="Constant">&quot;  registers\n&quot;</span><span class="Delimiter">;</span>
<span id="L36" class="LineNr"> 36 </span><span class="Delimiter">:(before &quot;End <a href='001help.cc.html#L53'>Help</a> Texts&quot;)</span>
<span id="L37" class="LineNr"> 37 </span><a href='001help.cc.html#L262'>put_new</a><span class="Delimiter">(</span><span class="Special"><a href='001help.cc.html#L53'>Help</a></span><span class="Delimiter">,</span> <span class="Constant">&quot;registers&quot;</span><span class="Delimiter">,</span>
<span id="L38" class="LineNr"> 38 </span>  <span class="Constant">&quot;SubX currently supports eight 32-bit integer registers. From 0 to 7, they are:\n&quot;</span>
<span id="L39" class="LineNr"> 39 </span>  <span class="Constant">&quot;  <a href='010---vm.cc.html#L13'>EAX</a> <a href='010---vm.cc.html#L14'>ECX</a> <a href='010---vm.cc.html#L15'>EDX</a> <a href='010---vm.cc.html#L16'>EBX</a> <a href='010---vm.cc.html#L17'>ESP</a> <a href='010---vm.cc.html#L18'>EBP</a> <a href='010---vm.cc.html#L19'>ESI</a> EDI\n&quot;</span>
<span id="L40" class="LineNr"> 40 </span>  <span class="Constant">&quot;ESP contains the top of the stack.\n&quot;</span>
<span id="L41" class="LineNr"> 41 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L42" class="LineNr"> 42 </span>  <span class="Constant">&quot;-- 8-bit registers\n&quot;</span>
<span id="L43" class="LineNr"> 43 </span>  <span class="Constant">&quot;Some instructions operate on eight *overlapping* 8-bit registers.\n&quot;</span>
<span id="L44" class="LineNr"> 44 </span>  <span class="Constant">&quot;From 0 to 7, they are:\n&quot;</span>
<span id="L45" class="LineNr"> 45 </span>  <span class="Constant">&quot;  AL CL DL BL AH CH DH BH\n&quot;</span>
<span id="L46" class="LineNr"> 46 </span>  <span class="Constant">&quot;The 8-bit registers overlap with the 32-bit ones. AL is the lowest signicant byte\n&quot;</span>
<span id="L47" class="LineNr"> 47 </span>  <span class="Constant">&quot;of <a href='010---vm.cc.html#L13'>EAX</a>, AH is the second lowest significant byte, and so on.\n&quot;</span>
<span id="L48" class="LineNr"> 48 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L49" class="LineNr"> 49 </span>  <span class="Constant">&quot;For example, if <a href='010---vm.cc.html#L16'>EBX</a> contains 0x11223344, then BL contains 0x44, and BH contains 0x33.\n&quot;</span>
<span id="L50" class="LineNr"> 50 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L51" class="LineNr"> 51 </span>  <span class="Constant">&quot;There is no way to access bytes within <a href='010---vm.cc.html#L17'>ESP</a>, <a href='010---vm.cc.html#L18'>EBP</a>, <a href='010---vm.cc.html#L19'>ESI</a> or EDI.\n&quot;</span>
<span id="L52" class="LineNr"> 52 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L53" class="LineNr"> 53 </span>  <span class="Constant">&quot;For complete details consult the IA-32 software developer's manual, volume 2,\n&quot;</span>
<span id="L54" class="LineNr"> 54 </span>  <span class="Constant">&quot;table 2-2, \&quot;</span><span class="Constant">32</span>-bit addressing forms with the ModR/<span class="Special">M</span> byte\<span class="Constant">&quot;.\n&quot;</span>
<span id="L55" class="LineNr"> 55 </span>  <span class="Constant">&quot;It is included in this repository as 'modrm.pdf'.\n&quot;</span>
<span id="L56" class="LineNr"> 56 </span>  <span class="Constant">&quot;The register encodings are described in the top row of the table, but you'll need\n&quot;</span>
<span id="L57" class="LineNr"> 57 </span>  <span class="Constant">&quot;to spend some time with it.\n&quot;</span>
<span id="L58" class="LineNr"> 58 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L59" class="LineNr"> 59 </span>  <span class="Constant">&quot;-- flag registers\n&quot;</span>
<span id="L60" class="LineNr"> 60 </span>  <span class="Constant">&quot;Various instructions (particularly 'compare') modify one or more of three 1-bit 'flag'\n&quot;</span>
<span id="L61" class="LineNr"> 61 </span>  <span class="Constant">&quot;registers, as a side-effect:\n&quot;</span>
<span id="L62" class="LineNr"> 62 </span>  <span class="Constant">&quot;- the sign flag (SF): usually set if an arithmetic result is negative, or\n&quot;</span>
<span id="L63" class="LineNr"> 63 </span>  <span class="Constant">&quot;  <a href='000organization.cc.html#L148'>reset</a> if not.\n&quot;</span>
<span id="L64" class="LineNr"> 64 </span>  <span class="Constant">&quot;- the zero flag (ZF): usually set if a result is zero, or <a href='000organization.cc.html#L148'>reset</a> if not.\n&quot;</span>
<span id="L65" class="LineNr"> 65 </span>  <span class="Constant">&quot;- the overflow flag (OF): usually set if an arithmetic result overflows.\n&quot;</span>
<span id="L66" class="LineNr"> 66 </span>  <span class="Constant">&quot;The flag bits are read by conditional jumps.\n&quot;</span>
<span id="L67" class="LineNr"> 67 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L68" class="LineNr"> 68 </span>  <span class="Constant">&quot;For complete details on how different instructions update the flags, consult the IA-32\n&quot;</span>
<span id="L69" class="LineNr"> 69 </span>  <span class="Constant">&quot;manual (volume 2). There's various versions of it online, such as <a href="https://c9x.me/x86">https://c9x.me/x86</a>,\n&quot;</span>
<span id="L70" class="LineNr"> 70 </span>  <span class="Constant">&quot;though of course you'll need to be careful to ignore instructions and flag registers\n&quot;</span>
<span id="L71" class="LineNr"> 71 </span>  <span class="Constant">&quot;that SubX doesn't support.\n&quot;</span>
<span id="L72" class="LineNr"> 72 </span>  <span class="Constant">&quot;\n&quot;</span>
<span id="L73" class="LineNr"> 73 </span>  <span class="Constant">&quot;It isn't simple, but if this is the processor you have running on your computer,\n&quot;</span>
<span id="L74" class="LineNr"> 74 </span>  <span class="Constant">&quot;might as well get good at it.\n&quot;</span>
<span id="L75" class="LineNr"> 75 </span><span class="Delimiter">);</span>
<span id="L76" class="LineNr"> 76 </span>
<span id="L77" class="LineNr"> 77 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L78" class="LineNr"> 78 </span><span class="Comment">// the subset of x86 flag registers we care about</span>
<span id="L79" class="LineNr"> 79 </span><span class="Normal">bool</span> SF =<span class="Constant"> false</span><span class="Delimiter">;</span>  <span class="Comment">// sign flag</span>
<span id="L80" class="LineNr"> 80 </span><span class="Normal">bool</span> ZF =<span class="Constant"> false</span><span class="Delimiter">;</span>  <span class="Comment">// zero flag</span>
<span id="L81" class="LineNr"> 81 </span><span class="Normal">bool</span> <a href='010---vm.cc.html#L81'>OF</a> =<span class="Constant"> false</span><span class="Delimiter">;</span>  <span class="Comment">// overflow flag</span>
<span id="L82" class="LineNr"> 82 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span>
<span id="L83" class="LineNr"> 83 </span>SF = ZF = <a href='010---vm.cc.html#L81'>OF</a> =<span class="Constant"> false</span><span class="Delimiter">;</span>
<span id="L84" class="LineNr"> 84 </span>
<span id="L85" class="LineNr"> 85 </span><span class="Comment">//: how the flag registers are updated after each instruction</span>
<span id="L86" class="LineNr"> 86 </span>
<span id="L87" class="LineNr"> 87 </span><span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span id="L88" class="LineNr"> 88 </span><span class="Comment">// Combine 'arg1' and 'arg2' with arithmetic operation 'op' and store the</span>
<span id="L89" class="LineNr"> 89 </span><span class="Comment">// result in 'arg1', then update flags.</span>
<span id="L90" class="LineNr"> 90 </span><span class="Comment">// beware: no side-effects in args</span>
<span id="L91" class="LineNr"> 91 </span><span class="Comment">#define BINARY_ARITHMETIC_OP(op, arg1, arg2) { \</span>
<span id="L92" class="LineNr"> 92 </span>  <span class="Comment">/*</span><span class="Comment"> arg1 and arg2 must be signed </span><span class="Comment">*/</span> \
<span id="L93" class="LineNr"> 93 </span>  <span class="Normal">int64_t</span> tmp = arg1 op arg2<span class="Delimiter">;</span> \
<span id="L94" class="LineNr"> 94 </span>  arg1 = arg1 op arg2<span class="Delimiter">;</span> \
<span id="L95" class="LineNr"> 95 </span>  <a href='003trace.cc.html#L183'>trace</a><span class="Delimiter">(</span><span class="Constant">90</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;storing 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; arg1 &lt;&lt; end<span class="Delimiter">();</span> \
<span id="L96" class="LineNr"> 96 </span>  SF = <span class="Delimiter">(</span>arg1 &lt; <span class="Constant">0</span><span class="Delimiter">);</span> \
<span id="L97" class="LineNr"> 97 </span>  ZF = <span class="Delimiter">(</span>arg1 == <span class="Constant">0</span><span class="Delimiter">);</span> \
<span id="L98" class="LineNr"> 98 </span>  <a href='010---vm.cc.html#L81'>OF</a> = <span class="Delimiter">(</span>arg1 != tmp<span class="Delimiter">);</span> \
<span id="L99" class="LineNr"> 99 </span><span class="Delimiter">}</span>
<span id="L100" class="LineNr">100 </span>
<span id="L101" class="LineNr">101 </span><span class="Comment">// Combine 'arg1' and 'arg2' with bitwise operation 'op' and store the result</span>
<span id="L102" class="LineNr">102 </span><span class="Comment">// in 'arg1', then update flags.</span>
<span id="L103" class="LineNr">103 </span><span class="Comment">#define BINARY_BITWISE_OP(op, arg1, arg2) { \</span>
<span id="L104" class="LineNr">104 </span>  <span class="Comment">/*</span><span class="Comment"> arg1 and arg2 must be unsigned </span><span class="Comment">*/</span> \
<span id="L105" class="LineNr">105 </span>  arg1 = arg1 op arg2<span class="Delimiter">;</span> \
<span id="L106" class="LineNr">106 </span>  <a href='003trace.cc.html#L183'>trace</a><span class="Delimiter">(</span><span class="Constant">90</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;storing 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; arg1 &lt;&lt; end<span class="Delimiter">();</span> \
<span id="L107" class="LineNr">107 </span>  SF = <span class="Delimiter">(</span>arg1 &gt;&gt; <span class="Constant">31</span><span class="Delimiter">);</span> \
<span id="L108" class="LineNr">108 </span>  ZF = <span class="Delimiter">(</span>arg1 == <span class="Constant">0</span><span class="Delimiter">);</span> \
<span id="L109" class="LineNr">109 </span>  <a href='010---vm.cc.html#L81'>OF</a> =<span class="Constant"> false</span><span class="Delimiter">;</span> \
<span id="L110" class="LineNr">110 </span><span class="Delimiter">}</span>
<span id="L111" class="LineNr">111 </span>
<span id="L112" class="LineNr">112 </span><span class="SalientComment">//:: simulated RAM</span>
<span id="L113" class="LineNr">113 </span>
<span id="L114" class="LineNr">114 </span><span class="Delimiter">:(before &quot;End Types&quot;)</span>
<span id="L115" class="LineNr">115 </span><span class="Normal">const</span> <span class="Normal">uint32_t</span> <a href='010---vm.cc.html#L115'>SEGMENT_ALIGNMENT</a> = <span class="Constant">0x1000000</span><span class="Delimiter">;</span>  <span class="Comment">// 16MB</span>
<span id="L116" class="LineNr">116 </span><span class="Normal">inline</span> <span class="Normal">uint32_t</span> <a href='010---vm.cc.html#L116'>align_upwards</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> x<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> align<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L117" class="LineNr">117 </span>  <span class="Identifier">return</span> <span class="Delimiter">(</span>x+align-<span class="Constant">1</span><span class="Delimiter">)</span> &amp; -<span class="Delimiter">(</span>align<span class="Delimiter">);</span>
<span id="L118" class="LineNr">118 </span><span class="Delimiter">}</span>
<span id="L119" class="LineNr">119 </span>
<span id="L120" class="LineNr">120 </span><span class="Comment">// Like in real-world Linux, we'll allocate RAM for our programs in disjoint</span>
<span id="L121" class="LineNr">121 </span><span class="Comment">// slabs called VMAs or Virtual Memory Areas.</span>
<span id="L122" class="LineNr">122 </span><span class="Normal">struct</span> vma <span class="Delimiter">{</span>
<span id="L123" class="LineNr">123 </span>  <span class="Normal">uint32_t</span> start<span class="Delimiter">;</span>  <span class="Comment">// inclusive</span>
<span id="L124" class="LineNr">124 </span>  <span class="Normal">uint32_t</span> end<span class="Delimiter">;</span>  <span class="Comment">// exclusive</span>
<span id="L125" class="LineNr">125 </span>  vector&lt;<span class="Normal">uint8_t</span>&gt; <a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">;</span>
<span id="L126" class="LineNr">126 </span>  vma<span class="Delimiter">(</span><span class="Normal">uint32_t</span> s<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> e<span class="Delimiter">)</span> :start<span class="Delimiter">(</span>s<span class="Delimiter">),</span> end<span class="Delimiter">(</span>e<span class="Delimiter">)</span> <span class="Delimiter">{}</span>
<span id="L127" class="LineNr">127 </span>  vma<span class="Delimiter">(</span><span class="Normal">uint32_t</span> s<span class="Delimiter">)</span> :start<span class="Delimiter">(</span>s<span class="Delimiter">),</span> end<span class="Delimiter">(</span><a href='010---vm.cc.html#L116'>align_upwards</a><span class="Delimiter">(</span>s+<span class="Constant">1</span><span class="Delimiter">,</span> <a href='010---vm.cc.html#L115'>SEGMENT_ALIGNMENT</a><span class="Delimiter">))</span> <span class="Delimiter">{}</span>
<span id="L128" class="LineNr">128 </span>  <span class="Normal">bool</span> <a href='010---vm.cc.html#L128'>match</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> a<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L129" class="LineNr">129 </span>    <span class="Identifier">return</span> a &gt;= start &amp;&amp; a &lt; end<span class="Delimiter">;</span>
<span id="L130" class="LineNr">130 </span>  <span class="Delimiter">}</span>
<span id="L131" class="LineNr">131 </span>  <span class="Normal">bool</span> <a href='010---vm.cc.html#L131'>match32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> a<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L132" class="LineNr">132 </span>    <span class="Identifier">return</span> a &gt;= start &amp;&amp; a+<span class="Constant">4</span> &lt;= end<span class="Delimiter">;</span>
<span id="L133" class="LineNr">133 </span>  <span class="Delimiter">}</span>
<span id="L134" class="LineNr">134 </span>  <span class="Normal">uint8_t</span>&amp; data<span class="Delimiter">(</span><span class="Normal">uint32_t</span> a<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L135" class="LineNr">135 </span>    assert<span class="Delimiter">(</span><a href='010---vm.cc.html#L128'>match</a><span class="Delimiter">(</span>a<span class="Delimiter">));</span>
<span id="L136" class="LineNr">136 </span>    <span class="Normal">uint32_t</span> result_index = a-start<span class="Delimiter">;</span>
<span id="L137" class="LineNr">137 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">.</span>size<span class="Delimiter">()</span> &lt;= result_index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L138" class="LineNr">138 </span>      <span class="Normal">const</span> <span class="Normal">int</span> align = <span class="Constant">0x1000</span><span class="Delimiter">;</span>
<span id="L139" class="LineNr">139 </span>      <span class="Normal">uint32_t</span> result_size = result_index + <span class="Constant">1</span><span class="Delimiter">;</span>  <span class="Comment">// size needed for result_index to be valid</span>
<span id="L140" class="LineNr">140 </span>      <span class="Normal">uint32_t</span> new_size = <a href='010---vm.cc.html#L116'>align_upwards</a><span class="Delimiter">(</span>result_size<span class="Delimiter">,</span> align<span class="Delimiter">);</span>
<span id="L141" class="LineNr">141 </span>      <span class="Comment">// grow at least 2x to maintain some amortized complexity guarantees</span>
<span id="L142" class="LineNr">142 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>new_size &lt; <a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">.</span>size<span class="Delimiter">()</span> * <span class="Constant">2</span><span class="Delimiter">)</span>
<span id="L143" class="LineNr">143 </span>        new_size = <a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">.</span>size<span class="Delimiter">()</span> * <span class="Constant">2</span><span class="Delimiter">;</span>
<span id="L144" class="LineNr">144 </span>      <span class="Comment">// never grow past the stated limit</span>
<span id="L145" class="LineNr">145 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>new_size &gt; end-start<span class="Delimiter">)</span>
<span id="L146" class="LineNr">146 </span>        new_size = end-start<span class="Delimiter">;</span>
<span id="L147" class="LineNr">147 </span>      <a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">.</span>resize<span class="Delimiter">(</span>new_size<span class="Delimiter">);</span>
<span id="L148" class="LineNr">148 </span>    <span class="Delimiter">}</span>
<span id="L149" class="LineNr">149 </span>    <span class="Identifier">return</span> <a href='010---vm.cc.html#L125'>_data</a><span class="Delimiter">.</span>at<span class="Delimiter">(</span>result_index<span class="Delimiter">);</span>
<span id="L150" class="LineNr">150 </span>  <span class="Delimiter">}</span>
<span id="L151" class="LineNr">151 </span>  <span class="Normal">void</span> <a href='010---vm.cc.html#L151'>grow_until</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> new_end_address<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L152" class="LineNr">152 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>new_end_address &lt; end<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L153" class="LineNr">153 </span>    <span class="Comment">// Ugly: vma knows about the global Memory list of vmas</span>
<span id="L154" class="LineNr">154 </span>    <span class="Normal">void</span> <a href='010---vm.cc.html#L161'>sanity_check</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> start<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> end<span class="Delimiter">);</span>
<span id="L155" class="LineNr">155 </span>    <a href='010---vm.cc.html#L161'>sanity_check</a><span class="Delimiter">(</span>start<span class="Delimiter">,</span> new_end_address<span class="Delimiter">);</span>
<span id="L156" class="LineNr">156 </span>    end = new_end_address<span class="Delimiter">;</span>
<span id="L157" class="LineNr">157 </span>  <span class="Delimiter">}</span>
<span id="L158" class="LineNr">158 </span>  <span class="Comment">// End vma Methods</span>
<span id="L159" class="LineNr">159 </span><span class="Delimiter">};</span>
<span id="L160" class="LineNr">160 </span><span class="Delimiter">:(code)</span>
<span id="L161" class="LineNr">161 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L161'>sanity_check</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> start<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> end<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L162" class="LineNr">162 </span>  <span class="Normal">bool</span> dup_found =<span class="Constant"> false</span><span class="Delimiter">;</span>
<span id="L163" class="LineNr">163 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L166'>SIZE</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L164" class="LineNr">164 </span>    <span class="Normal">const</span> vma&amp; curr = <span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">);</span>
<span id="L165" class="LineNr">165 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>start == start<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L166" class="LineNr">166 </span>      assert<span class="Delimiter">(</span>!dup_found<span class="Delimiter">);</span>
<span id="L167" class="LineNr">167 </span>      dup_found =<span class="Constant"> true</span><span class="Delimiter">;</span>
<span id="L168" class="LineNr">168 </span>    <span class="Delimiter">}</span>
<span id="L169" class="LineNr">169 </span>    <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>start &gt; start<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L170" class="LineNr">170 </span>      assert<span class="Delimiter">(</span>curr<span class="Delimiter">.</span>start &gt; end<span class="Delimiter">);</span>
<span id="L171" class="LineNr">171 </span>    <span class="Delimiter">}</span>
<span id="L172" class="LineNr">172 </span>    <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>start &lt; start<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L173" class="LineNr">173 </span>      assert<span class="Delimiter">(</span>curr<span class="Delimiter">.</span>end &lt; start<span class="Delimiter">);</span>
<span id="L174" class="LineNr">174 </span>    <span class="Delimiter">}</span>
<span id="L175" class="LineNr">175 </span>  <span class="Delimiter">}</span>
<span id="L176" class="LineNr">176 </span><span class="Delimiter">}</span>
<span id="L177" class="LineNr">177 </span>
<span id="L178" class="LineNr">178 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L179" class="LineNr">179 </span><span class="Comment">// RAM is made of VMAs.</span>
<span id="L180" class="LineNr">180 </span>vector&lt;vma&gt; <span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">;</span>
<span id="L181" class="LineNr">181 </span><span class="Delimiter">:(code)</span>
<span id="L182" class="LineNr">182 </span><span class="Comment">// The first 3 VMAs are special. When loading ELF binaries in later layers,</span>
<span id="L183" class="LineNr">183 </span><span class="Comment">// we'll assume that the first VMA is for code, the second is for data</span>
<span id="L184" class="LineNr">184 </span><span class="Comment">// (including the heap), and the third for the stack.</span>
<span id="L185" class="LineNr">185 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L185'>grow_code_segment</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> new_end_address<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L186" class="LineNr">186 </span>  assert<span class="Delimiter">(</span>!<span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
<span id="L187" class="LineNr">187 </span>  <span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span><a href='010---vm.cc.html#L151'>grow_until</a><span class="Delimiter">(</span>new_end_address<span class="Delimiter">);</span>
<span id="L188" class="LineNr">188 </span><span class="Delimiter">}</span>
<span id="L189" class="LineNr">189 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L189'>grow_data_segment</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> new_end_address<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L190" class="LineNr">190 </span>  assert<span class="Delimiter">(</span><a href='001help.cc.html#L166'>SIZE</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L191" class="LineNr">191 </span>  <span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span><a href='010---vm.cc.html#L151'>grow_until</a><span class="Delimiter">(</span>new_end_address<span class="Delimiter">);</span>
<span id="L192" class="LineNr">192 </span><span class="Delimiter">}</span>
<span id="L193" class="LineNr">193 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L194" class="LineNr">194 </span><span class="Normal">uint32_t</span> <span class="Special"><a href='010---vm.cc.html#L194'>End_of_program</a></span> = <span class="Constant">0</span><span class="Delimiter">;</span>  <span class="Comment">// when the program executes past this address in tests we'll stop the test</span>
<span id="L195" class="LineNr">195 </span><span class="Comment">// The stack grows downward. Can't increase its size for now.</span>
<span id="L196" class="LineNr">196 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span>
<span id="L197" class="LineNr">197 </span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
<span id="L198" class="LineNr">198 </span><span class="Special"><a href='010---vm.cc.html#L194'>End_of_program</a></span> = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L199" class="LineNr">199 </span><span class="Delimiter">:(code)</span>
<span id="L200" class="LineNr">200 </span><span class="Comment">// These helpers depend on Mem being laid out contiguously (so you can't use a</span>
<span id="L201" class="LineNr">201 </span><span class="Comment">// map, etc.) and on the host also being little-endian.</span>
<span id="L202" class="LineNr">202 </span><span class="Normal">inline</span> <span class="Normal">uint8_t</span> <a href='010---vm.cc.html#L202'>read_mem_u8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L203" class="LineNr">203 </span>  <span class="Normal">uint8_t</span>* handle = <a href='010---vm.cc.html#L217'>mem_addr_u8</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>  <span class="Comment">// error messages get printed here</span>
<span id="L204" class="LineNr">204 </span>  <span class="Identifier">return</span> handle ? *handle : <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L205" class="LineNr">205 </span><span class="Delimiter">}</span>
<span id="L206" class="LineNr">206 </span><span class="Normal">inline</span> <span class="Normal">int8_t</span> <a href='010---vm.cc.html#L206'>read_mem_i8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L207" class="LineNr">207 </span>  <span class="Identifier">return</span> <span class="Normal">static_cast</span>&lt;<span class="Normal">int8_t</span>&gt;<span class="Delimiter">(</span><a href='010---vm.cc.html#L202'>read_mem_u8</a><span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L208" class="LineNr">208 </span><span class="Delimiter">}</span>
<span id="L209" class="LineNr">209 </span><span class="Normal">inline</span> <span class="Normal">uint32_t</span> <a href='010---vm.cc.html#L209'>read_mem_u32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L210" class="LineNr">210 </span>  <span class="Normal">uint32_t</span>* handle = <a href='010---vm.cc.html#L233'>mem_addr_u32</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>  <span class="Comment">// error messages get printed here</span>
<span id="L211" class="LineNr">211 </span>  <span class="Identifier">return</span> handle ? *handle : <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L212" class="LineNr">212 </span><span class="Delimiter">}</span>
<span id="L213" class="LineNr">213 </span><span class="Normal">inline</span> <span class="Normal">int32_t</span> <a href='010---vm.cc.html#L213'>read_mem_i32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L214" class="LineNr">214 </span>  <span class="Identifier">return</span> <span class="Normal">static_cast</span>&lt;<span class="Normal">int32_t</span>&gt;<span class="Delimiter">(</span><a href='010---vm.cc.html#L209'>read_mem_u32</a><span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L215" class="LineNr">215 </span><span class="Delimiter">}</span>
<span id="L216" class="LineNr">216 </span>
<span id="L217" class="LineNr">217 </span><span class="Normal">inline</span> <span class="Normal">uint8_t</span>* <a href='010---vm.cc.html#L217'>mem_addr_u8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L218" class="LineNr">218 </span>  <span class="Normal">uint8_t</span>* result = <span class="Constant">NULL</span><span class="Delimiter">;</span>
<span id="L219" class="LineNr">219 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L166'>SIZE</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L220" class="LineNr">220 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span><a href='010---vm.cc.html#L128'>match</a><span class="Delimiter">(</span>addr<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L221" class="LineNr">221 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>result<span class="Delimiter">)</span>
<span id="L222" class="LineNr">222 </span>        <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;address 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; addr &lt;&lt; <span class="Constant">&quot; is in two segments\n&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L223" class="LineNr">223 </span>      result = &amp;<span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>data<span class="Delimiter">(</span>addr<span class="Delimiter">);</span>
<span id="L224" class="LineNr">224 </span>    <span class="Delimiter">}</span>
<span id="L225" class="LineNr">225 </span>  <span class="Delimiter">}</span>
<span id="L226" class="LineNr">226 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>result == <span class="Constant">NULL</span><span class="Delimiter">)</span>
<span id="L227" class="LineNr">227 </span>    <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;Tried to access uninitialized memory at address 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; addr &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L228" class="LineNr">228 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L229" class="LineNr">229 </span><span class="Delimiter">}</span>
<span id="L230" class="LineNr">230 </span><span class="Normal">inline</span> <span class="Normal">int8_t</span>* <a href='010---vm.cc.html#L230'>mem_addr_i8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L231" class="LineNr">231 </span>  <span class="Identifier">return</span> <span class="Normal">reinterpret_cast</span>&lt;<span class="Normal">int8_t</span>*&gt;<span class="Delimiter">(</span><a href='010---vm.cc.html#L217'>mem_addr_u8</a><span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L232" class="LineNr">232 </span><span class="Delimiter">}</span>
<span id="L233" class="LineNr">233 </span><span class="Normal">inline</span> <span class="Normal">uint32_t</span>* <a href='010---vm.cc.html#L233'>mem_addr_u32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L234" class="LineNr">234 </span>  <span class="Normal">uint32_t</span>* result = <span class="Constant">NULL</span><span class="Delimiter">;</span>
<span id="L235" class="LineNr">235 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L166'>SIZE</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L236" class="LineNr">236 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span><a href='010---vm.cc.html#L131'>match32</a><span class="Delimiter">(</span>addr<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L237" class="LineNr">237 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>result<span class="Delimiter">)</span>
<span id="L238" class="LineNr">238 </span>        <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;address 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; addr &lt;&lt; <span class="Constant">&quot; is in two segments\n&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L239" class="LineNr">239 </span>      result = <span class="Normal">reinterpret_cast</span>&lt;<span class="Normal">uint32_t</span>*&gt;<span class="Delimiter">(</span>&amp;<span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>data<span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L240" class="LineNr">240 </span>    <span class="Delimiter">}</span>
<span id="L241" class="LineNr">241 </span>  <span class="Delimiter">}</span>
<span id="L242" class="LineNr">242 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>result == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L243" class="LineNr">243 </span>    <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;Tried to access uninitialized memory at address 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; addr &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L244" class="LineNr">244 </span>    <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;The entire 4-byte <a href='011run.cc.html#L119'>word</a> should be initialized and lie in a single segment.\n&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L245" class="LineNr">245 </span>  <span class="Delimiter">}</span>
<span id="L246" class="LineNr">246 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L247" class="LineNr">247 </span><span class="Delimiter">}</span>
<span id="L248" class="LineNr">248 </span><span class="Normal">inline</span> <span class="Normal">int32_t</span>* <a href='010---vm.cc.html#L248'>mem_addr_i32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L249" class="LineNr">249 </span>  <span class="Identifier">return</span> <span class="Normal">reinterpret_cast</span>&lt;<span class="Normal">int32_t</span>*&gt;<span class="Delimiter">(</span><a href='010---vm.cc.html#L233'>mem_addr_u32</a><span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L250" class="LineNr">250 </span><span class="Delimiter">}</span>
<span id="L251" class="LineNr">251 </span><span class="Comment">// helper for some syscalls. But read-only.</span>
<span id="L252" class="LineNr">252 </span><span class="Normal">inline</span> <span class="Normal">const</span> <span class="Normal">char</span>* <a href='010---vm.cc.html#L252'>mem_addr_kernel_string</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L253" class="LineNr">253 </span>  <span class="Identifier">return</span> <span class="Normal">reinterpret_cast</span>&lt;<span class="Normal">const</span> <span class="Normal">char</span>*&gt;<span class="Delimiter">(</span><a href='010---vm.cc.html#L217'>mem_addr_u8</a><span class="Delimiter">(</span>addr<span class="Delimiter">));</span>
<span id="L254" class="LineNr">254 </span><span class="Delimiter">}</span>
<span id="L255" class="LineNr">255 </span><span class="Normal">inline</span> string <a href='010---vm.cc.html#L255'>mem_addr_string</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> size<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L256" class="LineNr">256 </span>  ostringstream out<span class="Delimiter">;</span>
<span id="L257" class="LineNr">257 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">size_t</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; size<span class="Delimiter">;</span>  ++i<span class="Delimiter">)</span>
<span id="L258" class="LineNr">258 </span>    out &lt;&lt; <a href='010---vm.cc.html#L202'>read_mem_u8</a><span class="Delimiter">(</span>addr+i<span class="Delimiter">);</span>
<span id="L259" class="LineNr">259 </span>  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span id="L260" class="LineNr">260 </span><span class="Delimiter">}</span>
<span id="L261" class="LineNr">261 </span>
<span id="L262" class="LineNr">262 </span>
<span id="L263" class="LineNr">263 </span><span class="Normal">inline</span> <span class="Normal">void</span> <a href='010---vm.cc.html#L263'>write_mem_u8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">,</span> <span class="Normal">uint8_t</span> val<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L264" class="LineNr">264 </span>  <span class="Normal">uint8_t</span>* handle = <a href='010---vm.cc.html#L217'>mem_addr_u8</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>
<span id="L265" class="LineNr">265 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>handle != <span class="Constant">NULL</span><span class="Delimiter">)</span> *handle = val<span class="Delimiter">;</span>
<span id="L266" class="LineNr">266 </span><span class="Delimiter">}</span>
<span id="L267" class="LineNr">267 </span><span class="Normal">inline</span> <span class="Normal">void</span> <a href='010---vm.cc.html#L267'>write_mem_i8</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">,</span> <span class="Normal">int8_t</span> val<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L268" class="LineNr">268 </span>  <span class="Normal">int8_t</span>* handle = <a href='010---vm.cc.html#L230'>mem_addr_i8</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>
<span id="L269" class="LineNr">269 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>handle != <span class="Constant">NULL</span><span class="Delimiter">)</span> *handle = val<span class="Delimiter">;</span>
<span id="L270" class="LineNr">270 </span><span class="Delimiter">}</span>
<span id="L271" class="LineNr">271 </span><span class="Normal">inline</span> <span class="Normal">void</span> <a href='010---vm.cc.html#L271'>write_mem_u32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">,</span> <span class="Normal">uint32_t</span> val<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L272" class="LineNr">272 </span>  <span class="Normal">uint32_t</span>* handle = <a href='010---vm.cc.html#L233'>mem_addr_u32</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>
<span id="L273" class="LineNr">273 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>handle != <span class="Constant">NULL</span><span class="Delimiter">)</span> *handle = val<span class="Delimiter">;</span>
<span id="L274" class="LineNr">274 </span><span class="Delimiter">}</span>
<span id="L275" class="LineNr">275 </span><span class="Normal">inline</span> <span class="Normal">void</span> <a href='010---vm.cc.html#L275'>write_mem_i32</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">,</span> <span class="Normal">int32_t</span> val<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L276" class="LineNr">276 </span>  <span class="Normal">int32_t</span>* handle = <a href='010---vm.cc.html#L248'>mem_addr_i32</a><span class="Delimiter">(</span>addr<span class="Delimiter">);</span>
<span id="L277" class="LineNr">277 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>handle != <span class="Constant">NULL</span><span class="Delimiter">)</span> *handle = val<span class="Delimiter">;</span>
<span id="L278" class="LineNr">278 </span><span class="Delimiter">}</span>
<span id="L279" class="LineNr">279 </span>
<span id="L280" class="LineNr">280 </span><span class="Normal">inline</span> <span class="Normal">bool</span> <a href='010---vm.cc.html#L280'>already_allocated</a><span class="Delimiter">(</span><span class="Normal">uint32_t</span> addr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L281" class="LineNr">281 </span>  <span class="Normal">bool</span> result =<span class="Constant"> false</span><span class="Delimiter">;</span>
<span id="L282" class="LineNr">282 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L166'>SIZE</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L283" class="LineNr">283 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L180'>Mem</a></span><span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span><a href='010---vm.cc.html#L128'>match</a><span class="Delimiter">(</span>addr<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L284" class="LineNr">284 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>result<span class="Delimiter">)</span>
<span id="L285" class="LineNr">285 </span>        <a href='003trace.cc.html#L190'>raise</a> &lt;&lt; <span class="Constant">&quot;address 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; addr &lt;&lt; <span class="Constant">&quot; is in two segments\n&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L286" class="LineNr">286 </span>      result =<span class="Constant"> true</span><span class="Delimiter">;</span>
<span id="L287" class="LineNr">287 </span>    <span class="Delimiter">}</span>
<span id="L288" class="LineNr">288 </span>  <span class="Delimiter">}</span>
<span id="L289" class="LineNr">289 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L290" class="LineNr">290 </span><span class="Delimiter">}</span>
<span id="L291" class="LineNr">291 </span>
<span id="L292" class="LineNr">292 </span><span class="SalientComment">//:: core interpreter loop</span>
<span id="L293" class="LineNr">293 </span>
<span id="L294" class="LineNr">294 </span><span class="Delimiter">:(code)</span>
<span id="L295" class="LineNr">295 </span><span class="Comment">// skeleton of how x86 instructions are decoded</span>
<span id="L296" class="LineNr">296 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L296'>run_one_instruction</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L297" class="LineNr">297 </span>  <span class="Normal">uint8_t</span> op=<span class="Constant">0</span><span class="Delimiter">,</span> op2=<span class="Constant">0</span><span class="Delimiter">,</span> op3=<span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L298" class="LineNr">298 </span>  <span class="Comment">// Run One Instruction</span>
<span id="L299" class="LineNr">299 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><span class="Special"><a href='003trace.cc.html#L168'>Dump_trace</a></span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L300" class="LineNr">300 </span>    cerr &lt;&lt; <span class="Constant">&quot;registers: &quot;</span><span class="Delimiter">;</span>
<span id="L301" class="LineNr">301 </span>    <a href='010---vm.cc.html#L368'>dump_registers</a><span class="Delimiter">();</span>
<span id="L302" class="LineNr">302 </span><span class="CommentedCode">//?     dump_stack();  // for debugging; not defined until later layer</span>
<span id="L303" class="LineNr">303 </span>  <span class="Delimiter">}</span>
<span id="L304" class="LineNr">304 </span>  <a href='003trace.cc.html#L183'>trace</a><span class="Delimiter">(</span><span class="Constant">90</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;inst: 0x&quot;</span> &lt;&lt; <a href='010---vm.cc.html#L413'>HEXWORD</a> &lt;&lt; EIP &lt;&lt; end<span class="Delimiter">();</span>
<span id="L305" class="LineNr">305 </span>  op = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">();</span>
<span id="L306" class="LineNr">306 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><span class="Special"><a href='003trace.cc.html#L168'>Dump_trace</a></span><span class="Delimiter">)</span> cerr &lt;&lt; <span class="Constant">&quot;opcode: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L307" class="LineNr">307 </span>  <span class="Normal">switch</span> <span class="Delimiter">(</span>op<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L308" class="LineNr">308 </span>  <span class="Normal">case</span> <span class="Constant">0xf4</span>:  <span class="Comment">// hlt</span>
<span id="L309" class="LineNr">309 </span>    EIP = <span class="Special"><a href='010---vm.cc.html#L194'>End_of_program</a></span><span class="Delimiter">;</span>
<span id="L310" class="LineNr">310 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L311" class="LineNr">311 </span>  <span class="Comment">// End Single-Byte Opcodes</span>
<span id="L312" class="LineNr">312 </span>  <span class="Normal">case</span> <span class="Constant">0x0f</span>:
<span id="L313" class="LineNr">313 </span>    <span class="Normal">switch</span><span class="Delimiter">(</span>op2 = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L314" class="LineNr">314 </span>    <span class="Comment">// End Two-Byte Opcodes Starting With 0f</span>
<span id="L315" class="LineNr">315 </span>    <span class="Normal">default</span>:
<span id="L316" class="LineNr">316 </span>      cerr &lt;&lt; <span class="Constant">&quot;unrecognized second opcode after 0f: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op2<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L317" class="LineNr">317 </span>      <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L318" class="LineNr">318 </span>      exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L319" class="LineNr">319 </span>    <span class="Delimiter">}</span>
<span id="L320" class="LineNr">320 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L321" class="LineNr">321 </span>  <span class="Normal">case</span> <span class="Constant">0xf2</span>:
<span id="L322" class="LineNr">322 </span>    <span class="Normal">switch</span><span class="Delimiter">(</span>op2 = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L323" class="LineNr">323 </span>    <span class="Comment">// End Two-Byte Opcodes Starting With f2</span>
<span id="L324" class="LineNr">324 </span>    <span class="Normal">case</span> <span class="Constant">0x0f</span>:
<span id="L325" class="LineNr">325 </span>      <span class="Normal">switch</span><span class="Delimiter">(</span>op3 = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L326" class="LineNr">326 </span>      <span class="Comment">// End Three-Byte Opcodes Starting With f2 0f</span>
<span id="L327" class="LineNr">327 </span>      <span class="Normal">default</span>:
<span id="L328" class="LineNr">328 </span>        cerr &lt;&lt; <span class="Constant">&quot;unrecognized third opcode after f2 0f: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op3<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L329" class="LineNr">329 </span>        <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L330" class="LineNr">330 </span>        exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L331" class="LineNr">331 </span>      <span class="Delimiter">}</span>
<span id="L332" class="LineNr">332 </span>      <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L333" class="LineNr">333 </span>    <span class="Normal">default</span>:
<span id="L334" class="LineNr">334 </span>      cerr &lt;&lt; <span class="Constant">&quot;unrecognized second opcode after f2: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op2<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L335" class="LineNr">335 </span>      <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L336" class="LineNr">336 </span>      exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L337" class="LineNr">337 </span>    <span class="Delimiter">}</span>
<span id="L338" class="LineNr">338 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L339" class="LineNr">339 </span>  <span class="Normal">case</span> <span class="Constant">0xf3</span>:
<span id="L340" class="LineNr">340 </span>    <span class="Normal">switch</span><span class="Delimiter">(</span>op2 = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L341" class="LineNr">341 </span>    <span class="Comment">// End Two-Byte Opcodes Starting With f3</span>
<span id="L342" class="LineNr">342 </span>    <span class="Normal">case</span> <span class="Constant">0x0f</span>:
<span id="L343" class="LineNr">343 </span>      <span class="Normal">switch</span><span class="Delimiter">(</span>op3 = <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L344" class="LineNr">344 </span>      <span class="Comment">// End Three-Byte Opcodes Starting With f3 0f</span>
<span id="L345" class="LineNr">345 </span>      <span class="Normal">default</span>:
<span id="L346" class="LineNr">346 </span>        cerr &lt;&lt; <span class="Constant">&quot;unrecognized third opcode after f3 0f: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op3<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L347" class="LineNr">347 </span>        <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L348" class="LineNr">348 </span>        exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L349" class="LineNr">349 </span>      <span class="Delimiter">}</span>
<span id="L350" class="LineNr">350 </span>      <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L351" class="LineNr">351 </span>    <span class="Normal">default</span>:
<span id="L352" class="LineNr">352 </span>      cerr &lt;&lt; <span class="Constant">&quot;unrecognized second opcode after f3: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op2<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L353" class="LineNr">353 </span>      <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L354" class="LineNr">354 </span>      exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L355" class="LineNr">355 </span>    <span class="Delimiter">}</span>
<span id="L356" class="LineNr">356 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L357" class="LineNr">357 </span>  <span class="Normal">default</span>:
<span id="L358" class="LineNr">358 </span>    cerr &lt;&lt; <span class="Constant">&quot;unrecognized opcode: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L412'>HEXBYTE</a> &lt;&lt; <a href='010---vm.cc.html#L415'>NUM</a><span class="Delimiter">(</span>op<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L359" class="LineNr">359 </span>    <a href='003trace.cc.html#L187'>DUMP</a><span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span>
<span id="L360" class="LineNr">360 </span>    exit<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L361" class="LineNr">361 </span>  <span class="Delimiter">}</span>
<span id="L362" class="LineNr">362 </span><span class="Delimiter">}</span>
<span id="L363" class="LineNr">363 </span>
<span id="L364" class="LineNr">364 </span><span class="Normal">inline</span> <span class="Normal">uint8_t</span> <a href='010---vm.cc.html#L364'>next</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L365" class="LineNr">365 </span>  <span class="Identifier">return</span> <a href='010---vm.cc.html#L202'>read_mem_u8</a><span class="Delimiter">(</span>EIP++<span class="Delimiter">);</span>
<span id="L366" class="LineNr">366 </span><span class="Delimiter">}</span>
<span id="L367" class="LineNr">367 </span>
<span id="L368" class="LineNr">368 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L368'>dump_registers</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L369" class="LineNr">369 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='010---vm.cc.html#L21'>NUM_INT_REGISTERS</a><span class="Delimiter">;</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L370" class="LineNr">370 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>i &gt; <span class="Constant">0</span><span class="Delimiter">)</span> cerr &lt;&lt; <span class="Constant">&quot;; &quot;</span><span class="Delimiter">;</span>
<span id="L371" class="LineNr">371 </span>    cerr &lt;&lt; <span class="Constant">&quot;  &quot;</span> &lt;&lt; i &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; std::hex &lt;&lt; std::setw<span class="Delimiter">(</span><span class="Constant">8</span><span class="Delimiter">)</span> &lt;&lt; std::setfill<span class="Delimiter">(</span><span class="Constant">'_'</span><span class="Delimiter">)</span> &lt;&lt; <span class="Special"><a href='010---vm.cc.html#L28'>Reg</a></span>[i]<span class="Delimiter">.</span>u<span class="Delimiter">;</span>
<span id="L372" class="LineNr">372 </span>  <span class="Delimiter">}</span>
<span id="L373" class="LineNr">373 </span>  cerr &lt;&lt; <span class="Constant">&quot; -- SF: &quot;</span> &lt;&lt; SF &lt;&lt; <span class="Constant">&quot;; ZF: &quot;</span> &lt;&lt; ZF &lt;&lt; <span class="Constant">&quot;; <a href='010---vm.cc.html#L81'>OF</a>: &quot;</span> &lt;&lt; <a href='010---vm.cc.html#L81'>OF</a> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L374" class="LineNr">374 </span><span class="Delimiter">}</span>
<span id="L375" class="LineNr">375 </span>
<span id="L376" class="LineNr">376 </span><span class="Comment">//: start tracking supported opcodes</span>
<span id="L377" class="LineNr">377 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L378" class="LineNr">378 </span>map&lt;<span class="Comment">/*</span><span class="Comment">op</span><span class="Comment">*/</span>string<span class="Delimiter">,</span> string&gt; <span class="Special"><a href='010---vm.cc.html#L378'>Name</a></span><span class="Delimiter">;</span>
<span id="L379" class="LineNr">379 </span>map&lt;<span class="Comment">/*</span><span class="Comment">op</span><span class="Comment">*/</span>string<span class="Delimiter">,</span> string&gt; <span class="Special"><a href='010---vm.cc.html#L379'>Name_0f</a></span><span class="Delimiter">;</span>
<span id="L380" class="LineNr">380 </span>map&lt;<span class="Comment">/*</span><span class="Comment">op</span><span class="Comment">*/</span>string<span class="Delimiter">,</span> string&gt; <span class="Special"><a href='010---vm.cc.html#L380'>Name_f3</a></span><span class="Delimiter">;</span>
<span id="L381" class="LineNr">381 </span>map&lt;<span class="Comment">/*</span><span class="Comment">op</span><span class="Comment">*/</span>string<span class="Delimiter">,</span> string&gt; <span class="Special"><a href='010---vm.cc.html#L381'>Name_f3_0f</a></span><span class="Delimiter">;</span>
<span id="L382" class="LineNr">382 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span>
<span id="L383" class="LineNr">383 </span><a href='010---vm.cc.html#L385'>init_op_names</a><span class="Delimiter">();</span>
<span id="L384" class="LineNr">384 </span><span class="Delimiter">:(code)</span>
<span id="L385" class="LineNr">385 </span><span class="Normal">void</span> <a href='010---vm.cc.html#L385'>init_op_names</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L386" class="LineNr">386 </span>  <a href='001help.cc.html#L252'>put</a><span class="Delimiter">(</span><span class="Special"><a href='010---vm.cc.html#L378'>Name</a></span><span class="Delimiter">,</span> <span class="Constant">&quot;f4&quot;</span><span class="Delimiter">,</span> <span class="Constant">&quot;halt (hlt)&quot;</span><span class="Delimiter">);</span>
<span id="L387" class="LineNr">387 </span>  <span class="Comment">// End Initialize Op Names</span>
<span id="L388" class="LineNr">388 </span><span class="Delimiter">}</span>
<span id="L389" class="LineNr">389 </span>
<span id="L390" class="LineNr">390 </span><span class="Delimiter">:(before &quot;End <a href='001help.cc.html#L53'>Help</a> Special-cases(key)&quot;)</span>
<span id="L391" class="LineNr">391 </span><span class="Normal">if</span> <span class="Delimiter">(</span>key == <span class="Constant">&quot;opcodes&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L392" class="LineNr">392 </span>  cerr &lt;&lt; <span class="Constant">&quot;Opcodes currently supported by SubX:\n&quot;</span><span class="Delimiter">;</span>
<span id="L393" class="LineNr">393 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> string&gt;::iterator p = <span class="Special"><a href='010---vm.cc.html#L378'>Name</a></span><span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != <span class="Special"><a href='010---vm.cc.html#L378'>Name</a></span><span class="Delimiter">.</span>end<span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span>
<span id="L394" class="LineNr">394 </span>    cerr &lt;&lt; <span class="Constant">&quot;  &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>second &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L395" class="LineNr">395 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> string&gt;::iterator p = <span class="Special"><a href='010---vm.cc.html#L379'>Name_0f</a></span><span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != <span class="Special"><a href='010---vm.cc.html#L379'>Name_0f</a></span><span class="Delimiter">.</span>end<span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span>
<span id="L396" class="LineNr">396 </span>    cerr &lt;&lt; <span class="Constant">&quot;  0f &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>second &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L397" class="LineNr">397 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> string&gt;::iterator p = <span class="Special"><a href='010---vm.cc.html#L380'>Name_f3</a></span><span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != <span class="Special"><a href='010---vm.cc.html#L380'>Name_f3</a></span><span class="Delimiter">.</span>end<span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span>
<span id="L398" class="LineNr">398 </span>    cerr &lt;&lt; <span class="Constant">&quot;  f3 &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>second &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L399" class="LineNr">399 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> string&gt;::iterator p = <span class="Special"><a href='010---vm.cc.html#L381'>Name_f3_0f</a></span><span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != <span class="Special"><a href='010---vm.cc.html#L381'>Name_f3_0f</a></span><span class="Delimiter">.</span>end<span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span>
<span id="L400" class="LineNr">400 </span>    cerr &lt;&lt; <span class="Constant">&quot;  f3 0f &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>second &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
<span id="L401" class="LineNr">401 </span>  cerr &lt;&lt; <span class="Constant">&quot;Run `subx help instructions` for details on <a href='011run.cc.html#L114'>words</a> like 'r32' and 'disp8'.\n&quot;</span>
<span id="L402" class="LineNr">402 </span>          <span class="Constant">&quot;For complete details on these instructions, consult the IA-32 manual (volume 2).\n&quot;</span>
<span id="L403" class="LineNr">403 </span>          <span class="Constant">&quot;There's various versions of it online, such as <a href="https://c9x.me/x86">https://c9x.me/x86</a>.\n&quot;</span>
<span id="L404" class="LineNr">404 </span>          <span class="Constant">&quot;The mnemonics in brackets will help you locate each instruction.\n&quot;</span><span class="Delimiter">;</span>
<span id="L405" class="LineNr">405 </span>  <span class="Identifier">return</span> <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L406" class="LineNr">406 </span><span class="Delimiter">}</span>
<span id="L407" class="LineNr">407 </span><span class="Delimiter">:(before &quot;End <a href='001help.cc.html#L53'>Help</a> Contents&quot;)</span>
<span id="L408" class="LineNr">408 </span>cerr &lt;&lt; <span class="Constant">&quot;  opcodes\n&quot;</span><span class="Delimiter">;</span>
<span id="L409" class="LineNr">409 </span>
<span id="L410" class="LineNr">410 </span><span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span id="L411" class="LineNr">411 </span><span class="Comment">#include &lt;iomanip&gt;</span>
<span id="L412" class="LineNr">412 </span><span class="Comment">#define HEXBYTE  std::hex &lt;&lt; std::setw(2) &lt;&lt; std::setfill('0')</span>
<span id="L413" class="LineNr">413 </span><span class="Comment">#define HEXWORD  std::hex &lt;&lt; std::setw(8) &lt;&lt; std::setfill('0')</span>
<span id="L414" class="LineNr">414 </span><span class="Comment">// ugly that iostream doesn't print uint8_t as an integer</span>
<span id="L415" class="LineNr">415 </span><span class="Comment">#define NUM(X) static_cast&lt;int&gt;(X)</span>
<span id="L416" class="LineNr">416 </span><span class="Comment">#include &lt;stdint.h&gt;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->