Dipesh

My Setup

2024-12-21T00:00:00+00:00

Nix (Just for common packages)</h2>
I don't really want to move to full-fledged nix setup because it's a lot of effort. However, I do want to keep some of my common packages/tools in version control, so that it's easy for me to set them up easily when (if) I move my setup.</p>

nix-env</h3>

Install nix</li>

Add the unstable channel so that I have mostly latest versions.</li> </ul>

$</span> nix-channel</span> --add</span> https://nixos.org/channels/nixpkgs-unstable nixpkgs</span></span></code></pre>

Update the channels</li>
</ul>
$</span> nix-channel</span> --update</span></span></code></pre>

Install my stuff</li>
</ul>
$</span> nix-env</span> -iA</span> nixpkgs.myPackages</span></span></code></pre>

My config is stored in my dotfiles repo</a></li>
</ul>
Emacs (Primary Editor)</h2>

Doom emacs with my configs piling up over the time. Link</a>, tips and tricks for myself</a></li>
</ul>



Setup Coq
2024-06-29T00:00:00+00:00
Install</h2>
$</span> opam switch create with-coq</span> 4.10.2</span></span>
</span>
$</span> opam repo add coq-released https://coq.inria.fr/opam/released</span></span>
</span>
$</span> opam pin add coq</span> 8.19.2</span> # opam pin add coq $VERSION (can be used to upgrade by mentioning new version)</span></span></code></pre>Use</h2>
To use the switch, do the following</p>
$ opam switch with-coq</span></span>
$ eval $(opam env --switch=with-coq)</span></span></code></pre>


What is a Fixed Point Combinator?
2024-03-28T00:00:00+00:00
(Copy-pasting Wikipedia) A fixed-point combinator (or fixpoint combinator), is a
higher-order function that returns some fixed point (a value that is mapped to
itself) of its argument function, if one exists.</p>
It has the following type(given in Haskell)</p>
fix</span> ::</span> (a</span> -></span> a)</span> -></span> a</span></span></code></pre>
We'll assume it's defined somewhere already and move on for now.</p>
Now, a classic example for showing it's usage is a factorial function(or any
recursive function would work).</p>
Generally it would be written recursively like this:</p>
fact</span>::</span> Integer</span> -></span> Integer</span></span>
fact n </span>= if</span> n </span>==</span> 0</span> then</span> 1</span> else</span> n </span>*</span> (fact (n </span>-</span> 1</span>))</span></span></code></pre>
But, let's assume we don't have recursion in our language. So, let's try to write it a bit differently.</p>
fact'</span>::</span> (</span>Integer</span> -></span> Integer</span>)</span> -></span> Integer</span> -></span> Integer</span></span>
fact' f n </span>= if</span> n </span>==</span> 0</span> then</span> 1</span> else</span> n </span>*</span> (f (n </span>-</span> 1</span>))</span></span></code></pre>
Now, using fix</code>, we could define our fact</code> to be something like this</p>
-- fact:: Integer -> Integer</span></span>
-- fix:: (a -> a) -> a</span></span>
-- fact' :: (Integer -> Integer) -> Integer -> Integer</span></span>
-- which can be rewritten as</span></span>
-- fact' :: (Integer -> Integer) -> (Integer -> Integer)</span></span>
--</span></span>
-- in fix fact', a is substituted to be (Integer -> Integer)</span></span>
-- so fix fact:: Integer -> Integer</span></span>
fact n </span>=</span> fix fact'</span></span></code></pre>
But fix</code> has been a blackbox for us till now. Let's see how we can define it.</p>
fix:: (a -> a) -> a</span></span>
fix f = <t></span></span></code></pre>
Now what could go in for t</code> expression there? If we think purely in terms of types, we have
a function as parameter f: a-> a</code> and we need result to be of type a</code>. So, it's probably
going to be achieved by applying f</code>.</p>
Now, what is something of type a</code> we can apply to f: a -> a</code>. We really only know of one thing
whose result is type a</code> i.e fix</code>. So, it's just going to be</p>
fix f = f (fix f)</span></span></code></pre>
andd, that's the definition of fix</code>, the fixed-point combinator.</p>

NOTE: Since, fix is defined recursively, it has to be a primitive provided by
host language(language in which the interpreter is written), since we
mentioned before we didn't support recursion.</p>
</blockquote>

NOTE: Also this definition of fix works in a call by name language(lazy
language) like Haskell, but will overflow the stack in something like OCaml.</p>
</blockquote>
Let's try defining it in OCaml</h3>
Why do we need to do it differently in OCaml?</h4>
Issue arises due to strictness.  If you translate the program
to OCaml, it'll be like this:</p>
let rec fix f = f (fix f)</span></span></code></pre>
The issue with this is, the moment you call fix</code> with some f</code>, it'll first try
to evaluate the fix f</code> in RHS, which just keeps on going forever. Haskell
doesn't suffer from the issue because it only actually evaluates it when it's
needed.</p>
ghci</span>></span> fix f = f</span> (fix</span> f</span>)</span></span>
ghci</span>></span> x y = 1:y</span></span>
ghci</span>></span> infinite1s = fix x</span></span>
ghci</span>></span> take</span> 10</span> infinite1s</span></span>
[1,1,1,1,1,1,1,1,1,1]</span></span></code></pre>
Using fix</code>, we can define x=1:x</code> like above. We basically took
x::[Integer] -> [Integer]</code> and converted it to [Integer]</code> with fix</code>.</p>
You can't do this in OCaml directly. This is of the form a -> a</code> where
a=[Integer]</code>. This form of fix with the signature (a -> a) -> a</code> is possible
in Haskell because a</code> whatever it is, is lazily evaluated. It's actually a
thunk which evaluates to a</code>. In OCaml, a</code> is always an evaluated value, so you
will end up needing some thunking mechanism to define fix</code>.</p>
We need to get laziness to do this in OCaml. So, we'll use partially
evaluated functions to get a definition of fix</code>. We define it as follows:</p>
val</span> fix</span> :</span> ((</span>'</span>a</span> -></span> '</span>b</span>)</span> -></span> '</span>a</span> -></span> '</span>b</span>)</span> -></span> '</span>a</span> -></span> '</span>b</span></span>
let</span> rec</span> fix</span> f x</span> =</span> f (fix f) x</span></span></code></pre>

(if you think about it, is sort of similar to (a -> a)-> a</code> in Haskell,
but a</code> maps to 'a -> 'b</code> here.)</p>
</blockquote>
This doesn't blow up because the usage of fix in RHS is also partial, it
doesn't get fully evaluated until we actually use it. We end up creating lazy
semantics of our own here.</p>
utop</span> # let rec fix f x = f (fix f) x;;</span></span>
val</span> fix :</span> ((</span>'a -> '</span>b) -</span>></span> 'a -> '</span>b) -</span>></span> 'a -> '</span>b = </span><</span>fun</span>></span></span>
─(</span> 16:05:30</span> )─</span><</span> command 7 </span>></span>──────────────────────────────────────────────────────────────────────────────────────────────{</span> counter:</span> 0</span> }─</span></span>
utop</span> # let fact f n = if n=0 then 1 else n * (f (n - 1));;</span></span>
val</span> fact :</span> (int -</span>></span> int</span>) -</span>></span> int -</span>></span> int = </span><</span>fun</span>></span></span>
─(</span> 16:05:34</span> )─</span><</span> command 8 </span>></span>──────────────────────────────────────────────────────────────────────────────────────────────{</span> counter:</span> 0</span> }─</span></span>
utop</span> # (fix fact) 10;;</span></span>
-</span> : int =</span> 3628800</span></span></code></pre>
That's pretty much it.</p>

This sort of clicked properly for me when I was watching this excellent
lecture by Robert Harper</a>,
so I thought I'd write it out as a small blog</p>
</blockquote>


Non Local Jumps with setjmp and longjmp
2023-11-01T00:00:00+00:00
While going through Postgres source code, I found a really cool way technique
they were using to do non local jumps(acting sort of as an exception handling
mechanism). Postgres is written in C and C doesn't really have a construct for
exceptions, so how would they do something like this?</p>
One very common functionality we observe in any interactive shell is when we
press Ctrl-c</code>, that operation gets cancelled. You can take python repl as an example.
When I pressed Ctrl-c</code> it aborted and printed KeyboardInterrupt</code>.</p>
λ</span> python</span></span>
Python</span> 3.11.5</span> (main,</span> Sep</span>  2</span> 2023, 14:16:33</span>) [GCC </span>13.2.1</span> 20230801] on linux</span></span>
Type</span> "help", "copyright", "credits" or "license" for more information.</span></span>
>>></span> print</span>(</span></span>
KeyboardInterrupt</span></span>
>>></span></span></code></pre>
Postgres also offers a similar interactive environment in the form of psql</code>
binary which lets us run db operations interactively. They also obviously offer
similar functionality of aborting when you press Ctrl-c</code>.</p>
To understand how this functionality would be implemented, we need to know a few
things. When we press Ctrl-c</code>, we are sending something called an interrupt.
That interrupt is handled by the kernel by sending a signal to the running
process(1</a>). Our Ctrl-c</code> keypress will trigger a SIGINT</code> signal. And we have mechanism to handle signals(2</a>) ourselves in user
code. Using that, we can use that to do a lot of powerful things.</p>
Let's take a look into the postgres(psql</code> to be specific) code to figure out
how they do this.</p>
The directory for psql</code> code lies at src/bin/psql</code>. The entrypoint(main
function) is inside startup.c</code>, which internally calls MainLoop</code> function in
mainloop.c</code>(aptly named).</p>

In startup.c</code>, there's a call to psql_setup_cancel_handler</code>(which is a
oneliner setup_cancel_handler(psql_cancel_callback)</code>) which eventually ends up
calling setup_cancel_handler()</code> in src/fe_utils/cancel.c</code>(there signal handler
for SIGINT is registered, and also a callback function is registered). The
handle_sigint</code> function is registered for handling SIGINT</code>, inside which it
calls cancel_callback</code> function if it's not NULL(which it won't be for our
particular codepath).</li>
</ul>
 </a>

 </a>
</p>
</a>
So, basically psql_cancel_callback</code> function is run as part of the signal handler (handle_sigint</code>).</p>

Now, let's look at the main loop. The MainLoop</code> function does a bunch of
stuff at the start(which I have no clue about) but the actual loop is mainly
the following code. It's a huge function which does a lot of things(expected
since it's what drives the whole program). If you scroll through it you'll
find that it's getting line and executing it(handling exits,clearing,etc.
too), it's quite involved really.</li>
</ul>
I came across this particular code snippet(where I have my cursor in the
screenshot). I had heard about something called setjmp/longjmp</code> before but
hadn't really encountered them in real world code(Could be that I haven't seen a
lot of real world code).</p>
</a>
</p>
Short primer on non local jump construct in C</h2>

setjmp</code> : Marks the point where this was called as somewhat of a checkpoint
by saving the execution state</li>
longjmp</code>: We jump to the checkpoint from wherever we are. This can be across
functions (of course locally too).</li>
</ul>
An example (taken straight from
Wikipedia</a>) will make it a bit more
clearer. The wikipedia page does a great job of showing how it can be used.</p>
#include</span> <stdio.h></span></span>
#include</span> <setjmp.h></span></span>
</span>
static</span> jmp_buf buf;</span></span>
</span>
void</span> second</span>() {</span></span>
    printf</span>(</span>"second</span>\n</span>"</span>);</span>         // prints</span></span>
    longjmp</span>(buf,</span>1</span>);</span>             // jumps back to where setjmp was called - making setjmp now return 1</span></span>
}</span></span>
</span>
void</span> first</span>() {</span></span>
    second</span>();</span></span>
    printf</span>(</span>"first</span>\n</span>"</span>);</span>          // does not print</span></span>
}</span></span>
</span>
int</span> main</span>() {</span></span>
    if</span> (</span>!</span>setjmp</span>(buf))</span></span>
        first</span>();</span>                // when executed, setjmp returned 0</span></span>
    else</span>                        // when longjmp jumps back, setjmp returns 1</span></span>
        printf</span>(</span>"main</span>\n</span>"</span>);</span>       // prints</span></span>
</span>
    return</span> 0</span>;</span></span>
}</span></span></code></pre>
Postgres doesn't use setjmp/longjmp</code> but uses sigsetjmp/siglongjmp</code> because
they're supposed to be used if you're using them in signal handling context it
seems(again a piece of knowledge from the linked wikipedia page).</p>

Something fun to do: Look into if setjmp/longjmp</code> allow us to implement
delimited continuations(TODO: I need to understand them better)</p>
</blockquote>
Tying together all the pieces</h2>
We saw the sigsetjmp</code> call to establish a checkpoint(here</a>). Now we need to find where siglongjmp</code> call is coming from. Well, that's easy, it's probably coming somewhere from the signal handler.</p>
Seeing setup_cancel_handler</a>, we see a callback
function(i.e query_cancel_callback</code>, which is basically psql_cancel_callback</code>)
being assigned to cancel_callback</code> variable and that is called in the
handle_sigint</a> function. I had already mentioned this
before</a>).</p>
</a>
</p>
Voila, We see the siglongjmp</code> call here.</p>
So, all of the stuff above is responsible for this small functionality.</p>
</p>
Verifying what I figured out above isn't a load of crap</h2>
Let's make change to psql_cancel_callback</a> and add a new print statement.</p>
</p>
And let's also add a print after sigsetjmp</code> in MainLoop</code></p>
</p>
After I compile with these changes, the behaviour of Ctrl-c</code> changes slightly in psql</code>. Now I get this</p>
</p>
So, I guess it wasn't incorrect.</p>
References</h2>

</a> Signals and
Interrupts</a></li>
</a> Signal Handling</a></li>
</a> Setjmp Wikipedia</a></li>
</ol>


Tips for optimizing OCaml code
2023-07-21T00:00:00+00:00

NOTE: This is a Work In Progress post, I'll update this as I learn more.</p>
</blockquote>

Try to reduce caml_modify</code> calls</li>
Reduce allocations, avoiding something like 'a option</code> can help with
performance quite a lot.</li>
Use higher order functions sparingly. For example: see
here</a>. That
kind of goes on to show the cost of indirect calls(which means inlining can't
possibly happen)</li>
Looking into the assembly generated is your friend.
Link which tells you how to do that</a></li>
This Profiling section for ocaml.org</a> and
Compiler Backend section Real World OCaml</a>
gives overview of profiling and some information on generated assembly.</li>
Useful links for knowing more about internals :
1</a>,
2</a></li>
</ul>


Helpful Emacs Shortcuts
2023-06-20T00:00:00+00:00


Useful commands page for someone else
Emacs-reminders</a></p>
</li>

describe-bindings</code> or SPC h b b</code> is super helpful for knowing what happens
when you press stuff</p>
</li>

describe-prefix-bindings</code> can be used to see bindings in current mode.</p>
</li>

SPC h</code> is for help related stuff, same as C-h</code></p>
</li>

C-h k</code> or SPC h k</code> or describe-key</code> will give information about keys you
press when it prompts you.</p>
</li>

C-h j</code> and C-h k</code> will move to next page and previous page when there's a
which-key buffer and there's multiple pages for a particular key press [TODO: figure out why this doesn't work anymore in my setup for some reason]</p>
</li>

C-h</code> on any which-key buffer opens a list of searchable possible
keybindings/actions I can take in the current key prefix. Example: Say I press
C-c</code>, then C-h</code> will open up all the actions/keys starting with C-c</code>.</p>
</li>

All describe-*</code> is super helpful. There's describe-variable</code>,
describe-command</code>, describe-function</code> and so on.</p>
</li>

C-M-h</code> -> mark-defun will select a whole function</p>
</li>

If you want to open a file that's in some text, you can select it and then
just press gF</code> to jump to it(this is evil mode binding). Command:
evil-find-file-at-point-with-line</code> .This works with line numbers also so if
there's something of form :line, this is super useful. This
helps when you have file names and line names in error messages, you can
easily jump to that file+line</p>
</li>

Use maximize-window</code> to maximize one window in splits and do winner-undo</code> to undo it</p>
</li>

C-M-SPC</code> -> mark-sexp</code> will select the next ast node(sort of), repeating it
more will move forward. C-M-<left></code> will move backward</p>
</li>

fill-paragraph</code> is nice for formatting text (with max width), bound to M-q</code>.
In tuareg-mode</code>,M-q</code> is bound to tuareg-indent-phrase</code> which helps in
formatting comments in ocaml</p>
</li>

Registers are there in emacs too. C-x r s <reg-name></code> to copy things to a
register and C-x r i <reg-name></code> or consult-register</code> followed by
<reg-name></code> to paste it. If you're using evil mode, the usual vim way can be
used "<reg-name>y/p</code>. More info can be found in
emacswiki</a></p>
</li>

Very useful emacs stuff at emacsrocks.com</a></p>
</li>

Flyspell</a> is super helpful</p>
</li>

apropos</code> is super helpful, like a regex search for emacs commands(SPC-h-a</code>
in doom, C-h-a</code> also works)</p>
</li>

C-u <param> M-x <command></code> will run <command></code> with <param></code>. This is
useful when say you have mark-sexp</code>, you maybe mark an extra sexp, so you'd
do C-u -1 M-x mark-sexp</code>(for evil mode(doomemacs) it's
SPC-u -1 M-x mark-sexp</code> )</p>
</li>

dired-toggle-read-only</code> allows to change(makes dired editable) whatever we
want in dired buffer(can be helpful for renaming mostly and probably many
other things too). To finish edit wdired-finish-edit</code> and to abort
wdired-abort-changes</code></p>
</li>

Some cool things
here</a></p>
</li>

See orderless</a> for prefixes that
trigger different behaviors during minibuffer search in vertico</p>
</li>

Use org-timestamp</code> to insert date to the buffer(quite cool)</p>
</li>

Want to insert unicode symbols in emacs. Do one of the the following(Reference</a>):</p>

M-x set-input-method RET tex</code> or C-\</code></li>
C-x 8 RET</code> to see a bunch of searchable symbols and insert them</li>
If we want this to be in every buffer, need to customize-variable</code> default-input-method</code></li>
</ul>
</li>
</ul>


GCC Workshop IITB Notes
2023-02-27T00:00:00+00:00

NOTE</strong> : This is still incomplete and I might add content as I see the
videos more.</p>
</blockquote>
Notes</h2>

Variable Meanings</p>

$(SOURCE_D) = Source directory</li>
$(BUILD) = Build directory</li>
$(INSTALL) = Install directory</li>
</ul>
</blockquote>

The workshop was held in 2012, so a lot has changed code wise but the concept
is pretty much same. One major thing is, most of the code is C++ code(.cc
extension) but when this workshop was happening it was all C files(.c
extension).</p>
</blockquote>
Configuring GCC</h2>
</p>

Convention followed in the picture:</p>

Box => Executable</li>
Not in Box => File/Data'</li>
Oval => Library</li>
</ol>
</blockquote>
Gcc generates a lot of source code during the build step.</p>
Terminologies</h3>

The sources of the compiler are compiled on Build System</code>.</li>
The built compiler runs on Host System</code>(host).</li>
The compiler compiles code for the Target System</code>(target).</li>
</ul>


More on configure terminologies found
here</a></li>
All Configure Options found
here</a></li>
</ul>
</blockquote>
What happens during build?</h2>
Normal Build Steps</h3>
</p>
Native Build With Bootstrapping</h3>
</p>
Build Stages</h3>
</p>

Stage 1 files created in $(BUILD)/stage1-gcc</li>
Stage 2 files created in $(BUILD)/prev-gcc</li>
Stage 2 files created in $(BUILD)/gcc</li>
</ul>

NOTE: Cross compilation is difficult and weird</p>
</blockquote>

There's explanation of mechanism to add new target to gcc in the workshop. But
since it's unlikely you'd want to do this, I'm skipping it. It starts at 3/4th
of the video L3-B.</p>
</blockquote>
Directory Structure</h2>
Frontend Code</h3>

Kept in <source_directory>/gcc/<lang></code> where lang</code> can be language frontends
c,cp,go,etc</li>
It contains parsing code, additional ast/generic nodes,if any. It also has
interface to generic creation</li>
</ul>
Optimizer Code and Backend Generator Code</h3>

Kept in <source_directory>/gcc</code></li>
<source_directory>/gcc/config/<target_dir></code> has backend code. <target>.md</code>
and <target>.h</code> files will be present. <target>.cc</code> may also be there. It'll
have more files than this though.</li>
</ul>
Plugins</h2>
Static Plugin</h3>

Changes required in gcc/Makefile.in, some header and source files.</li>
Atleast cc1 may have to be rebuild and all other files that were affected by
source change.</li>
</ul>
Dynamic Plugin</h3>


Supported on platforms that support -ldl -rdynamic.</p>
</li>

Loaded using dlopen and invoked at pre-determined locations in compilation
process.</p>
</li>

Command line option: -fplugin=/path/to/name.so</p>
</li>

The compilers are also plugins. They are static plugins however and can be
found in $(SOURCE_D)/gcc/gcc.cc</code>. There's an array of them, called
static const struct compiler default_compilers[]</code>.</p>

# means default specs not availble in top level directory. Defined
somewhere else. @ means Aliased entry.</p>
</blockquote>
</li>

$(SOURCE_D)/gcc/<lang>/lang-specs.h</code> has more information about the compiler.
Example: C++'s specs can be seen in $(SOURCE_D)/gcc/cp/lang-specs.h</code> and for
C, it's defined in the gcc.cc file itself(so it's @ implying it's aliased
entry. For C++ it's in different directory, so it doesn't have default specs).</p>
</li>

Dynamic plugin mechanism just adds a node to the linked list of optimization
passes.</p>
</li>

Passes are executed with execute_pass_list</code> function defined in
$(SOURCE_D)/gcc/passes.cc</code> which is just a while loop running all the passes.</p>
</li>
</ul>
Interprocedural Pass</h4>

simple_ipa_opt_pass</code> => Works on functions in a translation unit, stored in
variable all_simple_ipa_passes</code></li>
Regular IPA pass => Works across translation units. Used in link time
optimization. ipa_opt_pass_d</code> has details about ipa passes,which will be used
in lto.</li>
</ul>
Predefined pass lists</h4>

all_lowering_passes</code></li>
all_small_ipa_passes</code></li>
all_regular_ipa_passes</code></li>
all_lto_gen_passes</code></li>
all_passes</code> => Intraprocedural passes on gimple and rtl</li>
</ul>
Adding a static Pass</h3>
</p>
Control Flow</h2>
GCC Driver Program</h3>

control flow can be found in $(SOURCE_D)/gcc/gcc.cc</code> in driver::main</code>
function definition.</li>
</ul>
CC1 Top Level Control Flow</h3>

can be found in toplev.cc $(SOURCE_D)/gcc/toplev.cc</code> in toplev::main</code>
function definition.</li>
</ul>

NOTE: Watch L5-A if more insights needed about the flow of program. It has
many more things such as code gen flow, passes flow, lowering passes flow,
etc.</p>
</blockquote>

NOTE: Better to See L5-B by yourself as well, the LTO section is amazing.
Skipping it because it's kind of an advanced topic. TODO</strong> : Make notes on
this</p>
</blockquote>
GENERIC, GIMPLE and RTL</h2>
GENERIC</h3>

Language independent IR for a complete function in the form of trees</li>
Obtained by removing language specific constructs from ASTs</li>
All tree codes defined in $(SOURCE_D)/gcc/tree.def</code></li>
With this, all language can have their own ASTs and they just have to emit
GENERIC and gcc will take over from there.</li>
</ul>
GIMPLE</h3>

Language indepedent 3 address code representation</li>
It is simplified subset of GENERIC.</li>
It has 3 address codes, simplified scope(block begin and end), Control Flow
Lowering, simplified and restricted grammar</li>
Easy to optimize</li>
</ul>
Manipulating GIMPLE</h4>

A Basic Block contains a doubly linked list of GIMPLE statements</li>
The statements are represented as GIMPLE tuple and the operands are
represented by a tree data structure.</li>
Processing of statements done through iterators.</li>
</ul>

Many APIs for GIMPLE manipulation can be found in $(SOURCE_D)/gcc/gimple.h</code></p>
</blockquote>
Manipulating tree</h4>

My friends found a great blog post about manipulating gimple from
Yonatan Goldschmidt</a>. The blog post is in 2 parts.
It lies here</a>
and here</a>.
The code is here</a> and it's a
great resource for learning ast manipulation in gcc.</li>
</ul>


Notes on GCC
2023-02-24T00:00:00+00:00

NOTE</strong> : This is still incomplete and I might add more content</p>
</blockquote>

Takes about 50 minutes for clean build on my current machine</li>
X86-64 calling convention :
Link</a></li>
Inside CC1</a></li>
</ul>
Setting Up Dev Environment</h2>

Useful Link</a>
(Important to learn if you want to hack on gcc)</li>
Create a different build directory(convention followed). Build tree => build
directory, Source tree => the root directory where source code lies.</li>
Install bear to generate compile_commands.json</li>
</ul>
$ ./contrib/download_prerequisites</span></span>
$ mkdir build # create build tree/directory</span></span>
$ cd build</span></span>
$ ../configure --prefix=$PWD/GCC-INSTALL-DIR --enable-languages=c,c++ --disable-bootstrap # Disable bootstrap to make build fast</span></span>
$ bear -- make -j$(nproc) # bear will generate compile_commands.json which will be used by development env for understanding about the repo</span></span></code></pre>

See
this</a>
to learn more about when to enable bootstrap and when to use multiple copies
of the repo and things like that.</li>
For cross compiling(this is just from my experience trying to compile for
arm64 host and target, on my x86 machine)</li>
</ul>
$ sudo pacman -S aarch64-linux-gnu-gcc \\ install cross compilers(this is for aarch64)</span></span>
$ mkdir build</span></span>
$ cd build</span></span>
$ ../configure --prefix=$PWD/GCC-12.2.0 --enable-languages=c,c++ --disable-bootstrap  --host=aarch64-linux-gnu --target=aarch64-linux-gnu</span></span>
$ clear; make -j$(nproc)</span></span>
$ make install</span></span></code></pre>

This</a> is
more comprehensive guide for cross compiling.</li>
</ul>
Tools used(Gcc hacker must learn properly)</h3>

Autoconf ( configure.ac </a>
files), Automake are used.
Link(has a nice diagram about how they work together)</a></li>
Configure shell scripts and .in header templates</li>
Makefile is generated using Makefile.{def,tpl,in}(.in is generated from .def
and .tpl using autogen</code>) files present in source directory. This is done by
the configure script and it should be generated in the build directory.</li>
There are two level of configurations, the topmost $GCCTOP/configure</code> and the
one in $GCCTOP/gcc/configure</code> (GCCTOP => source directory</code>). Some configure
arguments are passed from the topmost to the lower, but the topmost --help
don't mention them.</li>
</ul>
Must Understand</h3>

Source Directory and what they have .
Link</a></li>
Gcc subdirectory.
Link</a></li>
Passes</li>
</ul>
General Notes</h2>

In general, the names of macros are all in uppercase, while the names of
functions are entirely in lowercase. There are rare exceptions to this rule.
You should assume that any macro or function whose name is made up entirely of
uppercase letters may evaluate its arguments more than once. You may assume
that a macro or function whose name is made up entirely of lowercase letters
will evaluate its arguments only once.</p>
</blockquote>
Lexing</h2>
First the input source is “tokenized”, so that the stream of input characters is
divided into a stream of tokens. This is called “lexing”, and largely
implemented in gcc in libcpp(folder in gcc) (which also implements the
preprocessor - hence the name)</p>
Parsing</h2>

gcc -S <c-file> -O2 -fverbose-asm -fdump-tree-all -fdump-ipa-all -fdump-rtl-all</code>
will generate dumps for every compiler pass that happened</p>
</blockquote>
Next the frontend parses the tokens from a flat stream into a tree-like
structure reflecting the grammar of the language (or complains about syntax
errors or type errors, and bails out). This stage uses gcc’s tree</strong> type.
There may be frontend-specific kinds of node, in the tree but the frontend will
convert these to a generic form. Most warnings and lint things are implemented
in this phase</strong>.</p>
After each frontend the middle end “sees” a tree representation that we call
generic</strong>. Generic</strong> IR closely resembles the original C code, but sometimes
you will see control flow expressed via “goto” statements that go to numbered
labels, and temporary variables introduced by the frontend.</p>
Gimple</h2>
The tree-based IR can contain arbitrarily-complicated nested expressions, which
is relatively easy for the frontends to generate, but difficult for the
optimizer to work with, so GCC almost immediately converts it into a form named
“gimple”.
Gimple Documentation</a></p>
Gimple with CFG(Control Flow Graph)</h2>
Gimple</strong> is almost immediately converted to a CFG, a directed graph of "Basic
Blocks"(Sequences of instructions with no control flow). The control flow is
expressed as edges between the Basic Blocks.</p>

gcc -S <c-file> -O2 -fverbose-asm -fdump-tree-all-graph -fdump-ipa-all-graph -fdump-rtl-all-graph</code>
will generate dot graph dumps for every compiler pass that happened,in
addition to normal dumps generated without the graph suffix in the flags</p>
</blockquote>
Gimple SSA(Static Single Assignment)</h2>
SSA form is commonly used inside compilers, as it makes many kinds of
optimization much easier to implement. In SSA, every local variable is only ever
assigned to once; if there are multiple assignments to a local variable, it gets
split up into multiple versions. Pretty much any major compiler uses SSA form at
one point. Heavily used in LLVM as well. More
here</a>. Involves
concept such as 'phi-nodes' and more.</p>
GCC-Gimple-SSA documentation:
here</a></p>
In SSA form, almost 200 passes are there.</p>
Intraprocedural Passes</h3>
These work on one function at a time. They have a “t” code in their dump file.
For example, test.c.175t.switchlower is the dump file for an optimization pass
which converts gimple switch statements into lower-level gimple statements and
control flow (which doesn’t do anything in our example above, as it doesn’t have
any switch statements; try writing a simple C source file with a switch
statement and see what it does)</p>
Interprocedural Passes</h3>
Consider all of the functions at once, such as which functions call which other
functions. These have an “i” code in their dump file.</p>

All sets of optimizations can be found in gcc/passes.def</code>.</p>
</blockquote>
RTL</h2>

Gimple is converted to Register Transfer Language (RTL), a much lower-level
representation of the code, which will allow us to eventually go all the way
to assembler.</li>
This conversion happens in an optimization pass called "expand".</li>
RTL form of the IR is much closer to assembler: whereas gimple works in terms
of variables of specific data types, RTL instructions work in terms of
low-level operations on an arbitrary number of registers of specific bit
sizes.</li>
</ul>
Optimization passes in RTL</h3>


Implements calling convention of an ABI</p>
</li>

Does register allocation</p>
</li>

Uses actual instruction and addressing modes of CPU rather than assuming an
ideal set of combinations</p>
</li>

Optimizations such as scheduling instructions, handling delay slot, etc to
make it run efficiently on the machine.</p>
</li>

Converts the CFG that RTL inherited from gimple into a flat series of
instructions connected by jumps (honoring constraints such as limitations on
how many bytes a jump instruction can go)</p>
</li>

Final form of RTL is generated in a pass called "final". This form is suitable
for output in assembler.</p>
</li>
</ul>
GENERIC</h2>

Union Crimes happening in codebase. Abusing union memory layout.. tree_node</code>
is a union, which has two fields that always need to exist. TREE_CHAIN</code> and
TREE_TYPE</code> macros defined in gcc/tree.h</code> need to access common</code> and typed</code>
field of tree_node</code>(in gcc/tree-core.h</code>) and they'll always end up being
valid because the minimum size of anything inside that union is
tree_typed</code>(which makes TREE_TYPE</code> always valid because of union memory
layout) and whenever they need to use TREE_CHAIN</code>, many cases it's having
tree_common</code> as first field in struct and hence making it valid. I'm assuming
this needs to be checked however as some type have tree_typed</code> as member and
not tree_common</code> (maybe because they don't need the next pointer).</li>
</ul>
GIMPLE</h2>
INCOMPLETE</strong></p>
Passes</h2>
Frontend Passes</h3>

Language frontend is invoked only once.</li>
I think gcc/toplev.cc is the driver program? I'm not sure</li>
langs_hook.parse_file is invoked in gcc/toplev.cc</code>. I'm not sure how this is
working?</li>
Each front end provides its own lang hook initializer. Lang hook routines
common to C++ and ObjC++ appear in cp/cp-objcp-common.cc</li>
Languages can use whatever intermediate language representation they want. (C
uses GENERIC trees + some language specific tree codes, defined in
c-common.def), while Fortran uses completely different private representation.</li>
C Frontend invokes the gimplifier manually on each function and uses the
callbacks to convert language specific tree nodes directly to GIMPLE</code>, before
passing the function off to be compiled. Fortran however follows private repr
=> GENERIC => GIMPLE path.</li>
The call-graph is a data structure designed for inter-procedural optimization.
It represents a multi-graph where nodes are functions (symbols within symbol
table) and edges are call sites.</li>
The front end needs to pass all function definitions and top level
declarations off to the middle-end so that they can be compiled and emitted to
the object file.</li>
</ul>
Gimplification Passes</h3>

Tree lowering pass. This pass converts the GENERIC functions-as-trees tree
representation into the GIMPLE form.</li>
The main entry point to this pass is gimplify_function_tree</code> located in
gimplify.cc</code>. Processes entire function, gimplifying each of the statements.
Main thing to look into is the gimplify_expr</code>.</li>
See gcc/cgraphunit.cc</code> which implements main driver of the compilation
process. This is where lower_nested_functions</code> (in cgraphnode::analyze) is
called which I inside it calls gimplify_function_tree</code> inside it on all the
functions. Also look into the cgraph_node</code> structure defined in
gcc/cgraph.h</code>. (The call-graph is a data structure designed for
inter-procedural optimization. It represents a multi-graph where nodes are
functions (symbols within symbol table) and edges are call sites)</li>
See gimplify_stmt</code> and gimplify_expr</code>(Has lots of comments to understand.
TODO: understand this as I'm not clear with representation fully) in
gcc/gimplify.cc</code>.</li>
There's a language specific gimplify_expr</code> that will be implemented as
language hook. Called in gimplify_expr</code> in gcc/gimplify.cc</code> as
lang_hooks.gimplify_expr</code></li>
</ul>
Pass Manager</h3>
INCOMPLETE</strong></p>
Vectorization Related Things</h2>

Cost Model is described in $(SOURCE_D)/gcc/tree-vect-loop.cc</code></li>
More details here</a></li>
</ul>


Setup FStar in OCaml 4.14
2023-01-14T00:00:00+00:00
Steps</h2>
Setup dependencies properly</h3>

opam install ocamlbuild</li>
opam install ocamlfind</li>
sudo pacman -S libffi</li>
opam install ppx_deriving_yojson</li>
opam install -I +str ppx_deriving_yojson</li>
opam install str</li>
opam install ctypes ctypes-foreign</li>
opam uninstall integers</li>
opam install ctypes</li>
opam install ppx_deriving_yojson zarith pprint "menhir>=20161115" sedlex
process fix "wasm>=2.0.0" visitors ctypes-foreign ctypes</li>
sudo pacman -S dotnet-sdk-6.0</li>
</ul>
Actual Setup</h3>

Setup Link</a></li>
./everest z3 opam</li>
You have to add path to .zshrc or .bashrc it'll show up in output</li>
./everest pull FStar make karamel make (Idk but it might help to add -j at the
end?)</li>
Put FStar as well in your path</li>
</ul>
Better way</h2>
$</span> opam switch create fstar</span></span>
$</span> opam pin add fstar</span> --dev-repo</span></span>
$</span> opam pin add karamel</span> --dev-repo</span></span></code></pre>
Above, you may need to run opam install fstar karamel</code>, but I don't exactly remember</p>
To use the Fstar switch, do the following</p>
$ opam switch fstar</span></span>
$ eval $(opam env --switch=fstar)</span></span></code></pre>


Hello World
2022-10-05T00:00:00+00:00
Hi, This is my blog/personal site</p>
Testing Inline Math</h1>

$(a+b)^2$ = $a^2 + 2ab + b^2$</li>
A polynomial P of degree d over $\mathbb{F}_p$ is an expression of the form
$P(s) = a_0 + a_1 . s + a_2 . s^2 + ... + a_d . s^d$ for some
$a_0,..,a_d \in \mathbb{F}_p$</li>
</ul>
Testing Displayed Math</h1>
$$
p := (\sum_{k∈I}{c_k.v_k} +
\delta_v.t(x))·(\sum_{k∈I}{c_k.w_k} +
\delta_w.t(x)) −
(\sum_{k∈I}{c_k.y_k} + \delta_y.t(x))
$$</p>
Testing Code Support</h1>
let</span> ()</span> =</span> print_string</span> "Hello World!!!"</span>;;</span></span></code></pre>fn</span> main</span>(){</span></span>
  println!</span>(</span>"Hiya"</span>);</span></span>
}</span></span></code></pre>

Let's try defining it in OCaml</h3>

`References</h2></a> Signals and Interrupts</a></li> </a> Signal Handling</a></li> </a> Setjmp Wikipedia</a></li> </ol>`

What happens during build?</h2>

Normal Build Steps</h3>
</p>

Native Build With Bootstrapping</h3>
</p>

Directory Structure</h2>

Plugins</h2>

Adding a static Pass</h3>
</p>

Control Flow</h2>

`Manipulating tree</h4> My friends found a great blog post about manipulating gimple from Yonatan Goldschmidt</a>. The blog post is in 2 parts. It lies here</a> and here</a>. The code is here</a> and it's a great resource for learning ast manipulation in gcc.</li> </ul>`

Lexing</h2>
First the input source is “tokenized”, so that the stream of input characters is divided into a stream of tokens. This is called “lexing”, and largely implemented in gcc in libcpp(folder in gcc) (which also implements the preprocessor - hence the name)</p>

GIMPLE</h2>
INCOMPLETE</strong></p>

Pass Manager</h3>
INCOMPLETE</strong></p>

Dipesh

My Setup

Nix (Just for common packages)</h2>
I don't really want to move to full-fledged nix setup because it's a lot of effort. However, I do want to keep some of my common packages/tools in version control, so that it's easy for me to set them up easily when (if) I move my setup.</p>

Emacs (Primary Editor)</h2>

Doom emacs with my configs piling up over the time. Link</a>, tips and tricks for myself</a></li> </ul>

Setup Coq

Use</h2>
To use the switch, do the following</p>
`$ opam switch with-coq</span></span> $ eval $(opam env --switch=with-coq)</span></span></code></pre>`

What is a Fixed Point Combinator?

Non Local Jumps with setjmp and longjmp

Tips for optimizing OCaml code

Helpful Emacs Shortcuts

GCC Workshop IITB Notes

Notes on GCC

Setup FStar in OCaml 4.14

Steps</h2>

Hello World

Testing Displayed Math</h1>
$$ p := (\sum_{k∈I}{c_k.v_k} + \delta_v.t(x))·(\sum_{k∈I}{c_k.w_k} + \delta_w.t(x)) − (\sum_{k∈I}{c_k.y_k} + \delta_y.t(x)) $$</p>

Testing Code Support</h1>
`let</span> ()</span> =</span> print_string</span> "Hello World!!!"</span>;;</span></span></code></pre>fn</span> main</span>(){</span></span> println!</span>(</span>"Hiya"</span>);</span></span> }</span></span></code></pre>`

Dipesh

My Setup

Nix (Just for common packages)</h2> I don't really want to move to full-fledged nix setup because it's a lot of effort. However, I do want to keep some of my common packages/tools in version control, so that it's easy for me to set them up easily when (if) I move my setup.</p>

Emacs (Primary Editor)</h2> Doom emacs with my configs piling up over the time. Link</a>, tips and tricks for myself</a></li> </ul>

Setup Coq

Use</h2> To use the switch, do the following</p> $ opam switch with-coq</span></span> $ eval $(opam env --switch=with-coq)</span></span></code></pre>

What is a Fixed Point Combinator?

Let's try defining it in OCaml</h3>

Non Local Jumps with setjmp and longjmp

Short primer on non local jump construct in C</h2> setjmp</code> : Marks the point where this was called as somewhat of a checkpoint by saving the execution state</li>

References</h2> </a> Signals and Interrupts</a></li> </a> Signal Handling</a></li> </a> Setjmp Wikipedia</a></li> </ol>

Tips for optimizing OCaml code

Helpful Emacs Shortcuts

GCC Workshop IITB Notes

Notes</h2> Variable Meanings</p>

What happens during build?</h2>

Normal Build Steps</h3> </p>

Native Build With Bootstrapping</h3> </p>

Build Stages</h3> </p>

Directory Structure</h2>

Frontend Code</h3> Kept in <source_directory>/gcc/<lang></code> where lang</code> can be language frontends c,cp,go,etc</li>

Plugins</h2>

Adding a static Pass</h3> </p>

Control Flow</h2>

Manipulating tree</h4> My friends found a great blog post about manipulating gimple from Yonatan Goldschmidt</a>. The blog post is in 2 parts. It lies here</a> and here</a>. The code is here</a> and it's a great resource for learning ast manipulation in gcc.</li> </ul>

Notes on GCC

Lexing</h2> First the input source is “tokenized”, so that the stream of input characters is divided into a stream of tokens. This is called “lexing”, and largely implemented in gcc in libcpp(folder in gcc) (which also implements the preprocessor - hence the name)</p>

Interprocedural Passes</h3> Consider all of the functions at once, such as which functions call which other functions. These have an “i” code in their dump file.</p>

RTL</h2> Gimple is converted to Register Transfer Language (RTL), a much lower-level representation of the code, which will allow us to eventually go all the way to assembler.</li> This conversion happens in an optimization pass called "expand".</li>

GIMPLE</h2> INCOMPLETE</strong></p>

Pass Manager</h3> INCOMPLETE</strong></p>

Vectorization Related Things</h2> Cost Model is described in $(SOURCE_D)/gcc/tree-vect-loop.cc</code></li> More details here</a></li> </ul>

Setup FStar in OCaml 4.14

Steps</h2>

Hello World

Testing Displayed Math</h1> $$ p := (\sum_{k∈I}{c_k.v_k} + \delta_v.t(x))·(\sum_{k∈I}{c_k.w_k} + \delta_w.t(x)) − (\sum_{k∈I}{c_k.y_k} + \delta_y.t(x)) $$</p>

Testing Code Support</h1> let</span> ()</span> =</span> print_string</span> "Hello World!!!"</span>;;</span></span></code></pre>fn</span> main</span>(){</span></span> println!</span>(</span>"Hiya"</span>);</span></span> }</span></span></code></pre>

Nix (Just for common packages)</h2>
I don't really want to move to full-fledged nix setup because it's a lot of effort. However, I do want to keep some of my common packages/tools in version control, so that it's easy for me to set them up easily when (if) I move my setup.</p>

Emacs (Primary Editor)</h2>

Doom emacs with my configs piling up over the time. Link</a>, tips and tricks for myself</a></li> </ul>

Use</h2>
To use the switch, do the following</p>
`$ opam switch with-coq</span></span> $ eval $(opam env --switch=with-coq)</span></span></code></pre>`

`References</h2></a> Signals and Interrupts</a></li> </a> Signal Handling</a></li> </a> Setjmp Wikipedia</a></li> </ol>`

Normal Build Steps</h3>
</p>

Native Build With Bootstrapping</h3>
</p>

Adding a static Pass</h3>
</p>

`Manipulating tree</h4> My friends found a great blog post about manipulating gimple from Yonatan Goldschmidt</a>. The blog post is in 2 parts. It lies here</a> and here</a>. The code is here</a> and it's a great resource for learning ast manipulation in gcc.</li> </ul>`

Lexing</h2>
First the input source is “tokenized”, so that the stream of input characters is divided into a stream of tokens. This is called “lexing”, and largely implemented in gcc in libcpp(folder in gcc) (which also implements the preprocessor - hence the name)</p>

GIMPLE</h2>
INCOMPLETE</strong></p>

Pass Manager</h3>
INCOMPLETE</strong></p>

Vectorization Related Things</h2>

Cost Model is described in `$(SOURCE_D)/gcc/tree-vect-loop.cc</code></li>`
`More details here</a></li> </ul>`

Testing Displayed Math</h1>
$$ p := (\sum_{k∈I}{c_k.v_k} + \delta_v.t(x))·(\sum_{k∈I}{c_k.w_k} + \delta_w.t(x)) − (\sum_{k∈I}{c_k.y_k} + \delta_y.t(x)) $$</p>

Testing Code Support</h1>
`let</span> ()</span> =</span> print_string</span> "Hello World!!!"</span>;;</span></span></code></pre>fn</span> main</span>(){</span></span> println!</span>(</span>"Hiya"</span>);</span></span> }</span></span></code></pre>`