Want to master command line arguments in pure x86-64 YASM assembly on Linux? This video breaks down how to access argc and argv directly from the stack, without GCC libraries. Follow along as we write a program to loop through and print user-provided arguments, complete with a visual stack explanation. Whether you’re new to assembly or leveling up, this tutorial offers clear, practical insights for coding low-level programs. Check out my other videos for more assembly tips, and subscribe for more coding goodness!

Introduction to Command Line Arguments 00:00:00
Target Architecture and Assumptions 00:00:04
Recap of Command Line Arguments 00:00:56
Accessing Arguments in Pure Assembly 00:01:47
Program Structure and Data Section 00:02:19
Stack Pointer and Argument Count 00:04:16
Accessing Argument Vector (argv) 00:07:14
Looping Through Arguments 00:12:16
Incrementing to Next Argument 00:16:45
Visualizing the Stack 00:19:24
Running the Program with Arguments 00:21:56
Conclusion and Call to Subscribe 00:23:48

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

hey there let’s talk about accepting command line arguments in a pure assembly program

written for x86-64 aka amd yasm assembly

on linux anyway so uh there are going to be a lot of topics that i that i sort of mention in this

video that are not actually covered in this video so if you feel yourself getting lost like for

program in assembly in the first place.

If you don’t know what command line arguments are,

if you don’t know the terminal, things like that,

you probably want to check out my previous videos

because they will be explained in detail.

For now, I’m just going to assume you know how to do all this basic stuff.

And the only thing that I need to show you

is how to write a program in Yasm assembly that can

grab your command line arguments.

So, you know, just to do a quick recap of what I’m even talking about.

echo we can launch it with no arguments it doesn’t do anything but we can give

it some arguments we can say hello and then we can say goodbye and that’s two

arguments that I’m giving to echo echo will grab on to the arguments it was

given it’s actually going to receive three arguments the index zero argument

being the name of itself its own program and then the next two arguments being

the stuff that I typed after the program but you can see that it somehow figured

two arguments as strings and print them right so imagine you have an assembly

program and you want the user to be able to launch your program and add

arguments at the end of the command line and have your program behave in some

certain way according to what the user wants the question then becomes how do

you access those arguments it’s a little bit easier in GCC look at my other video

that I posted about the topic for GCC linked assembly programs it’s a little

You pretty much just look at RDI and RSI to get your argc and your character pointer array.

When you’re dealing with pure assembly though, the GCC libraries don’t bundle up the command

line arguments in a really convenient way for you.

You’ve got to look for them elsewhere.

It’s honestly not that much harder.

It’s just a little, feels a little weird.

I think at least for me, I was hoping to see the arguments in a register and I did not.

But anyway, so here’s my program.

Again, this is not an assembly programming video.

an assembly programming video if you need to know how to program assembly see my other videos for

now i’m just going to quickly go over it i’ve got my data section in yasm i am printing out a couple

of strings or i i have a couple of strings defined i’m saying like the module has started i’m going

to begin printing arguments i have some system call codes so that i can write just to standard

output and so that i can exit the program this is pure assembly so we don’t actually return from

we just get jumped into and then we call exit normally and then here’s the standard output pipe

again another video covers that and then i’ve got the exit success code again another video covers

that but basically you know exiting zero is usually what you do for success then i’ve got the

text section which holds all my assembly instructions and this is my entry point we don’t

really need to uh push and pop these registers because we’re just going to exit the program when

it’s totally fine we would need to preserve Kali saved registers if we were

jumping into a main function or if this was a different function that was being

jumped into but we’re not so we don’t have to anyway here’s my entry point the

underscore start for a pure assembly program and then I’m going to grab the

incoming arguments when you’re linking with GCC which we’re not doing here in

this video then the arguments come in very easily they just come in argc

up in RDI and arg sorry argc comes into RDI and the character pointer array comes in as RSI so you

can imagine in GCC this would be integer main and then integer argc character pointer array argv

right hopefully you’ve done this in a higher level language so you have a better idea of what I’m

talking about if not I guess that’s okay it will still allow you to grab even if you don’t

it will still allow you to grab,

even if you don’t understand this in C++.

So argc is actually the stack pointer.

The stack pointer register, RSP,

always tells you where the top of the stack is,

like what’s the last piece of data

that we actually have sitting on the stack.

So that’s gonna be the count of arguments.

argc is always gonna be the stack pointer.

So if you dereference the stack pointer register,

pointer register then what you’re doing is you know the stack pointer register

actually points to memory locations within the stack so if the memory

location that it’s looking at is where argc is stored then you dereference it

with the brackets and you’ll actually get argc so right away I’m just gonna

steal argc off the top of the stack and this is a good idea to do right away

because if you start doing other stuff you might end up modifying the stack

especially if you start calling functions and things like that and and

and and these these pieces of information will be lost or they’ll be a lot harder to find so right

away i’m just going to say argc goes directly into r12 and i have a little comment reminder

for myself at the top saying r12 is now argc same thing for uh r13 i’m going to say that’s a pointer

to my character pointer array i talked about this in depth on my other video where we talked about

an assembly program but basically if you look at uh if you look at argv right here it’s not just a

pointer and it’s not just an array it’s a pointer to an array and if you recall in higher level

languages or just i guess anything an array itself is a pointer because argv the symbol let’s say we

were in a higher level language argv can only point to one thing so it’s going to point to the very

but the beginning of your array is not going to be one string like one argument that the user gave

you because the user could give you many arguments instead it’s an array of pointers

so it’s a character pointer array meaning argv is a pointer to a pointer

the first item in any array is what is pointed to by the symbol so like imagine if we had just

had just for the sake of argument imagine if we had an integer array let’s say we had like 500

integers in like a c++ program so the symbol a is what i’m trying to say the symbol a

is really a pointer that points to the first integer in that array and then later of course

you can dereference that pointer with some sort of an index to get the index 5 integer or the

the array and a pointer to the first item.

Or I guess you could say it’s both a pointer to the array

and a pointer to the first item,

because it’s kind of the same thing.

So that means if we grab argv,

then we’ll be grabbing a pointer.

If we then dereference that pointer,

it would tell us where another pointer is.

And then that other pointer would point to a string

representing the first argument.

first argument so we’ll explain that more as i do this loop i’m going to i’m going to show you

some code that actually loops through all the arguments anyway the thing about where to find

that argv is it’s just the next pointer or i guess it’s the it’s the next item that the stack holds

so remember i told you that rsp when this when this function comes in rsp is a pointer to wherever

we’re we’re looking what memory location the top of the stack is so if we dereference that we get

So if we dereference that, we get argc.

Well, we just need to go find the next previous item in the stack

and then dereference that so that we can get the first pointer or argv,

you know, the first pointer to a pointer,

or the first double pointer in your array of pointer to pointers.

Why am I doing plus eight?

This might actually make sense as is,

sense as is but it’s important to understand that when you add stuff to the stack you’re actually

decreasing the memory locations uh that you are pointing to so like if i if i increase a stack

this is not a stack video there’s other videos that i have for that um if we add something to

the top of a stack you imagine the stack growing visually in a in a vertical direction like it’s

growing up right but inside of the computer the memory locations are actually going down

If we’re looking at the stack pointer and we’re adding eight, what it’s saying is that

we’re looking back into memory that was already added for the stack.

So that’s like if we grew the stack, that would be subtracting from the memory location.

So like looking further up in the stack would be subtracting from the memory location because

the stack grows upward in the abstract, but downward in memory locations.

So that means if we add eight, that means we’re going in the other direction.

that means we’re going in the other direction.

We’re looking downward into the stack.

So what that means is that the top two items on the stack

are first argc and then second, that first pointer,

you know, the argv argument.

And that’s how we access it with plus eight.

Why is it a plus eight instead of plus something else?

Because all pointers on 64-bit systems are 64-bit integers

and 64-bit integers are eight bytes.

If we’re talking about eight bytes, sorry,

if we’re talking about eight bits per byte.

So this is just how you access it.

What about this other thing going on here?

What’s this LEA instruction?

Usually you see a move instruction, right?

So we basically want to look at the stack pointer,

but look one level lower.

And each item on the stack is also going to be eight bytes.

We want to look one item lower on the stack,

and then we want to dereference it.

but we don’t want to dereference and store the dereferenced value we still want to grab the

actual pointer the thing is I shouldn’t have said dereference in the first place these are dereferencing

brackets right so like up here on line 46 when you put brackets around rsp it dereferences whatever

value rsp holds so therefore when you put brackets around this you kind of expect that you’re going

to be dereferencing right but we don’t want to dereference we just want the original address that

showing us. So the problem with this is that when we say RSP plus eight,

we can’t actually do a mathematical formula unless we’re inside of brackets, which means we

can’t do them in a move instruction without accidentally dereferencing and losing a pointer

to the actual array of pointers. If we dereferenced like this, we would just end up with,

you know, a pointer to one string. So the way around this is instead of using the move instruction,

instead of using the move instruction we use the lea instruction the lea instruction allows us to

put a formula inside of brackets so that the assembler won’t get confused but then it won’t

put the dereferenced value into r13 it’ll just put the actual value of whatever we see

with that formula meaning it’ll give us the memory location of the item sitting one under the top of

this at this point r13 is now the memory location of the of the item sitting one underneath the top

of the stack and then we can de-reference that later in order to look at all of our arguments

so the next part of our code is just going to print an intro message so there’s like this intro

string up here hello and um i’m basically going to call a custom function that i made to just sort of

Printing. Don’t worry about this code right here.

This is not the point of the video.

I just made a custom function that just kind of helped me print.

Don’t worry about that.

The real meat of this video is that we’re going to loop through all arguments

and just print every single argument that the user provided.

So you can imagine this is maybe the top of a while loop here.

Notice how, oh, I forgot to replace main with start with start.

I had another version of this program that used main.

pretend we have this is called the main loop instead of the the main functions

loop anyway so main loop initialize first thing I’m going to do is I’m going

to initialize the loop by saying we’re looking at index 0 okay no problem so

we’re looking at index 0 we want to do that we want to look at all the

arguments you know we want to look at index 0 and index 1 and index 2 and we

just want to keep going until we’re out of arguments remember that we also have

the number of arguments coming from argc now sitting in r12. So that means if we have a

counter that starts at zero with r14 and then we know how many arguments there are in r12,

we should be able to know when the loop stops. So just a reminder that, you know, the loops here,

the arrays here are zero-based indexed or zero-index based, which means, for example,

that’s three arguments but the array of arguments is going to have indexes zero and one and two

which means the last valid index is going to be two or the size minus one think about that if you

have five arguments the last index that is valid is going to be four size minus one because it’s

zero based so we can use that logic to figure out if we’re done so we start off with an index of zero

here and then at the top of the loop i’m just going to quickly ask are we done how do we know

are we done how do we know if we’re done we compare the current index we’re

looking at with the count and we say if the current index we’re looking at is

greater than or equal to the count then we know we’re already done we don’t need

to look at any more indexes why am I saying is is the index greater than or

equal to the count because remember if we have five arguments then the last

valid index is four therefore if we find ourselves looking at index five we know

already done five is equal to or greater than five, but four is not equal to or greater

than five.

So that’s why I’m using this logic here.

I’m saying if we’re done, then jump to the done label.

Basically what’s the done label?

It’s main loop done.

All it really does is it says goodbye and then it just exits the program with a system

call.

Again, I have other videos that explain system calls and all that stuff.

So if we’re done, we, uh, we jumped down to the done area, but if not, then execute

to the done area but if not then execution will fall through to this next loop or sorry this next

label which is not necessarily we don’t really need a label there but i i like to put i like to

put it there just to help myself remember this is what it looks like in terms of a while loop you

know i have like here’s the top of the while loop here’s the little comparison part of the while loop

here’s the body like the opening braces of the while loop and then here’s sort of like the

closing braces i just like to do that but anyway after we decided that we are not done and we drop

done and we drop through to the next actual instruction we’re just going to

print the next argument so what’s the next argument we will dereference r13

remember up here we took the second item sitting like you know one under the top

of the stack and we just stuck it into r13 so this is r13 is now the address of

the second item on the stack if we de-reference it then that’s going to give

then that’s going to give us a pointer to our um sorry it’s going to give us a pointer to the first

item to the first string i should say to the first string uh the f this the string of the first

argument so if we dereference you know let me say this one more time just to make sure that i’m

item, you know, the item right under the top of the stack, that’s going to be a pointer

to the first argument string.

So if we just simply dereference R13, then we’re basically telling RDI, here’s a pointer

to the string that we want to print.

Okay, so then I just call my helper function to print that string to standard output, no

problem.

And then we have to figure out like, how do we increment to go to the next string?

might have been unclear earlier because gcc does it in a different way but on the stack

every item underneath the the top of the stack is a is another pointer it’s part of the original argv

array it’s another pointer to a different string so basically if i increase r14 here then i’m

increasing the index counter that’ll help us eventually terminate but notice how here i’m

Remember R13 is the second item, you know, the item right under the top of the stack.

And if I dereference that, then I now have a pointer to the first argument string.

If I want to go one lower into the stack, then I just add eight to that register’s value.

Because again, remember, the stack grows downward in memory.

So if I increase the value, then I’m sort of like going through previous items that were put into the stack.

So imagine the stack here, it’s got like,

you know, argc sitting on top

and then underneath argc,

it’s got a pointer to the first argument.

And then under that in the stack,

it’s got a pointer to the second argument.

And then under that in the stack,

it’s got a pointer to the third argument.

Then under that, it’s got a pointer

to the next argument and so forth.

So every time we wanna go to the next arguments pointer,

the next arguments string pointer,

we just add eight to that R13 register,

which was originally just pointing at the first string.

so again why eight because pointers are 64-bit integers therefore they are eight bytes so I’m

just literally increasing the index by one and then I’m moving that register r13 to point to

the next pointer that way next time I dereference it up here on line 70 I’ll be dereferencing the

next string and these strings don’t need to be contiguous they could be located anywhere it’s

that is contiguous but it’s just full of pointers to other strings or sorry it’s full of if we de

reference the stack pointer at any point then we will get the address of a string so then we will

get a pointer to a string this double pointer stuff sometimes i get tongue tongue tired okay so uh

when we’re done printing and incrementing then we just jump to the top of the loop

And then finally, when we’re done, well, we’re done.

Let me draw this out for you, because I think the way I’m explaining it might be

a little bit unclear, so I just want to make sure that I’m being totally clear on

this, okay, so I’ve got my little annotator here and you can imagine here’s a stack

and it visually grows up.

We can imagine that every time we add an item to the stack, it grows up.

Like if you wanted to take a five, stick it on top of the stack.

Well, then it would end up on the top of the stack, right?

No problem.

Right? No problem.

Oh, maybe this needs to be bigger because of my pen size.

So let’s do it like that.

What the heck happened?

I lost the whole desktop.

There we go.

So we have this and this and this and this.

And so there’s probably some kind of a value sitting on top of the stack.

When we started the program,

RSP is a register that just has the memory location of the top of the stack,

you know, the most recently added item.

you know the most recently added item we know that this was actually arg c so if we dereferenced rsp

that’ll go to wherever rx is and get it so we can basically say that rx is sitting on the top of

the stack so you know we dereference our rsp which holds a memory location to this place in memory

we just had an integer stored an eight byte integer okay cool so then the next lowest i guess

the next highest item or the next lower item is arg v at index zero which is the same thing as

just saying arg v remember a pointer to the array is really a pointer to the first item

the next lower item is arg v at index one and so forth so we can just keep doing this we can keep

keep doing this we can keep going lower and lower and lower on the stack by adding eight to r13

because remember r13 originally pointed uh you know to this item right here i don’t know i’ll

say like r13 maybe starts off pointing uh to the first argument because that’s the way we have it

set up so every time the loop iterates if we dereference r13 then we’re getting a pointer to

when we add eight bytes to r13 we’re really just moving it down to the next pointer that we can

dereference hopefully that was a little bit more clear than what i said before or maybe you’re just

a visual learner um you know it’s a good idea to try to explain things in many different ways

but long story short we’re going down down down further in the stack to get more arguments and

we’re just printing them and so now that we’ve explained it all we should be able to just run

clear and make run and under the hood let me just show you real fast what I’ve got inside of my make

file under the hood when we do make run you don’t need to know about make files I have a video that

explains all of this don’t worry but well I mean you don’t need to know it to understand this video

but you probably do need to know it notice how when I call the executable which in this case is

I give it some arguments.

I give it just some strings.

First arg, second arg, third arg, fourth arg.

So that’s the same thing as if I typed echo first arg,

second arg, third arg, fourth arg, right?

That’s what echo is doing.

So in the make file, I’m just giving it those arguments.

And then our program now is looping

through all of the arguments.

It knows when to stop because we grabbed argc

and it knows where those strings are located

are located because the pointers to those strings are just sitting on the stack so if we deref twice

we’re derefing we’re doing a double dereference a pointer to a pointer

at least we could say r13 is a pointer to a pointer but the actual values sitting inside

the stack are just pointers to strings um so let’s just do this in a slightly different way

clear and then I’ll say main because that’s the name of the program that I

compiled you can imagine this is could be named something else and I’ll just put

hello you are super cool now so I’m giving it one two three four five

arguments in addition to main so it should print six things main hello you

are super cool now so notice how it prints main hello you are super cool now

Alright, that’s pretty much everything that I wanted to show you for the pure assembly

version of Grappin Command Line Arguments.

Thank you so much for listening.

It’s a little late for me.

The sun’s starting to come up.

I’ve got to go and eat a bunch of cookies.

So I hope you learned some stuff and I hope you had a little bit of fun.

Thank you so much for watching this video.

I will see you in the next one.

Happy studying and coding and all that stuff.

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

or just i’ll be able to keep making videos in general so please do do me a kindness and uh and

subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because i

know somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you control me if

you want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just wake

up i promise that’s what will happen also uh if you look at the middle of the screen right now you

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

clarifications or errata or just future videos that you want to see please leave a comment or

up what’s going on you know just send me a comment whatever i also wake up for those in the middle of

the night i get i wake up in a cold sweat and i’m like it would really it really mean the world to

me i would really appreciate it so again thank you so much for watching this video and um enjoy the

cool music as as i fade into the darkness which is coming for us all

Thank you.

The post Master Command Line Arguments in x86-64 Assembly with YASM appeared first on NeuralLantern.com.

Hey there, coding enthusiasts! Ready to master compiling, linking, and executing programs on Linux? In this fun and approachable video, we dive into the nuts and bolts of turning your code into runnable programs. We’ll create a simple C++ program, compile it with G++, and explore object files, linking, and execute permissions. Plus, we’ll mix in C and assembly code, tackle name mangling, and build a bash script to automate it all! Perfect for beginners or anyone curious about Linux programming, this guide is packed with practical tips and real-world examples. Don’t miss out—subscribe for more coding adventures, leave a comment with your thoughts, and let’s geek out together! Scan the QR code to visit my site for more tutorials. #LinuxProgramming #CodingForBeginners #CPlusPlus

Introduction to Compiling, Linking, and Executing 00:00:00
Overview of the Process 00:00:05
Writing a Simple C++ Program 00:00:28
Compiling with G++ 00:02:01
Understanding Executable Files 00:03:04
Executing a Program 00:04:21
Handling Execute Permissions 00:05:13
Creating a Compile Script 00:07:00
Using Shebang for Scripts 00:08:43
Specifying Output Files 00:10:53
Breaking Down Compilation Steps 00:12:26
Compiling to Object Files 00:13:17
Linking Object Files 00:15:24
Handling Multiple Source Files 00:18:39
Mixing C and C++ with Name Mangling 00:22:52
Enhancing Script with Error Handling 00:24:29
Adding Assembly Source File 00:31:16
Using Bash Variables for Flags 00:41:53
Organizing Compiler Flags 00:44:41
Final Script Enhancements 00:46:36
Conclusion and Call to Action 00:47:35

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there! Let’s talk about compiling, linking and executing.

This video is going to focus on Linux, but I think it’ll be useful for all other operating systems that you might be working with at home.

I’m just going to basically explain like what does it mean to compile?

What does it mean to link a program?

What does it mean to execute a program?

If you don’t know that, then I think this video might be for you.

Okay, so for starters, imagine you have written a program.

I’m going to write the program here real fast.

I’m going to say, let’s do an empty file.

We’ll call it, let’s see, I got my answer key up here.

We’ll call it first.cpp.

First.cpp.

So I’m just like making a first piece of source code and I’m editing it in my little editor.

Notice how I’m not calling this the main.cpp program because a lot of beginners, they always

do main.

I want you to know that you don’t actually need a source code file called main.cpp.

Even if you’re writing a C++ program, all you really need is just one instance of the function main.

Beyond that also, you only need an instance of main if you’re writing a hybrid program

or some kind of program that is in pure C++ or that has the GCC libraries.

GCC libraries call on the main function as your entry point.

But if you’re writing pure assembly, the entry point is actually underscore start as a label.

We’re not really going to do this is not an assembly tutorial.

I just wanted you to know real fast.

Okay.

So I’m going to do like IO stream and then I’m going to say

STDC out and I’m just going to print, you know, hello from first.

Cpp.

STD.

And L.

Okay.

So we kind of have like a hello world program that’ll just

that’ll just basically print a message and do nothing else how do we compile

this program and execute it you know what does that actually even mean okay

so for starters the first thing that you probably do when you’re compiling a

program you’ve probably been told to do something like this let me get my little

command line open here you’ve probably been told to do something like this

let’s compile with GCC or G++ and we’ll say the standard for C++ that we’re

There are a bunch of other standards you can use.

We can turn on all warnings.

We can have the compiler be pedantic in terms of the warnings that it gives us.

You know, these two things at the end don’t really matter that much.

It’s really all about G++ and then STD C++ 23 to get it compiled.

And then we’ll give an input file.

We’ll say burst.cpp.

And then I think probably usually this is where most of you stop.

you stop we just kind of like specify a couple flags specify the input file then

hit enter and it compiles if we list the contents of the directory now this might

be familiar you’ll probably see something called a.out a.out notice how

the permissions look a little bit different for that for that file it’s

kind of printed in green in Ubuntu and if you look at the left side right here

you can see that it’s got a bunch of X’s in the permissions area that just means

That just means it has execute permission.

The compiler does that automatically for you,

but essentially this is like just, you know,

an executable binary file.

It’s not a text file.

It’s just something that the computer is meant to run.

We can look inside of it real fast.

There’s a program called XXD on Linux,

and it’ll sort of spill the contents of that file.

So if I say XXD and then I go a.out,

it just spills like a whole lot of like binary nonsense,

right?

you can see at the very beginning elf that’s uh i think that’s executable linking format

for linux and then there’s like a bunch of stuff and it just doesn’t make sense this is not text

that you can read here’s like some sort of a shared argument that it’s using and then some

register information i don’t even know what most of this is somewhere in here if you look

carefully you’ll probably see that message where is that oh yeah hello from c first.cpp so it’s

saying that the message we typed in the program is actually embedded in the executable.

That makes sense.

So hopefully I’ve proved to you that this is just an executable program.

How do you execute the program?

Well, usually you’ll have to type, you know, the full path to the program that you want to execute

because your custom program is not in the system library paths.

So your system’s not going to know where to find it automatically,

even if it’s in the current folder.

So you would usually do something like, you know, the full path to your executable,

path to your executable like a.out. But there’s a shortcut we can use in Linux. The dot directory

usually just means or it always means the current directory. So if we say dot and then a slash,

that’s the same thing as typing out the full path to the current directory. Then it’s really easy to

just type the name of the file that we compiled. Okay, so a.out. We executed it now. So that’s what

it means to execute. We just compiled without a lot of options. We’re going to try to do that better

We’re going to try to do that better in a second.

And we know that you need execute permissions.

Let me show you what happens if we take away execute permissions.

I’m going to use a command called chamad, like change the mode.

I’m going to say take away execute permissions from the a.out program.

Then if I list the directory again, notice how there are a bunch of X’s missing now

on the left side of that a.out permissions area.

Notice how it’s not in green anymore.

Depending on your system, it might not be green or gray or whatever.

be green or gray or whatever but just look at the permissions so now if i do a dot out

it’ll say permission denied maybe you’ve seen this before especially if you’re syncing with

the cloud that doesn’t carry execute permissions from one machine to another which happens to me

all the time we can reverse this with just the chamad you know plus x execute permissions

and then we can just execute it again the funny thing about execute permissions is

you can actually execute a bash program which is basically a text file without

without needing to execute a binary program so this is not a bash video I’ll

make other videos in the future on my channels for for bash but for now just

know that something you compile is not the only type of thing that you can

actually execute in fact in Linux under the hood a lot of system tools are just

written in bash or Python or something else that looks like a human readable

like a human readable language and they are not necessarily all compiled languages, you

know, like C++.

Okay, so now that we kind of know that we’re compiling a program, let’s be a little bit

better about specifying the name of the output file.

So I just want you to see one more flag here and while I’m doing that, I’m going to create

a script that will compile our program for us.

nano and I’ll just name a file I’ll name it compile and it’ll be our compiler program okay

so what we did before is it was I think G++ and then we named the standard is C++ 23 and then we

said wall wall just means give me all warnings which is good to help your you know to help you

write better code same thing for pedantic just helps you write better code it gives you more

but you know it’s pretty good. Okay so this is where we stopped last time so

I’m going to say now let me remove a dot out now instead of typing the command by

ourselves we can run the compile script. The language I’ve just written was was

well I haven’t really written in any particular language but if we use a

shell interpreter called bash which is actually what’s running in the terminal

right now it’ll interpret any command line that we give it as just something

line that we give it as just something that we want it to execute to the system. So if I type

bash to run the bash interpreter and I just specify the name of the script, it should compile the

program automatically by executing that one line that I put inside of it. See now I’ve got the a.out

again. If you rewind the video you’ll see the a.out wasn’t there when I originally ran it.

One more time just to prove it to you. bash compile. Now you can see that it’s back. Okay

Okay, so let’s make this compile program a little bit better instead of typing bash every single time

I think I just want to try to execute the compile program directly. I

Can do that pretty easily. There’s something in

In our script that we can put that will designate what interpreter we should use to run the program

So right now it’s just like some text and it doesn’t really mean anything

there’s something called the shebang which just means hash bang and

just provide the path to some interpreter. I’m going to type shebang and then a path

to the bash interpreter. If you don’t know where bash is on your system, you can go which bash.

And I guess mine is a user bin bash. I think I can get away with bin bash. Let me see.

Let me just type it out to make sure bin bash. Yeah. Okay. So if I type exit, I’m actually in

another version of bash, which is inside of bash. If I do exit, I should just kind of stay where I

Okay, so bin bash will work, user bin bash will also work.

I’m going to go back to editing this compiler program.

And now all I have to do, because the system is going to know what interpreter to use to execute my little script program here,

all I have to do is add execute permissions on it, and it should work.

So let me first remove a dot out.

And then let me try first to execute compile.

It should not work because I don’t have execute permissions.

Remember we talked about that before.

permissions. Remember we talked about that before? So if I do that it says

permission denied. Oh no! So I’m going to give it permission to execute. I’m going

to say change the mode plus X on compile. If I list the directory again notice how

it’s green notice how there’s a bunch of X’s everywhere. So now I should be able

to just say compile and then it seems to have worked and notice how it has an

because it’s a pain in the butt to type out all the compile commands every single time,

especially if you have a complicated compile command or many files that you want to compile

in the same shot. So, you know, of course, in another video, I’m going to talk about make files,

build systems, proper build systems are a lot better than just making a script. But for now,

let’s just make a script because I just want you to understand, you know, compiling, linking,

some of the surrounding ideas. Okay, so I’m going to, let’s see, I’m going to go nano compile.

And the next upgrade that I want to make is I want to specify the output file because it’s

kind of a bad idea to not specify the output file and just hope that the compiler gives you

the file that you wanted. I don’t know. So I’m going to do dash O main, and that’s going to give

So if I remove a.out just to keep my area clean, I can now do compile.

And if I list again, notice how I’ve got main.

So I can execute main and it’s the same program that we already had.

In fact, maybe sometimes just as a shortcut since this is a script,

what if I’m always hitting ls-la, I always want to list the folder after I compile.

I could just put that into the script.

The more commands you put into the script, the more convenient things can get, unless

I guess it gets too messy.

So I’m going to do, I’m going to list first, and I’m going to remove main, just to prove

to you that we’re doing this from scratch, and then I’ll do compile.

Notice how it compiles and then lists everything for me.

Seems like it didn’t actually turn the compile green.

That’s probably another flag that we have to stick in there.

Let me see if I can do that real fast.

If not, I won’t waste time.

This is not an LS video.

probably color or colors is what I got to do. Let me just do that one more time. Yeah, okay. So

that’s just a flag on LS. That’s not what this video is about. So now we’re compiling directly

to main, but here’s the problem though. We’re actually kind of sort of skipping over some

steps that we could be aware of. When we compile our program, we’re actually taking our source code

and we’re assembling it down to assembly code under the hood, and then we’re compiling it to

And then we’re compiling it to an object file, which is sort of just machine code.

It’s like a level lower than assembly.

And then as a last step, it’s getting linked into an executable named main.

So we’re skipping a ton of steps.

Really what’s supposed to be happening is every single source file.

Oh, whoops.

I’m on the wrong machine right now.

Okay.

Where’s that?

Oh, the machine that I’m recording on.

There we go.

CPP and we’re thinking that it just goes directly to main you know that works if you only have one source file or if you don’t want to have

fine-tuned control over your compiling

But I would like to do something a little bit more detailed. Let’s compile our

CPP source file into an object file. I’ll name it first.o and then we’ll link that into main

Why is that useful because later when we have multiple source files?

We might we might want to compile them all to object files first and then link them all together in one step into main

all together in one step into main this will be even more useful when you later realize that you

can use a build system that does kind of the same thing to save compilation time i won’t talk too

much about make files here but let me just tell you when you start using a build system

your compile time can be drastically reduced uh story i used to have a program a long time ago

that i wrote myself took like an hour to compile i would literally every little change i made i’d

have to get up and leave and go make a sandwich or something and then come back by the time it

back by the time it was finished compiling when i started using object files as intermediate steps

and upgraded to a build system i was using gnu make then my compile time went down to like a

minute each time so it was like so much more efficient anyway let’s do that let’s do that now

let’s let’s uh let’s nano our compile script and you just need another flag in here for the gcc

an object file and not actually produce a fully linked executable that you can execute that means

i should probably rename main to something else because main is supposed to be my executable at

least that’s what i’ve chosen i would like to have every object file be named similarly to the source

file it belongs to so i’m going to type the output now is going to be first.o and then the c flag

just says only compile don’t link this means of course that i’m not going to produce a program

a program that I can run. Let’s see, I’m gonna end up accidentally deleting the

compiler. Okay, but we can see what we’re doing. Okay, so compile and CPP for first.

So I’m gonna compile it and now notice how we have an object file and no main

and just the source file and its corresponding object file. So I can’t run

this program. I have to do the additional linking step now. So I’m gonna do

step now so I’m going to do compile and in my editor here let’s see where is my

command that I wanted to do for linking okay so I’m going to link with the the

GCC libraries I’m gonna use the G++ command I’m just gonna put a couple of

flags I’ll explain them real fast I’m gonna say that I want a 64-bit

executable which you probably actually don’t have to specify I’m going to

anyway and then I’m gonna tell it again that I want it to link up against the

23 libraries. This is important if multiple modules reference the C++ libraries. I’m not

even sure. I think I need it in both the compiling command and the linking command. I’m going to

leave it in both because it should work. Usually if you want to embed debugging symbols into your

program, you want to put a dash G there, which is a great idea. But we’re not going to talk about

debugging in this video. You can also specify the type of debugging symbols that you want.

symbols that you want I’m just gonna put that in here right now G dwarf 2 and

then there’s some new flags that you kind of need there’s one here called no

PI which I think is just an Ubuntu thing your program probably won’t execute if

you don’t do that just just put it in there and trust me there’s another one

that we have to put in now called no exec stack which basically prevents your

program from executing code sitting inside of the stack which is just sort

not get hacked hopefully it’s not bulletproof but you know it might help

and then i’m going to give it input files the input files for the linking

stage maybe i should do a comment linking stage

compile the c++ program or source or something

for the linking stage uh you want to you want to provide all of the object files

that you’re going to link together in this case we just have you know

file named first and then we can specify the output file as main if we didn’t

specify it would probably be a dot out like we saw before so if I got this

right let’s see if I did now this should compile the C++ source code file into

its corresponding object file and then scoop up the object file turn it into an

executable okay so my clear and then list and then I’m gonna remove the object

put star dot o which is a shell trick to basically say that that star dot o is

going to expand to really mean every file that ends in dot o so you know in

this case it’s actually just gonna end up being first dot o but it’s a trick you

can use to grab multiple object files or files of a certain type all in one

command so I’m gonna do that and then I’m gonna list again and then I’m gonna

compile and you can see that the compile command it created first dot o the

the object file, and it also created the executable main.

So if I execute main, the same thing should happen.

So great. We’re ready to move on to another step.

Let me remove star dot O.

I got to be so careful because I’m going to totally ruin this video by erasing the wrong thing.

Okay. Because this is, I should be in a Git repository, but I’m trying to be fast here.

Okay. So let’s nano compile.

Let’s create a second source file actually.

Okay. So let me get out of this.

Let me get out of this.

I want to create a second source file.

I’m going to call it second.c.

It’s going to be a pure C program.

And because we don’t have C++ libraries in C source files,

I’m just going to say, you know,

standard input output dot O for the header.

I’m going to make a function called void second probably.

And it doesn’t do anything except just sort of print

a little message.

So I’m going to say hello from second.

And then do a new line.

because we don’t have endels in c all right i think that’s probably going to work so then

let’s uh edit our compiling script and we’ll just add another line here to compile the c source

okay so i’m going to go gcc because it’s not c plus plus anymore and um i’m going to do all

warnings and pedantic again uh you don’t really need even need to worry about that and i’m going

need even need to worry about that and i’m going to give it an input of second.c because that’s the

file we just worked on and i’m going to tell it i only want you to compile with the dash c flag if i

forgot that on this one then i’ll probably end up with an object file a main and then an a.out that’s

only based on the c source code and that probably wouldn’t work because the second source code

doesn’t have a main function inside of it so um let’s see we’ll do output and it’s going to be

and then I think that should be okay you know something that I just realized I

should mention too is when you’re making hybrid programs like this or or

programs where there are just many many source files like I said before you

don’t need to have a source code named main.cpp you can name all your source

codes anything that you want the one thing that you really do need is a piece

of source code oh I’m editing inside the terminal suddenly sorry I got

Sorry, I got sidetracked.

I wanted to edit all this stuff inside of Genie because it’s a little bit better.

Maybe it doesn’t matter.

So notice how we have the main function inside of our first.cpp program,

and then there’s no main function inside of our other source codes.

For your program that uses the GCC libraries, you need exactly one instance of main.

so that means um you know you have to have at least one and if you have more than one it’s

probably not going to link so if i put a main inside of here probably not going to work

this also kind of means you can arrange your source code in a funny way you could

have a bunch of different pieces of source code that you could consider maybe libraries maybe

there are a bunch of classes or something that will help your program and you can release multiple

different executable files by just having different source code files each with their own

mains and linked separately against the object files that contain your library or classes or

whatever that’s just a little side tip but um anyway let’s see if i actually did this right

we’re linking this and i’m going to see if it works i get stuck inside of the terminal i start

thinking i’m going to edit everything inside there okay so it compiled well let me let me

remove the main and then just clear it again in the list okay so now I’m gonna

run the compiler and after the compiler ran everything seemed to be okay it

compiled first into its object file and it also compiled second into its object

file if I run the main executable notice how it only prints hello from first dot

CPP well what about the second one that we just added well what we need to do is

improve our linking stage notice how in the linking stage right here we just

stage right here we just only link first.o so we should also include the other object file that we

want i’m going to glob that in a second but uh let me show you compile now if we run main

what did i do wrong hold on let’s see here second.c oh i forgot to actually call the second

function so that’s cool just uh wrote a bunch of stuff for no reason at all let me uh let me have

have the main function call on the second function we’re going to encounter an issue here too the

second function is written in c and the first function uh its its source code is in c plus plus

and the thing is c plus plus uses something called name mangling i won’t go over it too much in this

video but it uses name mangling so you can overload functions you can have functions with the same

name but like different signatures right so it’ll go in there and it’ll mangle the name of a function

the name of a function according to its overload prototype so that we can actually call overloaded

functions but we don’t really have that in C so that means if we try to call a C function

from C++ we’re probably going to end up calling the wrong name because there’s the expectation

that the other module has name mangling enabled but it’s not because it’s C so I just have

to do this little block extern C and just name all the stuff that is not going to be

name mangled i’ll just provide the prototypes of all the functions that i want to be able to call

so just void second if you look here again we just have void second and now when um when the c plus

plus module calls on second it won’t expect name mangling so it should work so we’re calling it

and then we linked it now everything i think should be okay i’m going to compile one more time

and then i’m going to run the main program and now you see that we have both calls in there

Awesome. Let’s give this script a little bit more output though. This is kind of

precarious. What if something failed inside of there? Maybe you don’t want the script to continue

if something fails and maybe you kind of want to know where the script is at while it’s compiling.

So I’m going to upgrade it just a little bit. So compile the source. I’m just going to say echo

compiling the, you know, compiling burst.cbp. And then here I’ll just do another echo and I’ll say

and then here I’ll say echo linking the executable or the binary aka the binary

I don’t even know if that’s the proper term I just like to call these things binaries because

they’re not in text anyway so if we do another I’m going to do I’m going to do a compound

command line here I’m going to go clear and compile so that I don’t have to continue to

continue to clear every single time. Now notice how it prints what it’s doing. So if it kind of

failed somewhere along the way, or if it took a long time, you’d kind of know what’s going on.

Now let’s use a little bash trick, because remember this is a bash script. It’s not just

going to only execute actual commands. I’m going to say or exit with the return code of the previous

We’re going to try to execute G++.

If G++ fails for some reason, then the whole program or the whole script is going to exit

and it’s going to exit with the return code mentioned here.

I think it’s not going to print it.

I’ll show you how to print it in a second, but we can actually make a function called

die up here in a second, which might be better.

So I’m going to do the same thing over here.

I’m going to say or exit with the return code of the GCC command and then here or exit with

And then here or exit with the return code of the linking command.

We’ll do it one more time here.

Notice how it seems to work.

So now let’s make the first C++ program not actually compile.

I’ll put a bunch of Zs there.

And so if we try to compile it again, it should just quit right after it tries to compile the C++ program.

So that saves you some time and helps draw your attention to what went wrong.

The C++ compiler is saying hey, there’s like a type there. It doesn’t show the exit code though. So let’s make a function in bash

That will die and print an exit code. So I’m going to say do die or maybe just die by itself something like that

Functions whoops. I’m in the wrong language

Let me go back to the compiler

make a function in bash

Called die and it’ll take one argument and the argument will just be the exit code

that we want it to alert us of.

So I’m going to say echo,

I’m going to say we are dying now.

Previous exits code was,

maybe I’ll do a little variable here,

I’ll do a local variable.

Exit code is going to be the first incoming argument.

This is a bash program, not C++.

And then here I can just say exit code.

Okay.

So then after writing all that,

then after writing all that I can say or die and then just you know so I’m calling

a function and the first argument I’m giving it is the actual exit code of the

thing that died so we’re just kind of like using indirection to print a pretty

pretty message to get a little bit more information so we’ll try that one more

time notice how it says we are dying now previous exit code was one so that just

that just tells us that gcc exited with the exit code of one not super useful but it’s nice to see

could be something else entirely like i don’t know maybe uh maybe we misname the first source

code file let’s see if the code changes i think it probably will nope maybe this exit code was one

no such file or directory all right exit code am i doing something wrong i guess i’m all right

Alright, okay, so let’s just move on.

I wanted it to be fancier.

We could also upgrade a little bit if we wanted to.

Instead of echoing, I could make a function called log here,

and I could just say that the log command just echoes,

and maybe we’ll put a cute label, and we’ll say, you know,

my super cool program compiler, or how about super cool compiler?

And then just do the $1, because that’s the first incoming argument that you get.

the first incoming argument that you get now I can type log instead of echo so

that’s nice and why would you want to do this well now it’s gonna go inside of a

function which means later on you can start adding extra commands like logger

a log to the system daemon oh no so this would write to your system log in

addition to printing something you could do anything you want you know it’s just

like a regular program adding more power by sticking everything inside of

functions I’m gonna put log here and let’s see if it works

let’s see if it works pile okay nice notice how we have a little message with a little header which

seems pretty cool maybe instead of echoing here let’s make a complaint function let’s do a

complain and same thing as the echo function but maybe I think there’s a flag where you can tell

echo to print to standard error instead of standard output but I’m just going to do it the easy way

it the easy way I’m going to say one goes to two so that the the first pipe standard output is going

to be redirected into the second pipe standard error so now I can use complain instead of um

echo down here complain before I die oh I forgot to actually

or die I forgot to actually exit so that means it was oh yeah it’s still compiling everything

Let me fix that.

So in the actual die function, hopefully you were at home cringing along with me.

Let’s see, let’s exit with the actual exit code that was specified just to make things

a little bit more automatable.

Yeah, now it stops right away.

And the complainer is like, you know, pretty cool.

Let me fix the first source code real fast.

And we’ll say that the second source code is broken.

We’ll put a bunch of Z’s there.

So now the first one compiles, the second one, it breaks.

And we’re starting to, you know, get a hang for a compiler script that’s a lot more sophisticated

than just typing things on the command line, right?

You can take this as far as you want.

The next step above this is using a proper build engine.

So let’s see.

Well, let’s do another source code.

an assembly source code. So we’ll say third dot ASM and it’s just going to be Yasm. This is not

a Yasm or assembly tutorial. I’m just showing you how to, you know, build a, you know, compile,

link and execute. We’ll make a data section so I can just stick some defines in here real fast.

I’ll say system write is going to be equal to a one and then the file descriptor for std out

Do you ever feel like red jumps out at you on the screen?

Does that mean I have eye problems?

I am kind of old now.

I don’t know.

Hello from third dot ASM and I’ll just put a little new line there.

So I don’t have to do it elsewhere.

And then I’ll have to specify the magic message length because this is not a sophisticated program that can loop through the message looking for a null terminator.

And then I’ll do a text section, which is where your code goes.

which is where your code goes and you know in hybrid programs if I have this

third function which is marked as a which is marked using a label and then

in return statement I still have to mark a third as being accessible outside

this module so I’m going to do the global statement and then I’m just going

to do really quickly I’m going to move something into RAX it’s going to be

system right so basically I would like to write something somewhere to some

some file descriptor its first argument wants where I want to write it so I’m

gonna write it to the standard output instead of an actual file and then I’m

gonna move RSI the next argument is going to be the actual message or a

pointer to the message that I defined above and you know check out my other

videos if you want to learn assembly that’s this is not this is not an

assembly learning video I’m just kind of doing it real fast in case you’re

probably unless I ruined it somehow let’s start compiling or assembling the

assembly program so just one more we’ll say assemble the assembly source or

module or whatever you want to call it we’re going to use the ASM to do that

G dwarf 2 is the debugging symbols not necessary in this video the format is I

want a 64-bit executable that’s how you do it in Yasm and I’m going to give it

and I’m going to give it an input of just the third assembly source file.

And I want it to output the third object file.

I got to remind myself to glob line 36 after this or die with the exit code.

Okay. So now this might work.

Oh, I got to put, I got to put third dot O in the linking stage.

I’m going to do clear and I’m going to go here and compile.

and compile.

Unrecognized debug format, dward.

Why didn’t you stop me?

It’s g dwarf.

Let’s see, what did I do wrong?

g dwarf, oh, dwarf dash two.

Oh, it’s not even g, it’s just dwarf two.

Sorry.

And I got to put a dash, I think, for EASM.

Yeah, okay.

Let’s see if that works.

What did I do wrong?

Oh no no, Yasm doesn’t need the dash, but GCC wants the dash.

Okay, I had it right the first time.

Doop doop doop, okay, so it probably linked.

Let me run it and see what happened.

Hello from the second, oh, we still have to actually call it from the C++ module.

So now we’ll do the same thing.

We’ll say that the assembly module, it’s not going to use name mangling.

use name mangling there’s no overloads so we’re going to put it into the extern C

block and we’ll just say you know void third how do we know that’s that it’s a

void function with no arguments well you know that’s just a convenience that

happens under the hood with C and C++ in assembly it’s just a label that you’re

jumping to and returning from void means return type all that means is I’m

trying my best not to make this a C++ or an assembly tutorial but all that

All that means is there is no return value getting returned.

That would be the RAX register if I wanted to move something in there.

And then similarly, if I wanted to catch arguments, I’d be grabbing from other registers.

So I’m not grabbing any register, any arguments from registers, and I’m not sending a value back with RAX or XMM0 or anything.

So that just means it’s void and no arguments.

So let’s do it again.

Compile it and then run main.

then run main hello from second oh i sure put in the name mingling thing but i forgot to call it

let me do that third so now one more time compile and then run it

what’s happening in here

third i guess i should probably open this up now third asm so global third and then third oh

important part of a system call you got to put the keyword or the instruction system call in there

one more time i hope you’re laughing and cringing at home trying to make this more fun maybe i don’t

know okay so now it’s all it’s all working notice how we have a bunch of different modules in

different languages we’re compiling them all to object files first and we’re uh we’re linking

them all into one executable and we’re doing this in a really really easy way by using a script

script instead of typing all the commands out manually. Pretty convenient, right? Let me give

you another upgrade real fast here. So this is kind of irritating. I have like all of these object

files that I have to specify. What if I forget to specify some? Since this line 36 is just going to

be something that goes directly, you know, to the shell as a command line. This is not like bash

wildcards I can say star dot o meaning I’m going to give every object file to

the linker as an input file and that should just work automatically keep in

mind if you want to use an advanced strategy like I mentioned earlier where

you have multiple different object files and they’ve each got their own main

functions because they’re each going to be their own separate executables then

globbing all object files probably not going to work you might want to organize

files or stick the object files for executables in like their own folders or

something like that we’re not going to go that far but I just want you to know

so let’s do that again real fast here we’ll say clear and compile and I’ll

just try to like run main assuming that the compiler works yes so it worked

everything compiled by the way this and end that means only execute the next

So if I, you know, clear is obviously going to succeed and then compile, it might succeed

or not.

Then I’m going to try to run main.

Let me actually, let me actually do that real fast.

Let me show you what I’m talking about.

I’m going to remove main.

You’re okay.

So then I’m going to do clear and compile and main.

So obviously if everything works, then everything works.

But if I do that again, where something is not actually going to compile, like maybe

the second the c source program is not going to compile by putting some z’s in there then the

dot main or yeah that part shouldn’t get executed so it won’t try to execute our program

notice how it just stops so that’s convenient if i do it again though with a different command

if i chain instead of between the commands instead of putting and end to say one must execute before

semicolon then they will all execute no matter whether whether they succeeded or not maybe in

certain things you’re doing you actually want that behavior but in this case it’s going to be bad

watch what happens it fails to compile and then at the end it also tries to run a program that

doesn’t exist because it never got linked because the script stopped so i’m just letting you know

you have lots of different options when you’re writing these scripts we do it again and then let

And I think, well, maybe there’s one other thing I want you to know.

Sometimes these lines get really, really long, right?

And it’s messy and irritating.

At least for me.

Maybe if it goes off the side of the screen for you, it’s like, oh, that’s awful.

You can actually just separate a command across multiple lines with a backslash.

Or sorry, I think that is called a forward slash.

It’s the drive slash.

I don’t remember forward slash backslash.

I just say web slash and drive slash.

So I’m going to do G++ and do a little slash.

Then I can put the whole rest of the thing on the next line.

If I wanted to, I could start separating these out by category.

So maybe I’m like, oh, I don’t know.

Maybe M64 on its own line.

And then I’ll keep these other two on their own line.

And maybe these two on their own line.

You know, it’s up to you how you organize this.

And then I’ll say, give me all the input files on its own line.

And then the output file on another line.

on another line you could even put the or bars for the die part on its own line I

guess I’ll just try that and now let’s just make sure that this still compiles

let me remove star dot o and remove main it’s not there okay so clear and then

list and then two showed up somewhere oh my mistake I probably should have caught

some file got saved as a two I should have noticed okay so let’s do clear and

compile and I just run main okay so now everything works notice how even though

everything was on a different line it all just seemed to work cool what about

something here on line 38 we’re using the C++23 standard but we’re also doing

that up here and we’re also using the all warnings flag up here and down here

and pedantic also and even the linker like what if I want to put all warnings

into the linker we could make variables in bash and by the way this is totally

starting to become a job for for mark for make files but for now we’re just

stay in bash so I can make a variable in bash I can say maybe GCC flags name it something and I’ll

just put equals whatever and I’ll just type the stuff that I know is going to appear in every

single invocation of G++ or GCC so I’m going to go wall because I want to put that everywhere

and I’m going to say C++23 because I’m going to put that everywhere and probably pedantic I’m

I’m not going to put the dash C flag everywhere because notice how I’m only putting that on the compiler commands when I just want to make an object file.

But when I’m linking, there’s no dash C because that means you got to actually link.

So let’s see.

We got G dwarf two, G dwarf two.

Maybe I could put G dwarf two there and see if it still works.

So I want debugging symbols and I want them to be in dwarf dash two format, which honestly is the default format.

which honestly is the default format if you just put dash G.

Let’s see if I can get away with that for now.

So I’m going to go GCC flags.

And here I can get rid of C++23 and wall and pedantic.

And I’ll just insert instead GCC flags.

And if you want to be extra careful,

you can put these little braces around the variable name of that.

Probably should be fine.

But because I don’t want to type that again,

I’m just going to copy paste it into the other command.

So wall pedantic, just paste that.

Just paste that and then I’m going to leave it alone for Yasm because Yasm is different than GCC.

And then here I’m going to do another line where I just kind of put the flags.

That means I can get rid of those two flags.

And then wall and pedantic are going to show up.

No pi is kind of a linker only thing.

So is the no exec stack.

I think probably that will be okay.

Let’s see if I got that right or wrong.

Oh no.

Unrecognized command line option.

Wall pedantic GCC.

Oh, I guess because I quoted it.

I shouldn’t have done that.

Because I quoted it, the command line thought that that was all one argument.

I should have remembered.

So I’m going to unquote it right now.

This should help the command line understand that all of the things inside of that variable,

the GCC flags, are separate arguments instead of just one argument.

Let me try one more time.

Yay, it seems to work.

Okay, we got a warning here.

Command line option C++23 is valid for object,

but not for C.

Okay, so basically I made the mistake

of trying to send a C++ object,

which is this right here, or sorry,

a C++ argument, which is this right here,

into a C compiling command.

Not great.

So what if I did this?

I’ll do C flags, and it will contain only flags for C,

for C and then I’ll have another one for C++ flags

which will only contain things that are for C++ compiling so the regular C compiling can take

wall and pedantic okay and then it can take the G dwarf 2 okay the C++ flags it can take everything

except for um sorry the C++ flags can actually take all of the C flags and then additionally the

and then additionally the the c++ 23 flag so i could embed a variable inside of itself i could

say c flags or sorry i could embed a variable inside of another variable so that i can just

steal all of the flags from the c flags variable stick them also in the c++ flags variable and

then just add one more at the end of that hopefully that works i think it probably will

here and then use the C flags here just for compiling I could probably name the

variable better put the word compile in there or something but I don’t really

want to I think some people put CC to mean like C compiling but I don’t know I

just want to do it this way so we have that and then we’re gonna do CPP flags

like this we could also organize the variables differently so that the we

We could have some linker flags, which basically would probably have all of this stuff minus dash C.

And then we could have linking flags.

No, we can have linking flags that has all that stuff minus the C.

And then we’ll have like some compiler flags that has the linking flags plus the dash C.

But I don’t really want to spend a bunch of time on this now.

For now, we’ll just say we have C flags and CPP flags.

And we’ll just manually add that dash C.

But of course, keep in mind, you can organize these things any way you want.

and organize these things any way you want.

So I’m gonna do,

well, this might actually work.

I’m getting distracted.

I think it works.

Okay.

Let me just double check by removing all the object files.

There’s a two in there still.

Let’s debug that if it happens again,

then I’m gonna remove main.

Okay, then I’m just gonna list everything real fast.

Okay, let’s see.

Is there gonna be a two in there now?

Is there going to be a two in there now?

No, is that only when it fails?

Only when something fails to compile?

I mean, it’s working, so that’s good news.

You know what?

Leave a comment somewhere letting me know

where you think I went wrong with this two,

and maybe I’ll release another video

or something in the future,

at some distant point in the future.

But yeah, anyway, I hope you learned a lot of stuff

in this video and you had a little bit of fun too.

had a little bit of fun too. This has been, you know, a little intro for compiling, linking

and executing in Linux, but also probably on a bunch of other systems if you have these

same tools, and you’re working inside of bash. Thank you so much for watching this video.

I’ll see you in the next one.

of my heart i really appreciate it i do hope you did learn something and have some fun if you could

do me a please a small little favor could you please subscribe and follow this channel or these

videos or whatever it is you do on the current social media website that you’re looking at right

now it would really mean the world to me and it’ll help make more videos and grow this community so

we’ll be able to do more videos longer videos better videos or just i’ll be able to keep making

Do me a kindness and and subscribe. You know sometimes I’m sleeping in the middle of the night

And I just wake up because I know somebody subscribed or followed it just wakes me up and I get filled with joy

That’s exactly what happens every single time

So you could do it as a nice favor to me or you could you could troll me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, uh, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

go to the website which i think is also named somewhere at the bottom of this video and it’ll

take you to my main website where you can just kind of like see all the videos i published and

the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know just

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

coming for us all

Thank you.

The post Compile, Link, Execute: A Beginner’s Guide to Linux Programming with C++, C, and Assembly appeared first on NeuralLantern.com.