create account

Writing a simple Compiler on my own - Simple Examples in MIPS Assembly by drifter1

View this thread on steemit.com
· @drifter1 ·
$19.19
Writing a simple Compiler on my own - Simple Examples in MIPS Assembly
<html>
https://i.postimg.cc/brMKYfqD/compiler-series.jpg<br>
[Custom Thumbnail]<br>
All the Code of the series can be found at the <strong>Github repository</strong>:
https://github.com/drifter1/compiler
<hr>
<h1>Introduction</h1>&nbsp;&nbsp;&nbsp;&nbsp;Hello it's a me again @drifter1! Today we continue with my <strong>Compiler Series</strong>, a series where we implement a complete compiler for a simple C-like language by using the C-tools Flex and Bison. In this article <strong>we will write the simple examples that we used through-out the series in MIPS Assembly Code</strong>. To understand this article, I highly suggest you to go read my previous article about the MIPS Instruction Set...
<h2>Requirements:</h2>&nbsp;&nbsp;&nbsp;&nbsp;Actually <strong>you need to read and understand all the topics that I covered in the series as a whole</strong>, as these articles will give you access to knowledge about:<ul>
<li>What Compiler Design is (mainly the steps)</li>
<li>For which exact Language the Compiler is build for (Tokens and Grammar)</li>
<li>How to use Flex and Bison</li>
<li>How to implement a lexer and parser for the language using those tools</li>
<li>What the Symbol Table is and how we implement it</li>
<li>How we combine Flex and Bison together</li>
<li>How we can pass information from the Lexer to the Parser</li>
<li>How we define operator priorities, precedencies and associativity</li>
<li>What Semantic Analysis is (Attributes, SDT etc.)</li>
<li>How we do the so called "Scope Resolution"</li>
<li>How we declare types and check the type inter-compatibility for different cases that include function parameters and assignments</li>
<li>How we check function calls later on using a "Revisit queue", as function declarations mostly happen after functions get used (in our Language)</li>
<li>Intermediate Code Representations, including AST's</li>
<li>How we implement an AST (structure and management)</li>
<li>Action Rules for AST nodes and more</li>
<li>The target system's architecture and its assembly language (MIPS)</li>
</ul>
<h2>Difficulty:</h2>Talking about the <strong>series in general</strong> this series can be rated:
<ul><li>Intermediate to Advanced</li></ul>
<strong>Today's topic(s)</strong> can be rated:
<ul><li>Medium</li></ul>
So, without further ado, let's now finally start with the actual Tutorial...
<hr>
<h1>Actual Tutorial Content</h1>
<h2>Example 1</h2>&nbsp;&nbsp;&nbsp;&nbsp;The first example code that we saw during the series had no functions and did only one simple calculation using two variables. More specifically, we just define three variables: one integer i and two doubles val and res, and initialize the double val to 2.5 and set the value of the other double res to be equal to the value of val plus 1 (res = val + 1). The integer i is of no use, but still worth mentioning as you can see how we declare such a variable...<br><br>
Either way, the code that I'm talking about is:<br>
<pre><code>// declarations
int i;
double val, res;
// statements
val = 2.5;
res = val + 1;
return;</code></pre><br>
So, how do we turn this Simple-C code into MIPS Assembly?
<h3>Data Declarations</h3>&nbsp;&nbsp;&nbsp;&nbsp;An integer takes up 4 bytes of space, which are called a word and so we can use the keyword ".word" to define the integer. For the first one we of course also have to give an initialization value, let's say zero (0). On the other hand, an double takes up 8 bytes of space, that we will have to input manually using the keyword ".space". For testing purposes we will also define a new line message: "\n", so that we can print out the values of the two doubles in two different lines of the console.<br><br>
Therefore, the ".data" section is:<br>
<pre><code>.data
  i:	 .word	 0
val:	 .space	 8	 # $f0
res:	 .space	 8	 # $f2
newline: .asciiz "\n"</code></pre>
&nbsp;&nbsp;&nbsp;&nbsp;In the comments of this code you can also see that I "map" val to the register $f0 and res to the register $f2, as the arithmetic operation of addition has to be applied on the FP registers and cannot be applied on the memory.
<h3>Instructions</h3>&nbsp;&nbsp;&nbsp;&nbsp;So, now for the main instructions-section. First, we should initialize the variable val to 2.5, by setting the floating point register $f0 and the space that we declared previously to that value. This can be done quite simply by loading the immediate value 2.5 to the register $f0 and then storing the register to the memory space that we allocated for this variables. In other word we write:<br>
<pre><code>li.d $f0, 2.5
s.d $f0, val</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;Next up, is the addition of 1 to the value of the register val, that will give us the value of res (result). For that we will have to load the immediate value 1.0 into another register, so that we can use that value in the add instruction. So, loading the value 1.0 to register $f4 and adding that value to the value of $f0 and storing this value to $f2, we are basically done. In the end, $f2 will contain the result of val + 1. After that, we can also store that result to memory. So, we have:<br>
<pre><code>li.d $f4, 1.0
add.d $f2, $f0, $f4
s.d $f2, res</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;After that we can do 3 system calls, to print out the 2 doubles and a new line character in-between of each of those prints. In code, this looks like this:<br>
<pre><code>li $v0, 3
mov.d $f12, $f0
syscall<br>
li $v0, 4
la $a0, newline
syscall<br>
li $v0, 3
mov.d $f12, $f2
syscall</code></pre>
<br>
Finally, we also have to terminate the program writing:<br>
<pre><code>li $v0, 10
syscall</code></pre>
<h3>Console Output</h3>
The final MIPS code for this program is:<br>
<pre><code>.data
  i:	 .word	 0
val:	 .space	 8	 # $f0
res:	 .space	 8	 # $f2
newline: .asciiz "\n"<br>
.text
main:<br>
# val = 2.5
li.d $f0, 2.5
s.d $f0, val<br>
# res = val + 1
li.d $f4, 1.0
add.d $f2, $f0, $f4
s.d $f2, res<br>
# print values for testing
li $v0, 3
mov.d $f12, $f0
syscall<br>
li $v0, 4
la $a0, newline
syscall<br>
li $v0, 3
mov.d $f12, $f2
syscall<br>
# terminate program
li $v0, 10
syscall</code></pre>
<br>
Running it in <a href="http://spimsimulator.sourceforge.net/">QtSpim</a> we get:<br>
https://i.postimg.cc/tgLLy7qP/image.png<br><br>
2.5 is the value of val, whilst 3.5 is the value of res.
<hr>
<h2>Example 2</h2>&nbsp;&nbsp;&nbsp;&nbsp;After this warm-up, let's now get into a more interesting example, which is example2.c. The code of this example is:<br>
<pre><code>// declarations
int i;
double val = 2.5, res[10];
// statements
for(i = 0; i < 10; i++){
    res[i] = operation(val, i);
    val = res[i];
    print(res[i]);
    print('\n');
}
return;
// functions
double operation (double value, int i){ 
    // declarations
    double res;
    // statements
    res = value*i + i;
    return res;
}</code></pre>
<br>
Let's again start by declaring the variables...
<h3>Data declaration</h3>&nbsp;&nbsp;&nbsp;&nbsp;Here we have one integer, one double and one double array of 10 entries. Taking a look at the print() functions that occur through-out the code, we can also see that a "\n" message is needed and so we will use the same that we define previously. So, similar to the previous example, we will define the integer i as a ".word" with initial value 0, the double val as a ".space" of byte-size 8 and lastly the array will be a ".space" of size 80, so that it can store 10 doubles (10x8 = 80).<br><br>
The ".data" section's code thus is:<br>
<pre><code>.data
  i:	 .word	 0   # $f4 as FP
val:	 .space	 8	 # $f2
res:	 .space	 80	 # array with 10 doubles
newline: .asciiz "\n"</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;You can again see how I "map" the various variables to registers. As we are talking about floating point operations, the integer i will have to be converted to a double, and so we map it to the FP register $f4. Similar to before we also define a register for val, supposing that the  variable will be stored inside of $f2.
<h3>Instructions</h3>&nbsp;&nbsp;&nbsp;&nbsp;Similar to before, we have to initialize the variable val to 2.5, by setting the register $f2 to 2.5 and storing that value to the memory space that we allocated for that purpose. So, the first part of the ".text" section is:<br>
<pre><code>.text
main:<br>
    # val = 2.5
    li.d $f2, 2.5
    s.d $f2, val</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;After that we get to meet our friend the for-loop (!).As we have to store values back to the array, but also have to use the loop counter by itself, we basically have to define two loop counters that will increment simultaneously. The register $t0 will be the "actual" loop counter that will go from 0 to 9 in steps of 1, whilst $t1 will be an address counter that will go from 0 to 72, incrementing in steps of 8. The exit condition of value 10 will be stored in the register $t2.<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;So, knowing that the value of $t0 needs to be less than the value 10, we will use the reverse-logic to branch out of the loop when the value of the counter becomes 10 or more (greater equal). Thus, we will use the branch if greater equal (bge) branch instruction. At the end of the for loop's body we will jump back to the start using a simple j-Jump. So, the basic structure of our for-loop is:<br>
<pre><code># for loop
li $t0, 0	# i = 0
li $t1, 0	# address counter
li $t2, 10	# exit condition
for: bge $t0, $t2, end_for	# i < 10
    ....
    other instructions
    ...<br>
    # i++
    addi $t0, $t0, 1
    addi $t1, $t1, 4
    j for
end_for:</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;The operands/parameters of the "operation"-function are stored in $f2 and $t0, and so we can easily write the function. In a separate label below the main function we will have to convert the int to a double, storing the value of i in a FP register, let's say $f4. After that we can easily apply the value*i = i operation and return the result in another FP register, let's say $f0. In the end, we have to return back using jr $ra, as $ra stores the address of the instruction after the function call, that is done using jal. Either way, the operation function looks like this:<br>
<pre><code>operation:
	# convert int to double
	mtc1.d $t0, $f4
	cvt.d.w $f4, $f4
	# $f4 contains i<br>
	# res = value*i + i
	mul.d $f0, $f2, $f4
	add.d $f0, $f0, $f4<br>
	# return value in $f0
	jr $ra</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;Don't be to scared about that first part! We simply, move a value from the general-purpose registers of the MIPS CPU to the Co-processor that does floating point operations. So, the value of $t0 gets stored into $f4. The second instruction, basically converts the integer value into a double value. The rest is easier to understand, I think.<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;So, getting back to the for-loop's body, we call the function that we defined seconds ago using "jal operation", and then simply store the result to the res array, using the store instruction "s.d". After that we also have to "move" that value into the val register $f2, by also storing this value into memory (lots of optimizations could be made here, as only storing into the array is necessary). The code for these three things is:<br>
<pre><code># temp = operation(val, i)
# val in $f2
# i in $t0
jal operation<br>
# res[i] = temp
s.d $f0, res($t1)<br>
# val = res[i]
mov.d $f2, $f0
s.d $f2, val($0)
</code></pre>
<br>
After that we only have to print out the value that we got in that step, using:<br>
<pre><code># print(res[i])
li $v0, 3
mov.d $f12, $f0
syscall<br>
# print("\n")
li $v0, 4
la $a0, newline
syscall</code></pre>
<h3>Console Output</h3>The complete code looks like this:<br>
<pre><code>.data
  i:	 .word	 0   # $f4 as FP
val:	 .space	 8	 # $f2
res:	 .space	 80	 # array with 10 doubles
newline: .asciiz "\n"<br>
.text
main:<br>
	# val = 2.5
	li.d $f2, 2.5
	s.d $f2, val<br>
	# for loop
	li $t0, 0	# i = 0
	li $t1, 0	# address counter
	li $t2, 10	# exit condition
	for: bge $t0, $t2, end_for	# i < 10
		# temp = operation(val, i)
		# val in $f2
		# i in $t0
		jal operation<br>
		# res[i] = temp
		s.d $f0, res($t1)<br>
		# val = res[i]
		mov.d $f2, $f0
		s.d $f2, val($0)<br>
		# print(res[i])
		li $v0, 3
		mov.d $f12, $f0
		syscall<br>
		# print("\n")
		li $v0, 4
		la $a0, newline
		syscall<br>
		# i++
		addi $t0, $t0, 1
		addi $t1, $t1, 4
		j for
	end_for:<br>
	# terminate program
	li $v0, 10
	syscall<br>
operation:
	# convert int to double
	mtc1.d $t0, $f4
	cvt.d.w $f4, $f4
	# $f4 contains i<br>
	# res = value*i + i
	mul.d $f0, $f2, $f4
	add.d $f0, $f0, $f4<br>
	# return value in $f0
	jr $ra</code></pre>
<br>
Running the code in the console we get:<br>
https://i.postimg.cc/dt0fpgrG/image.png<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;As you can see the initial value of val is useless, as it gets multiplied by 0 and gets the final value 0. The result at each step is equal to the previous result multiplied by the current step's loop counter, that gets also added to the loop counter's value.
<hr>
<h2>RESOURCES</h2>
<h3>References:</h3>
No references, just using code that I implemented in my previous articles.
<h3>Images:</h3>
All of the images are custom-made!
<hr>
<h2>Previous parts of the series</h2>
<h3>General Knowledge and Lexical Analysis</h3>
<ul>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-introduction">Introduction</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-a-simple-c-language">A simple C Language</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-lexical-analysis-using-flex">Lexical Analysis using Flex</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-symbol-table-basic-structure">Symbol Table (basic structure)</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-using-symbol-tables-in-the-lexer">Using Symbol Table in the Lexer</a></li>
</ul>
<h3>Syntax Analysis</h3>
</ul>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-syntax-analysis-theory">Syntax Analysis Theory</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-bison-basics">Bison basics</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-creating-a-grammar-for-our-language">Creating a grammar for our Language</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-combine-flex-and-bison">Combine Flex and Bison</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-passing-information-from-lexer-to-parser">Passing information from Lexer to Parser</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-finishing-off-the-grammer-parser-part-1">Finishing Off The Grammar/Parser (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-finishing-off-the-grammar-parser-part-2-c-flex-bison">Finishing Off The Grammar/Parser (part 2)</a></li>
</ul>
<h3>Semantic Analysis (1)</h3>
</ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-semantic-analysis-theory-c-flex-bison">Semantic Analysis Theory</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-semantics-examples-c-flex-bison">Semantics Examples</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own---scope-resolution-using-the-symbol-table-cflexbison">Scope Resolution using the Symbol Table</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-type-declaration-and-checking-c-flex-bison">Type Declaration and Checking</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-function-semantics-part-1-c-flex-bison">Function Semantics (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-function-semantics-part-2-c-flex-bison">Function Semantics (part 2)</a></li>
</ul>
<h3>Intermediate Code Generation (AST)</h3>
</ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison">Abstract Syntax Tree Principle</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-structure-c-flex-bison">Abstract Syntax Tree Structure</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-management-c-flex-bison">Abstract Syntax Tree Management</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-declarations-and-initializations-c-flex-bison">Action Rules for Declarations and Initializations</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-expressions-c-flex-bison">Action Rules for Expressions</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-assignments-and-simple-statements-c-flex-bison">Action Rules for Assignments and Simple Statements</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-if-else-statements-c-flex-bison">Action Rules for  If-Else Statements</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-loop-statements-and-some-fixes-c-flex-bison">Action Rules for Loop Statements and some Fixes</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-declarations-part-1-c-flex-bison">Action Rules for Function Declarations (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-declarations-part-2-c-flex-bison">Action Rules for Function Declarations (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-calls-c-flex-bison">Action Rules for Function Calls</a></li>
</ul>
<h3>Semantic Analysis (2)</h3>
</ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-datatype-attribute-for-expressions-c-flex-bison">Datatype attribute for Expressions</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-type-checking-for-assignments-c-flex-bison">Type Checking for Assignments </a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-1-c-flex-bison">Revisit Queue and Parameter Checking (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-2-c-flex-bison">Revisit Queue and Parameter Checking (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-3-c-flex-bison">Revisit Queue and Parameter Checking (part 3)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-4-c-flex-bison">Revisit Queue and Parameter Checking (part 4)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-1-c-flex-bison">Revisit Queue and Assignment Checking (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-2-c-flex-bison">Revisit Queue and Assignment Checking (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-3-c-flex-bison">Revisit Queue and Assignment Checking (part 3)</a></li>
</ul>
<h3>Machine Code Generation</h3>
<ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-machine-code-generation-principles">Machine Code Generation Principles</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-mips-instruction-set">MIPS Instruction Set</a></li>
</ul>
<hr>
<h2>Final words | Next up on the project</h2>&nbsp;&nbsp;&nbsp;&nbsp; And this is actually it for today's post! I hope that I explained everything as much as I needed to. Next time, we will write the "full_example.c" file in MIPS Assembly!<br><br>
Next up on this series, in general, are:
<ul>
<li>Machine Code generation (MIPS Assembly)</li>
<li>Various Optimizations in the Compiler's Code</li>
</ul>
<br>
&nbsp;&nbsp;&nbsp;&nbsp; Which are all topics for which we will need more than one article to complete them. Also, note that we might also get into AST Code Optimizations later on, or that we could even extend the Language by adding complex datatypes (structs and unions), more rules etc.<br>
So, see ya next time!
<hr>
<h2>GitHub Account:</h2>
https://github.com/drifter1<br>
https://steemitimages.com/0x0/https://media.giphy.com/media/ybITzMzIyabIs/giphy.gif
<br>
Keep on drifting! ;)
</html>
πŸ‘  , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , and 46 others
properties (23)
post_id76,544,086
authordrifter1
permlinkwriting-a-simple-compiler-on-my-own-simple-examples-in-mips-assembly
categoryutopian-io
json_metadata{"community":"busy","app":"busy\/2.5.6","format":"markdown","tags":["utopian-io","tutorials","busy","programming","compiler"],"users":["drifter1"],"links":["https:\/\/github.com\/drifter1\/compiler","\/@drifter1","http:\/\/spimsimulator.sourceforge.net\/","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-introduction","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-a-simple-c-language","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-lexical-analysis-using-flex","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-symbol-table-basic-structure","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-using-symbol-tables-in-the-lexer","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-syntax-analysis-theory","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-bison-basics"],"image":["https:\/\/i.postimg.cc\/brMKYfqD\/compiler-series.jpg","https:\/\/i.postimg.cc\/tgLLy7qP\/image.png","https:\/\/i.postimg.cc\/dt0fpgrG\/image.png","https:\/\/steemitimages.com\/0x0\/https:\/\/media.giphy.com\/media\/ybITzMzIyabIs\/giphy.gif"]}
created2019-06-17 15:24:12
last_update2019-06-17 15:24:12
depth0
children4
net_rshares33,240,715,502,370
last_payout2019-06-24 15:24:12
cashout_time1969-12-31 23:59:59
total_payout_value14.623 SBD
curator_payout_value4.565 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length21,509
author_reputation56,378,187,690,347
root_title"Writing a simple Compiler on my own - Simple Examples in MIPS Assembly"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (110)
@portugalcoin ·
$12.55
Thank you for your contribution @drifter1.
We have been analyzing your tutorial and we suggest the following points:

- Again an excellent tutorial, very well explained and structured. Good job!

- In the next tutorial try to put more images in the middle of the tutorial, so that it is less massive.


Thank you for your work in developing this tutorial.
Looking forward to your upcoming tutorials.

Your contribution has been evaluated according to [Utopian policies and guidelines](https://join.utopian.io/guidelines), as well as a predefined set of questions pertaining to the category.

To view those questions and the relevant answers related to your post, [click here](https://review.utopian.io/result/8/1-1-2-1-3-3-1-3-).

---- 
Need help? Chat with us on [Discord](https://discord.gg/uTyJkNm).

[[utopian-moderator]](https://join.utopian.io/)
πŸ‘  , , , , , , , , , , , , , , , , , , , , , , ,
properties (23)
post_id76,556,975
authorportugalcoin
permlinkpt9g4w
categoryutopian-io
json_metadata{"tags":["utopian-io"],"users":["drifter1"],"links":["https:\/\/join.utopian.io\/guidelines","https:\/\/review.utopian.io\/result\/8\/1-1-2-1-3-3-1-3-","https:\/\/discord.gg\/uTyJkNm","https:\/\/join.utopian.io\/"],"app":"steemit\/0.1"}
created2019-06-17 20:41:21
last_update2019-06-17 20:41:21
depth1
children1
net_rshares21,758,115,576,632
last_payout2019-06-24 20:41:21
cashout_time1969-12-31 23:59:59
total_payout_value9.547 SBD
curator_payout_value3.003 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length851
author_reputation145,285,483,228,743
root_title"Writing a simple Compiler on my own - Simple Examples in MIPS Assembly"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (24)
@utopian-io ·
Thank you for your review, @portugalcoin! Keep up the good work!
properties (22)
post_id76,678,543
authorutopian-io
permlinkre-pt9g4w-20190619t211059z
categoryutopian-io
json_metadata{"app":"beem\/0.20.17"}
created2019-06-19 21:11:00
last_update2019-06-19 21:11:00
depth2
children0
net_rshares0
last_payout2019-06-26 21:11:00
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length64
author_reputation151,356,124,843,620
root_title"Writing a simple Compiler on my own - Simple Examples in MIPS Assembly"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
@steem-ua ·
#### Hi @drifter1!

Your post was upvoted by @steem-ua, new Steem dApp, using UserAuthority for algorithmic post curation!
Your post is eligible for our upvote, thanks to our collaboration with @utopian-io!
**Feel free to join our [@steem-ua Discord server](https://discord.gg/KpBNYGz)**
πŸ‘  
properties (23)
post_id76,559,007
authorsteem-ua
permlinkre-writing-a-simple-compiler-on-my-own-simple-examples-in-mips-assembly-20190617t214003z
categoryutopian-io
json_metadata{"app":"beem\/0.20.19"}
created2019-06-17 21:40:03
last_update2019-06-17 21:40:03
depth1
children0
net_rshares11,126,665,608
last_payout2019-06-24 21:40:03
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length287
author_reputation21,654,868,736,904
root_title"Writing a simple Compiler on my own - Simple Examples in MIPS Assembly"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (1)
@utopian-io ·
Hey, @drifter1!

**Thanks for contributing on Utopian**.
We’re already looking forward to your next contribution!

**Get higher incentives and support Utopian.io!**
 Simply set @utopian.pay as a 5% (or higher) payout beneficiary on your contribution post (via [SteemPlus](https://chrome.google.com/webstore/detail/steemplus/mjbkjgcplmaneajhcbegoffkedeankaj?hl=en) or [Steeditor](https://steeditor.app)).

**Want to chat? Join us on Discord https://discord.gg/h52nFrV.**

<a href='https://steemconnect.com/sign/account-witness-vote?witness=utopian-io&approve=1'>Vote for Utopian Witness!</a>
πŸ‘  
properties (23)
post_id76,564,093
authorutopian-io
permlinkre-writing-a-simple-compiler-on-my-own-simple-examples-in-mips-assembly-20190617t234659z
categoryutopian-io
json_metadata{"app":"beem\/0.20.17"}
created2019-06-17 23:47:03
last_update2019-06-17 23:47:03
depth1
children0
net_rshares11,354,524,749
last_payout2019-06-24 23:47:03
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length590
author_reputation151,356,124,843,620
root_title"Writing a simple Compiler on my own - Simple Examples in MIPS Assembly"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (1)