Procedures & The Stack Spring 2016 Procedures & The StackProcedures & The Stack Spring...

Spring 2016Procedures & The Stack

Procedures&TheStack

Announcements¢ Lab1graded

§ Latedays§ Extracredit

¢ HW2out¢ Lab2prepinsectiontomorrow

§ Bringlaptops!¢ Slides

HTTP://XKCD.COM/1270/

Roadmap

car *c = malloc(sizeof(car));c->miles = 100;c->gals = 17;float mpg = get_mpg(c);free(c);

Car c = new Car();c.setMiles(100);c.setGals(17);float mpg =

c.getMPG();

get_mpg:pushq %rbpmovq %rsp, %rbp...popq %rbpret

Java:C:

Assemblylanguage:

Machinecode:

01110100000110001000110100000100000000101000100111000010110000011111101000011111

Computersystem:

Memory&dataIntegers&floatsMachinecode&Cx86assemblyProcedures&stacksArrays&structsMemory&cachesProcessesVirtualmemoryMemoryallocationJavavs.C

Mechanismsrequiredforprocedures¢ Passingcontrol

§ Tobeginningofprocedurecode§ Backtoreturnpoint

¢ Passingdata§ Procedurearguments§ Returnvalue

¢ Memorymanagement§ Allocateduringprocedureexecution§ Deallocate uponreturn

¢ Allimplementedwithmachineinstructions§ Anx86-64procedureusesonlythose

mechanismsrequiredforthatprocedure

P(…) {••y = Q(x);print(y)•

int Q(int i){

int t = 3*i; int v[10];••return v[t];

Questionstoansweraboutprocedures

¢ HowdoIpassargumentstoaprocedure?¢ HowdoIgetareturnvaluefromaprocedure?¢ WheredoIputlocalvariables?¢ Whenafunctionreturns,howdoesitknowwheretoreturn?

¢ Toanswersomeofthesequestions,weneedacallstack …

Outline¢ StackStructure¢ CallingConventions

§ Passingcontrol§ Passingdata§ Managinglocaldata

¢ IllustrationofRecursion

MemoryLayout

Instructions

Literals

StaticData

DynamicData(Heap)

Largeconstants(e.g.,“example”)

static variables(includingglobalvariables(C))

variablesallocatedwithnew ormalloc

localvariables;procedurecontext

MemoryAddresses

HighAddresses

LowAddresses

MemoryLayout

Instructions

Literals

StaticData

DynamicData(Heap)

Stack Managed“automatically”(bycompiler)writable;notexecutable

Managedbyprogrammerwritable;notexecutable

Initializedwhenprocessstartswritable;notexecutable

Initializedwhenprocessstartsread-only;notexecutable

Initializedwhenprocessstartsread-only;executable

segmentationfaults?

x86-64Stack

¢ Regionofmemorymanagedwithstack“discipline”§ Growstowardloweraddresses§ Customarilyshown“upside-down”

¢ Register%rsp containsloweststackaddress§ %rsp =addressoftop element,the

most-recently-pusheditemthatisnot-yet-popped

StackPointer:%rsp

Stack“Top”

Stack“Bottom”HighAddresses

LowAddresses

StackGrowsDown

IncreasingAddresses

x86-64Stack:Push¢ pushq Src§ FetchoperandatSrc

§ Src canbereg,memory,immediate§ Decrement %rsp by8§ Storevalueataddressgivenby%rsp

¢ Example:§ pushq %rcx§ Adjust%rsp andstorecontentsof

%rcx onthestack

Stack“Bottom”

StackPointer:%rsp

Stack“Top”

HighAddresses

LowAddresses0x00…00

StackGrowsDown

IncreasingAddresses

¢ popq Dest§ Loadvalueataddressgivenby%rsp§ StorevalueatDest (mustberegister)§ Increment %rsp by8

¢ Example:§ popq %rcx§ Storescontentsoftopofstackinto%rcx andadjust%rsp

StackPointer:%rsp

Stack“Top”

Stack“Bottom”x86-64Stack:Pop

HighAddresses

StackGrowsDown

IncreasingAddresses

Thosebitsarestillthere;we’rejustnotusingthem.

Procedures¢ StackStructure¢ CallingConventions

ProcedureCallOverview

Caller

Callee

¢ Callee mustknowwheretofindargs¢ Callee mustknowwheretofindreturnaddress¢ Callermustknowwheretofindreturnvalue¢ CallerandCallee runonsameCPU,sousethesameregisters

¢ Howdowedealwithregisterreuse?¢ Unneededstepscanbeskipped(e.g.ifnoargumentsornoreturnvalue)

…<setupargs>call<cleanupargs><findreturnval>…

<createlocalvars>…

<setupreturnval><destroylocalvars>ret

procedures

ProcedureCallOverview

Caller

Callee…

<saveregs><setupargs>call<cleanupargs><restoreregs><findreturnval>…

<saveregs><createlocalvars>…

<setupreturnval><destroylocalvars><restoreregs>ret

¢ Theconvention ofwheretoleave/findthingsiscalledthecallingconvention(orprocedurecalllinkage).§ Detailsvarybetweensystems§ Wewillseetheconventionforx86-64/Linux indetail§ Whatcouldhappenifourprogramdidn’tfollowtheseconventions?

CodeExamples

long mult2(long a, long b)

{long s = a * b;return s;

void multstore(long x, long y, long *dest) {

long t = mult2(x, y);*dest = t;

0000000000400550 <mult2>:400550: mov %rdi,%rax # a400553: imul %rsi,%rax # a * b400557: retq # Return

0000000000400540 <multstore>:400540: push %rbx # Save %rbx400541: mov %rdx,%rbx # Save dest400544: callq 400550 <mult2> # mult2(x,y)400549: mov %rax,(%rbx) # Save at dest40054c: pop %rbx # Restore %rbx40054d: retq # Return

ProcedureControlFlow¢ Usestacktosupportprocedurecallandreturn¢ Procedurecall:call label

1. Pushreturnaddressonstack(why?,andwhichexactaddress?)2. Jumptolabel

ProcedureControlFlow¢ Usestacktosupportprocedurecallandreturn¢ Procedurecall:call label

1. Pushreturnaddressonstack2. Jumptolabel

¢ Returnaddress:§ Addressofinstructionimmediatelyaftercall instruction§ Examplefromdisassembly:

400544: callq 400550 <mult2>

400549: movq %rax,(%rbx)

Returnaddress=0x400549

¢ Procedurereturn:ret1. Popreturnaddressfromstack2. Jumptoaddress

nextinstructionhappenstobeamove,butcouldbeanything

ProcedureCall Example(step1)

0000000000400550 <mult2>:400550: mov %rdi,%rax••400557: retq

0000000000400540 <multstore>:••400544: callq 400550 <mult2>400549: mov %rax,(%rbx)••

0x400544

•••

0x400550

0x400549

•••

ProcedureCall Example(step2)

0x400557

0x400549

•••

ProcedureReturnExample(step1)

0x400549

•••

ProcedureReturn Example(step2)

ProcedureDataFlow

Registers– NOTinMemory!¢ First6arguments

¢ Returnvalue

Stack– inMemory!

¢ Onlyallocatestackspacewhenneeded

•• •

HighAddresses

Diane’sSilkDressCosts$8 9

X86-64ReturnValues¢ Byconvention,valuesreturnedbyproceduresareplacedinthe

%rax register§ Choiceof%rax isarbitrary,couldhaveeasilybeenadifferentregister

¢ Caller mustmakesuretosavethecontentsof%rax beforecallingacallee thatreturnsavalue§ Partofregister-savingconvention

¢ Calleeplacesreturnvalueintothe%rax register§ Anytypethatcanfitin8bytes– integer,float,pointer,etc.§ Forreturnvaluesgreaterthan8bytes,besttoreturnapointer tothem

¢ Uponreturn,caller findsthereturnvalueinthe%rax register

DataFlow Examples

long mult2(long a, long b)

{long s = a * b;return s;

void multstore(long x, long y, long *dest) {

long t = mult2(x, y);*dest = t;

0000000000400550 <mult2>:# a in %rdi, b in %rsi400550: movq %rdi,%rax # a 400553: imul %rsi,%rax # a * b# s in %rax400557: retq # Return

0000000000400540 <multstore>:# x in %rdi, y in %rsi, dest in %rdx•••400541: movq %rdx,%rbx # Save dest400544: callq 400550 <mult2> # mult2(x,y)# t in %rax400549: movq %rax,(%rbx) # Save at dest•••

Outline¢ Procedures

§ StackStructure§ CallingConventions

§ IllustrationofRecursion

Stack-BasedLanguages¢ Languagesthatsupportrecursion

§ e.g.,C,Java,mostmodern languages§ Codemustbe re-entrant

§ Multiple simultaneous instantiationsofsingleprocedure§ Needsomeplacetostorestateofeachinstantiation

§ Arguments§ Localvariables§ Returnpointer

¢ Stackdiscipline§ Statefor agivenprocedureneededfor alimitedtime

§ Startingfromwhenitiscalledtowhen itreturns§ Callee alwaysreturnsbeforecallerdoes

¢ Stackallocatedin frames§ Statefor asingleprocedure instantiation

FramePointer:%rbp(Optional)

StackFrames¢ Contents

§ Returnaddress§ IfNeeded:

§ Localvariables§ Temporaryspace

¢ Management§ Spaceallocatedwhen procedureisentered

§ “Set-up”code§ Spacedeallocateduponreturn

§ “Finish”code

StackPointer:%rsp

PreviousFrame

Stack“Top”

Framefor

currentproc

CallChainExample

yoo(…){

••who();••

who(…){

• amI();• amI();•

amI(…){

•if(…){amI()

ExampleCallChain

ProcedureamI isrecursive(callsitself)

Example:calltoyoo

yoo(…){

••who();••

yoo(…){

••who();••

Example:calltowho

who(…){

• amI();• amI();•

yoo(…){

••who();••

who(…){

• • •amI();• • •amI();• • •

Example:calltoamI

amI(…){

•if(){amI()

Example:recursivecalltoamI

yoo(…){

••who();••

who(…){

• • •amI();• • •amI();• • •

amI(…){

••amI();••

amI(…){

•if(){amI()

Example:(another)recursivecalltoamI

yoo(…){

••who();••

who(…){

• • •amI();• • •amI();• • •

amI(…){

•if(){amI()

amI(…){

•if(){amI()

amI(…){

•if(){amI()

Returnfrom:(another)recursivecalltoamI

yoo(…){

••who();••

who(…){

• • •amI();• • •amI();• • •

amI(…){

•if(){amI()

amI(…){

•if(){amI()

Returnfrom:recursivecalltoamI

yoo(…){

••who();••

who(…){

• • •amI();• • •amI();• • •

amI(…){

•if(){amI()

Returnfrom:calltoamI

yoo(…){

••who();••

who(…){

• amI();• amI();•

Example:(second)calltoamI

yoo(…){

••who();••

who(…){

• amI();• amI();•

amI(…){

•if(){amI()

Returnfrom:(second)calltoamI

yoo(…){

••who();••

who(…){

• amI();• amI();•

Returnfrom:calltowho

yooyoo(…){

••who();••

x86-64/LinuxStackFrame

¢ Caller’s StackFrame§ Extraarguments(if>6args)forthiscall§ Returnaddress

§ Pushedbycall instruction

¢ Current/Callee StackFrame§ Oldframepointer(optional)§ Savedregistercontext

(whenreusingregisters)§ Localvariables

(Ifcan’tbekeptinregisters)§ “Argumentbuild”area

(Ifcallee needstocallanotherfunction-parametersforfunctionabouttocall,ifneeded)

ReturnAddr

SavedRegisters

+Local

Variables

ArgumentBuild

(Optional)

Old%rbp

Arguments7+

CallerFrame

Framepointer%rbp

Stackpointer%rsp

(Optional)

April22

Example:incrementlong increment(long *p, long val) {

long x = *p;long y = x + val;*p = y;return x;

increment:movq (%rdi), %raxaddq %rax, %rsimovq %rsi, (%rdi)ret

Register Use(s)

%rdi Argumentp

%rsi Argumentval,y

%rax x,Returnvalue

ProcedureCallExample(initialstate)

¢ Returnaddressonstackis:§ addressofinstructionimmediately

followingthecallto“call_incr”(shownhereasmain,butcouldbeanything).

call_incr:subq $16, %rspmovq $351, 8(%rsp)movl $100, %esileaq 8(%rsp), %rdicall incrementaddq 8(%rsp), %raxaddq $16, %rspret

long call_incr() {long v1 = 351;long v2 = increment(&v1, 100);return v1+v2;

InitialStackStructure

•••

Returnaddr <main+8> ⟵%rsp

ProcedureCallExample(step1)

¢ Setupspaceforlocalvariables§ Onlyv1needsspaceonthestack

¢ Compilerallocatedextraspace§ Oftendoesthisforavarietyof reasons,

including alignment.

StackStructure

Allocatespaceforlocalvars

•••

Returnaddr <main+8>

351Unused

⟵old %rsp

⟵%rsp

⟵%rsp+8

StackStructure

Setupparametersforcalltoincrement

Aside: movl isusedbecause100isasmallpositive valuethatfitsin32bits.Highorderbitsofrsi getsettozeroautomatically.Ittakesonelessbytetoencodeamovl thanamovq.

Register Use(s)

%rdi &v1

%rsi 100

•••

Returnaddr <main+8>

351Unused ⟵%rsp

⟵%rsp+8

¢ Statewhileinsideincrement.§ Returnaddressontopofstackisaddress

oftheaddq instruction immediatelyfollowing calltoincrement.

StackStructure

increment:movq (%rdi), %raxaddq %rax, %rsimovq %rsi, (%rdi)ret

Register Use(s)

%rdi &v1

%rsi 100

•••

Returnaddr <main+8>

351Unused

Returnaddr <call_incr+?> ⟵%rsp

¢ Statewhileinsideincrement.§ After codeinbodyhasbeenexecuted.

StackStructure

increment:movq (%rdi), %rax # x = *paddq %rax, %rsi # y = x+100movq %rsi, (%rdi) # *p = yret

Register Use(s)

%rdi &v1

%rsi 451

%rax 351

•••

Returnaddr <main+8>

451Unused

Returnaddr <call_incr+?> ⟵%rsp

¢ Afterreturningfromcalltoincrement.§ Registersandmemoryhavebeenmodified

andreturnaddresshasbeenpoppedoffstack.

StackStructurelong call_incr() {

long v1 = 351;long v2 = increment(&v1, 100);return v1+v2;

Register Use(s)

%rdi &v1

%rsi 451

%rax 351

•••

Returnaddr <main+8>

451Unused ⟵%rsp

⟵%rsp+8

ProcedureCallExample(step6)StackStructure

call_incr:subq $16, %rspmovq $351, 8(%rsp)movl $100, %esileaq 8(%rsp), %rdicall incrementaddq 8(%rsp), %raxaddq $16, %rspret Register Use(s)

%rax 451+351

•••

Returnaddr <main+8>

451Unused ⟵%rsp

⟵%rsp+8

Update%rax tocontainv1+v2

ProcedureCallExample(step7)StackStructure

De-allocatespaceforlocalvars

call_incr:subq $16, %rspmovq $351, 8(%rsp)movl $100, %esileaq 8(%rsp), %rdicall incrementaddq 8(%rsp), %raxaddq $16, %rspret Register Use(s)

%rax 802

•••

Returnaddr <main+8>

451Unused

⟵%rsp

⟵old %rsp

¢ Statejustbeforereturningfromcalltocall_incr.

StackStructurelong call_incr() {

Register Use(s)

%rax 802

•••

Returnaddr <main+8> ⟵%rsp

¢ StateimmediatelyAFTER returningfromcalltocall_incr.§ Returnaddr hasbeenpoppedoff stack§ Controlhasreturned totheinstruction

immediately following thecalltocall_incr (not shownhere).

%rsp...

FinalStackStructurelong call_incr() {

Register Use(s)

%rax 802

RegisterSavingConventions¢ Whenprocedureyoo callswho:§ yoo isthecaller§ who isthecallee

¢ Can registerbeusedfortemporarystorage?

§ No!Contentsofregister%rdx overwrittenbywho!§ Thiscouldbetrouble– somethingshouldbedone. Either:

§ callershouldsave%rdx before thecall(andrestoreitafterthecall)§ callee shouldsave%rdx beforeusing it(and restoreitbefore returning)

yoo:• • •movq $15213, %rdxcall whoaddq %rdx, %rax• • •ret

who:• • •subq $18213, %rdx• • •ret

RegisterSavingConventions¢ Whenprocedureyoo callswho:

§ yoo isthecaller§ who isthecallee

¢ Canaregisterbeusedfortemporarystorage?¢ Conventions

§ “Caller Saved”§ Callersavestemporaryvaluesinitsstackframebeforecalling§ Callerrestoresvaluesafterthecall

§ “CalleeSaved”§ Calleesavestemporaryvaluesinitsstackframebeforeusing§ Calleerestoresthembeforereturningtocaller

x86-64LinuxRegisterUsage,part1

¢ %rax§ Returnvalue§ Alsocaller-saved&restored§ Canbemodifiedbyprocedure

¢ %rdi,...,%r9§ Arguments§ Alsocaller-saved&restored§ Canbemodifiedbyprocedure

¢ %r10,%r11§ Caller-saved&restored§ Canbemodifiedbyprocedure

Returnvalue

Arguments

Caller-savedtemporaries

x86-64LinuxRegisterUsage,part2

¢ %rbx,%r12,%r13,%r14§ Callee-saved§ Calleemustsave&restore

¢ %rbp§ Callee-saved§ Calleemustsave&restore§ Maybeusedasframepointer§ Canmix&match

¢ %rsp§ Specialformofcallee save§ Restoredtooriginalvalueupon

exitfromprocedure

Callee-savedTemporaries

Special%rbp

x86-6464-bitRegisters:UsageConventions

%r15Callee saved Callee saved

Callee saved

Caller saved

Callee saved

Stackpointer

Caller Saved

Returnvalue- Caller saved

Argument#4- Caller saved

Callee-SavedExample(step1)

call_incr2:pushq %rbxsubq $16, %rspmovq %rdi, %rbxmovq $351, 8(%rsp)movl $100, %esileaq 8(%rsp), %rdicall incrementaddq %rbx, %raxaddq $16, %rsppopq %rbxret

long call_incr2(long x) {long v1 = 351;long v2 = increment(&v1, 100);return x+v2;

InitialStackStructure

Rtn address

ResultingStackStructure

Unused %rsp

Rtn address

%rsp+8

Saved%rbx

Callee-SavedExample(step2)

call_incr2:pushq %rbxsubq $16, %rspmovq %rdi, %rbxmovq $351, 8(%rsp)movl $100, %esileaq 8(%rsp), %rdicall incrementaddq %rbx, %raxaddq $16, %rsppopq %rbxret

Pre-returnStackStructure

Rtn address

StackStructure

Unused %rsp

Rtn address

%rsp+8

Saved%rbx

long call_incr2(long x) {long v1 = 351;long v2 = increment(&v1, 100);return x+v2;

WhyCallerand CalleeSaved?¢ Wewantone callingconventiontosimplyseparate

implementationdetailsbetweencallerandcallee

¢ Ingeneral,neithercaller-savenorcallee-saveis“best”:§ Ifcallerisn’tusingaregister,caller-saveisbetter§ Ifcallee doesn’tneedaregister,callee-saveisbetter§ If“doneedtosave”,callee-savegenerallymakessmallerprograms

§ Functionsarecalledfrommultipleplaces

¢ So…“someofeach”andcompilertriesto“pickregisters”thatminimizeamountofsaving/restoring

/* Recursive popcount */long pcount_r(unsigned long x) {

if (x == 0)return 0;

elsereturn (x & 1)

+ pcount_r(x >> 1);}

RecursiveFunction pcount_r:movl $0, %eaxtestq %rdi, %rdije .L6pushq %rbxmovq %rdi, %rbxandl $1, %ebxshrq %rdicall pcount_raddq %rbx, %raxpopq %rbx

.L6:rep; ret

RecursiveFunction:BaseCasepcount_r:

movl $0, %eaxtestq %rdi, %rdije .L6pushq %rbxmovq %rdi, %rbxandl $1, %ebxshrq %rdicall pcount_raddq %rbx, %raxpopq %rbx

.L6:rep; ret

Register Use(s) Type

%rdi x Argument

%rax Returnvalue Returnvalue

elsereturn (x & 1)

Trick becausesomeHWdoesn’tlikejumpingtoret

RecursiveFunction:RegisterSavepcount_r:

.L6:rep; ret

←%rsp

<main+15>

Saved%rbx

elsereturn (x & 1)

%rdi x Argument

RecursiveFunction:CallSetuppcount_r:

.L6:rep; ret

elsereturn (x & 1)

%rdi x >> 1 Recursivearg

%rbx x & 1 Callee-saved ←%rsp

rtn <main+?>

Saved%rbx

rtn <pcount_r+22>

RecursiveFunction:Call pcount_r:movl $0, %eaxtestq %rdi, %rdije .L6pushq %rbxmovq %rdi, %rbxandl $1, %ebxshrq %rdicall pcount_raddq %rbx, %raxpopq %rbx

.L6:rep; ret

elsereturn (x & 1)

%rbx x & 1 Callee-saved

%raxRecursive callreturnvalue – ←%rsp

rtn <main+?>

Saved%rbx

RecursiveFunction:Resultpcount_r:

.L6:rep; ret

elsereturn (x & 1)

%rbx x & 1 Callee-saved

%rax Returnvalue

rtn <main+?>

Saved%rbx ←%rsp

rtn <main+?>

Saved%rbx

RecursiveFunction:Completionpcount_r:

.L6:rep; ret

elsereturn (x & 1)

%rax Returnvalue

...←%rsp

ObservationsAboutRecursion¢ Workswithoutanyspecialconsideration

§ Stackframesmeanthateachfunctioncallhasprivatestorage§ Savedregisters&localvariables§ Savedreturnpointer

§ Registersavingconventionspreventonefunctioncallfromcorruptinganother’sdata§ Unlessthecodeexplicitlydoesso(e.g.,bufferoverflow- describedinfuturelecture)

§ Stackdisciplinefollowscall/returnpattern§ IfPcallsQ,thenQreturnsbeforeP§ Last-In,First-Out

¢ Alsoworksformutualrecursion§ PcallsQ;QcallsP

x86-64StackFrames¢ Often(ideally),x86-64functionsneednostackframeatall

§ Justareturnaddressispushedontothestackwhenafunctioncallismade

¢ Afunctiondoesneedastackframewhenit:§ Hastoomanylocalvariablestoholdinregisters§ Haslocalvariablesthatarearraysorstructs§ Usestheaddress-ofoperator(&)tocomputetheaddressofalocalvariable§ Callsanotherfunctionthattakesmorethansixarguments§ Needstosavethestateofcaller-saveregistersbeforecallingaprocedure§ Needstosavethestateofcallee-saveregistersbeforemodifyingthem

x86-64ProcedureSummary¢ ImportantPoints

§ Proceduresareacombinationofinstructionsandconventions§ Conventionspreventfunctionsfromdisruptingeachother

§ Stackistherightdatastructureforprocedurecall/return§ IfPcallsQ,thenQreturnsbeforeP

¢ Recursionhandledbynormalcallingconventions§ Callercanstorevaluesinlocalstackframeandin

callee-savedregisters§ Putfunctionargumentsattopofstack§ Resultreturnin%rax

ReturnAddr

SavedRegisters

+Local

Variables

ArgumentBuild

Old%rbp

Arguments7+

CallerFrame

%rbp(Optional)

Onemorex86-64example¢ Exampleofpassingmorethan6parametersandpassing

addressesoflocalvariables¢ Thefollowingexample,alongwithabriefre-capofx86-64calling

conventionsisinthisvideo:

5.ProceduresandStacks§ …§ 6.x86-64CallingConventions

https://courses.cs.washington.edu/courses/cse351/videos/05/056.mp4

x86-64Example(1)

long int call_proc() {

long x1 = 1;int x2 = 2;short x3 = 3;char x4 = 4;proc(x1, &x1, x2, &x2,

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:subq $32,%rspmovq $1,16(%rsp) # x1movl $2,24(%rsp) # x2movw $3,28(%rsp) # x3movb $4,31(%rsp) # x4• • •

Returnaddresstocallerofcall_proc

Note: Detailsmayvarydependingoncompiler.

←%rsp

x86-64Example(2)– Allocatelocalvars

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:subq $32,%rspmovq $1,16(%rsp) # x1movl $2,24(%rsp) # x2movw $3,28(%rsp) # x3movb $4,31(%rsp) # x4• • •

←%rsp

x3x4 x2

x86-64Example(3)– setupparams toproc

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:• • •leaq 24(%rsp),%rcx # %rcx=&x2leaq 16(%rsp),%rsi # %rsi=&x1leaq 31(%rsp),%rax # %rax=&x4movq %rax,8(%rsp) # arg8=&4movl $4,(%rsp) # arg7=4leaq 28(%rsp),%r9 # %r9=&x3movl $3,%r8d # %r8 = 3movl $2,%edx # %rdx = 2movq $1,%rdi # %rdi = 1call proc• • •

x3x4 x2

Argumentspassedin(inorder):rdi,rsi,rdx,rcx,r8,r9

Sameinstructionsasinvideo,justadifferentorder.←%rsp

x86-64Example(4)– setupparams toproc

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:• • •leaq 24(%rsp),%rcxleaq 16(%rsp),%rsileaq 31(%rsp),%raxmovq %rax,8(%rsp)movl $4,(%rsp)leaq 28(%rsp),%r9movl $3,%r8dmovl $2,%edxmovq $1,%rdicall proc• • •

x3x4 x2

Returnaddresstocallerofcall_procArgumentspassedin(inorder):rdi,rsi,rdx,rcx,r8,r9

Notesizes

←%rsp

x86-64Example(5)– callproc

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:• • •leaq 24(%rsp),%rcxleaq 16(%rsp),%rsileaq 31(%rsp),%raxmovq %rax,8(%rsp)movl $4,(%rsp)leaq 28(%rsp),%r9movl $3,%r8dmovl $2,%edxmovq $1,%rdicall proc• • •

x3x4 x2

Returnaddresstolineaftercalltoproc ←%rsp

x86-64Example(6) – aftercalltoproc

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

x3x4 x2

Returnaddresstocallerofcall_proc movs__:moveandsignextend

cltq:signextend%eax into%rax(special-casetosavespace)

call_proc:• • •movswl 28(%rsp),%eax # %eax=x3movsbl 31(%rsp),%edx # %edx=x4subl %edx,%eax # %eax=x3-x4cltqmovslq 24(%rsp),%rdx # %rdx=x2addq 16(%rsp),%rdx #%rdx=x1+x2imulq %rdx,%rax # %rax=rax*rdxaddq $32,%rspret

←%rsp

x86-64Example(7)– de-allocatelocalvars

x3, &x3, x4, &x4);return (x1+x2)*(x3-x4);

call_proc:• • •movswl 28(%rsp),%eaxmovsbl 31(%rsp),%edxsubl %edx,%eaxcltqmovslq 24(%rsp),%rdxaddq 16(%rsp),%rdximulq %rdx,%raxaddq $32,%rspret

Returnaddresstocallerofcall_proc ←%rsp

Procedures & The Stack Spring 2016 Procedures & The StackProcedures & The Stack Spring...

Documents

Spring 20011 13. Remote Procedure Call (5.3) Outline Protocol Stack Presentation Formatting

Full Stack Reactive NoSQL: Spring Data and Couchbase

Spring + JPA + Hibernateumeshk29.yolasite.com/resources/4 - Spring-JPA-Hibernate.pdf · J2EE 1.4 Reality Check Common Technology Stack – Spring (IoC) – Hibernate (Light-Weight

Lecture 8: Control, Procedures, and the Stack CS 2011 Fall 2014, Dr. Rozier

The Stack & Procedures€¦ · L12: The Stack & Procedures CSE410, Winter 2017 Administrivia Homework 3 released today, due next Thu (2/9) Lab 2 deadline pushed to Monday (2/13) Definitely

Full Stack Reactive Java Kotlin! · 2018-11-15 · Full Stack Reactive Java With Spring Framework 5, Spring Boot 2, & Project Reactor Mark Heckler Principal Technologist, Spring Developer

Procedures & The Stack I - courses.cs.washington.edu fileL01: Intro, Combinational LogicL11: Procedures & The Stack IL01: Introduction CSE369, Autumn 2016CSE351, Autumn 2016 Mechanisms

University of Washington Today More on procedures, stack etc. Lab 2 due today! We hope it was fun! What is a stack? And how about a stack frame? 1

The Stack and Introduction to Procedures Dr. Konstantinos Tatas and Dr. Haris Haralambous

Full Stack Reactive JavaFull Stack Reactive Java With Spring Framework 5, Spring Boot 2, & Project Reactor Mark Heckler Principal Technologist, Spring Developer Advocate @mkheck @projectreactor

Spring - expertojava.ua.esexpertojava.ua.es/j2ee/publico/spring-2012-13/wholesite.pdf · Spring es un framework alternativo al stack de tecnologías estándar en aplicaciones JavaEE

Machine-Level Programming III: Procedures Feb. 8, 2000 Topics IA32 stack Stack-based languages Stack frames Register saving conventions Creating pointers

Building Next-Gen Web Applications with the Spring 3.0 Web Stack - Oracle · Building Next-Gen Web Applications with the Spring 3.0 Web Stack Keith Donald and Jeremy Grelle SpringSource

Assembly Language Procedures and the Stack. Stack A stack is a last-in–first-out (LIFO) data structure. Insert and delete operations are referred to as

Building Next-Gen Web Applications with the Spring 3.0 Web Stack

Procedures & The Stack II · 2016-10-25 · L01: Intro, Combinational LogicL12: Procedures & The Stack II CSE369, Autumn 2016CSE351, Autumn 2016 Administrivia Lab 2 due Friday Midterm

Club & Organization Policies & Procedures Spring 2005

Enterprise Architectures - cvut.czJPA (EclipseLink)(2 Java EE stack) Websockets(2 Java EE stack) Servlets(2 Java EE stack) Spring(provides similar functionality as Enterprise Java

Procedures and the Stack

1.p4600 spring 2011 course procedures