cs 110 computer architectureopcode= 4 (look up on green sheet) rs= 9 (first operand) rt= 0 (second...
TRANSCRIPT
CS110ComputerArchitecture
RunningaProgram- CALL(Compiling,Assembling,Linking,andLoading)
Instructor:SörenSchwertfeger
http://shtech.org/courses/ca/
School of Information Science and Technology SIST
ShanghaiTech University
1Slides based on UC Berkley's CS61C
BranchCalculation
• Ifwedon’t takethebranch:– PC = PC + 4 = nextinstruction
• Ifwedo takethebranch:– PC = (PC+4) + (immediate*4)
• Observations:– immediate isnumberofinstructionstojump(remember,specifieswords)eitherforward(+)orbackwards(–)
– BranchfromPC+4 forhardwarereasons;willbeclearwhylaterinthecourse
2
BranchExample(1/2)
• MIPSCode:Loop: beq $9,$0,End
addu $8,$8,$10addiu $9,$9,-1j Loop
End:
• I-Formatfields:opcode =4 (lookuponGreenSheet)rs =9 (firstoperand)rt =0 (secondoperand)immediate =???
3
Start counting from instruction AFTER the branch
123
3
BranchExample(2/2)
• MIPSCode:Loop: beq $9,$0,End
addu $8,$8,$10addiu $9,$9,-1j Loop
End:
Fieldrepresentation(decimal):
Fieldrepresentation(binary):
4
4 9 0 331 0
000100 01001 00000 000000000000001131 0
J-FormatInstructions(1/4)
• Forbranches,weassumedthatwewon’twanttobranchtoofar,sowecanspecifyachangeinthePC
• Forgeneraljumps(j andjal),wemayjumptoanywhere inmemory– Ideally,wewouldspecifya32-bitmemoryaddresstojumpto
– Unfortunately,wecan’tfitbotha6-bitopcodeanda32-bitaddressintoasingle32-bitword
5
J-FormatInstructions(2/4)
• Definetwo“fields”ofthesebitwidths:
• Asusual,eachfieldhasaname:
• KeyConcepts:– Keepopcode fieldidenticaltoR-FormatandI-Formatforconsistency
– Collapseallotherfieldstomakeroomforlargetargetaddress 6
6 2631 0
opcode target address31 0
J-FormatInstructions(3/4)
• Wecanspecify226 addresses– Stillgoingtoword-alignedinstructions,soadd00 aslasttwobits(multiplyby4)
– Thisbringsusto28bitsofa32-bitaddress
• Takethe4highestorderbitsfromthePC– Cannotreacheverywhere,butadequatealmostallofthetime,sinceprogramsaren’tthatlong
– Onlyproblematicifcodestraddlesa256MBboundary• Ifnecessary,use2jumpsorjr (R-Format)instead
7
J-FormatInstructions(4/4)
• Jumpinstruction:– NewPC={ (PC+4)[31..28],targetaddress,00}
• Notes:– {,,}meansconcatenation{4bits,26bits,2bits}=32bitaddress• Bookuses||instead
– Arrayindexing:[31..28]meanshighest4bits– Forhardwarereasons,usePC+4insteadofPC
8
AssemblerPseudo-Instructions• CertainCstatementsareimplementedunintuitivelyinMIPS– e.g.assignment(a=b)viaadd$zero
• MIPShasasetof“pseudo-instructions”tomakeprogrammingeasier– Moreintuitivetoread,butgettranslatedintoactualinstructionslater
• Example:move dst,src
translatedintoaddi dst,src,0
9
AssemblerPseudo-Instructions
• Listofpseudo-instructions:http://en.wikipedia.org/wiki/MIPS_architecture#Pseudo_instructions
– Listalsoincludesinstructiontranslation• LoadAddress(la)– la dst,label– Loadsaddressofspecifiedlabelintodst
• LoadImmediate (li)– li dst,imm– Loads32-bitimmediateintodst
• MARShasadditionalpseudo-instructions– SeeHelp(F1)forfulllist
10
AssemblerRegister
• Problem:–Whenbreakingupapseudo-instruction,theassemblermayneedtouseanextraregister
– Ifitusesaregularregister,it’lloverwritewhatevertheprogramhasputintoit
• Solution:– Reservearegister($1 or$at for“assemblertemporary”)thatassemblerwillusetobreakuppseudo-instructions
– Sincetheassemblermayusethisatanytime,it’snotsafetocodewithit
11
MultiplyandDivide• Examplepseudo-instruction:
mul $rd,$rs,$rt– Consistsofmult whichstorestheoutputinspecialhiandloregisters,andamovefromtheseregistersto$rd
mult $rs,$rtmflo $rd
• mult anddiv havenothingimportantintherd fieldsincethedestinationregistersarehi andlo
• mfhi andmflo havenothingimportantinthers andrt fieldssincethesourceisdeterminedbytheinstruction(seeCOD)
12
IntegerMultiplication(1/3)
• Paperandpencilexample(unsigned):Multiplicand 1000 8Multiplier x 1001 9
1000+0000+0000+100001001000 72
• m bitsx n bits=m +n bitproduct
IntegerMultiplication(2/3)
• InMIPS,wemultiplyregisters,so:– 32-bitvaluex 32-bitvalue=64-bitvalue
• SyntaxofMultiplication(signed):– mult register1,register2–Multiplies32-bitvaluesinthoseregisters&puts64-bitproductinspecialresultregs:• putsproductupperhalfinhi,lowerhalfin lo
– hi andlo are2registersseparatefromthe32generalpurposeregisters
– Usemfhi register&mflo register tomovefromhi,lo toanotherregister
IntegerMultiplication(3/3)• Example:– inC: a = b * c;– inMIPS:
• letb be$s2;letc be$s3;andleta be$s0 and$s1 (sinceitmaybeupto64bits)
mult $s2,$s3 # b*cmfhi $s0 # upper half of
# product into $s0mflo $s1 # lower half of
# product into $s1•Note:Often,weonlycareaboutthelowerhalfoftheproduct.•Pseudo-inst.mul expandstomult/mflo.
IntegerDivision(1/2)
• Paperandpencilexample(unsigned):– 74/8=9Rest2
1001 Quotient Divisor 1000|1001010 Dividend
-1000101011010-1000
10 Remainder(or Modulo result)
• Dividend=Quotientx Divisor+Remainder
• SyntaxofDivision(signed):– div register1,register2
– Divides32-bitregister1by32-bitregister2:
– putsremainderofdivisioninhi,quotientinlo
• ImplementsCdivision(/)andmodulo(%)
• ExampleinC: a = c / d; b = c % d;
• inMIPS:a«$s0;b«$s1;c«$s2;d«$s3
div $s2,$s3 # lo=c/d, hi=c%dmflo $s0 # get quotientmfhi $s1 # get remainder
IntegerDivision(2/2)
MALvs.TAL
• TrueAssemblyLanguage(TAL)– Theinstructionsacomputerunderstandsandexecutes
• MIPSAssemblyLanguage(MAL)– Instructionstheassemblyprogrammercanuse(includespseudo-instructions)
– EachMALinstructionbecomes1ormoreTALinstruction
18
Summary• I-Format: instructionswithimmediates,lw/sw (offsetisimmediate),andbeq/bne– Butnottheshiftinstructions– BranchesusePC-relativeaddressing
• J-Format: j andjal (butnotjr)– Jumpsuseabsoluteaddressing
• R-Format: allotherinstructions
19
opcode rs rt immediateI:
opcode target addressJ:
opcode functrs rt rd shamtR:
LevelsofRepresentation/Interpretation
lw $t0,0($2)lw $t1,4($2)sw $t1,0($2)sw $t0,4($2)
High Level LanguageProgram (e.g., C)
Assembly Language Program (e.g., MIPS)
Machine Language Program (MIPS)
Hardware Architecture Description(e.g., block diagrams)
Compiler
Assembler
Machine Interpretation
temp = v[k];v[k] = v[k+1];v[k+1] = temp;
0000 1001 1100 0110 1010 1111 0101 10001010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111
Architecture Implementation
Anything can be representedas a number,
i.e., data or instructions
20
Logic Circuit Description(Circuit Schematic Diagrams)
+ How to take a program and run it
LanguageExecutionContinuum• AnInterpreterisaprogramthatexecutesotherprograms.
• Languagetranslationgivesusanotheroption• Ingeneral,weinterpretahigh-levellanguagewhenefficiencyisnotcriticalandtranslatetoalower-levellanguagetoincreaseperformance
Easy to programInefficient to interpret
Difficult to programEfficient to interpret
Scheme Java C++ C Assembly Machine codeJava bytecode
21
InterpretationvsTranslation
• Howdowerunaprogramwritteninasourcelanguage?– Interpreter:Directlyexecutesaprograminthesourcelanguage
– Translator:Convertsaprogramfromthesourcelanguagetoanequivalentprograminanotherlanguage
• Forexample,consideraPythonprogramfoo.py
22
Interpretation
• Pythoninterpreterisjustaprogramthatreadsapythonprogramandperformsthefunctionsofthatpythonprogram.
23
Interpretation• Anygoodreasontointerpretmachinelanguageinsoftware?
• MARS– usefulforlearning/debugging• AppleMacintoshconversion– SwitchedfromMotorola680x0instructionarchitecturetoPowerPC.• Similarissuewithswitchtox86
– Couldrequireallprogramstobere-translatedfromhighlevellanguage
– Instead,letexecutablescontainoldand/ornewmachinecode,interpretoldcodeinsoftwareifnecessary(emulation)
24
Interpretationvs.Translation?(1/2)
• Generallyeasiertowriteinterpreter• Interpreterclosertohigh-level,socangivebettererrormessages(e.g.,MARS)– Translatorreaction:addextrainformationtohelpdebugging(linenumbers,names)
• Interpreterslower(10x?),codesmaller(2x?)• Interpreterprovidesinstructionsetindependence:runonanymachine
25
Interpretationvs.Translation?(2/2)
• Translated/compiledcodealmostalwaysmoreefficientandthereforehigherperformance:– Importantformanyapplications,particularlyoperatingsystems.
• Translation/compilationhelps“hide”theprogram“source”fromtheusers:– Onemodelforcreatingvalueinthemarketplace(eg.Microsoftkeepsalltheirsourcecodesecret)
– Alternativemodel,“opensource”,createsvaluebypublishingthesourcecodeandfosteringacommunityofdevelopers.
26
StepsincompilingaCprogram
27
Compiler• Input:High-LevelLanguageCode(e.g.,foo.c)
• Output:AssemblyLanguageCode(e.g.,foo.s forMIPS)
• Note:Outputmay containpseudo-instructions• Pseudo-instructions:instructionsthatassemblerunderstandsbutnotinmachineForexample:– move $s1,$s2Þ add $s1,$s2,$zero
28
WhereAreWeNow?
Compiler Class
29
Inthenews:XilinxACAP
• AdaptiveComputeAccelerationPlatform– AdvancedformofFPGA– MachineLearning,Genomic,Video-coding,Data-analysis,Fintec
– 50billiontransistors– 7nm(firstchipin7nm!)– 10-100xspeedvs.CPUs– FasterthanGPU– Muchmoreenergyefficient
– Fordatacenters/supercomputing 30
31
Assembler• Input:AssemblyLanguageCode(MAL)(e.g.,foo.s forMIPS)
• Output:ObjectCode,informationtables(TAL)(e.g.,foo.o forMIPS)
• ReadsandUsesDirectives• ReplacePseudo-instructions• ProduceMachineLanguage• CreatesObjectFile
32
AssemblerDirectives(p.A-13..A-17)• Givedirectionstoassembler,butdonotproducemachineinstructions.text: Subsequentitemsputinusertextsegment(machinecode).data: Subsequentitemsputinuserdatasegment(binaryrepofdatainsourcefile).globl sym: declaressym globalandcanbereferencedfromotherfiles.asciiz str: Storethestringstr inmemoryandnull-terminateit.word w1…wn: Storethen 32-bitquantitiesinsuccessivememorywords
33
Pseudo-instructionReplacement• AssemblertreatsconvenientvariationsofmachinelanguageinstructionsasifrealinstructionsPseudo: Real:subu $sp,$sp,32 addiu $sp,$sp,-32sd $a0, 32($sp) sw $a0, 32($sp)
sw $a1, 36($sp)mul $t7,$t6,$t5 mult $t6,$t5
mflo $t7addu $t0,$t6,1 addiu $t0,$t6,1ble $t0,100,loop slti $at,$t0,101
bne $at,$0,loopla $a0, str lui $at,left(str)
ori $a0,$at,right(str)
34
QuestionWhichofthefollowingisacorrectTALinstructionsequenceforla$v0,FOO?*%hi(label),tellsassemblertofillupper16bitsoflabel’saddr%lo(label),tellsassemblertofilllower16bitsoflabel’saddr
A:ori $v0,%hi(FOO)addiu $v0,%lo(FOO)
B:ori $v0,%lo(FOO)lui $v0,%hi(FOO)
C:lui $v0,%lo(FOO)ori $v0,%hi(FOO)
D:lui $v0,%hi(FOO)ori $v0,%lo(FOO)
E:la$v0,FOOisalreadyaTALinstruction
*AssumetheaddressofFOOis0xABCD0124 35
ProducingMachineLanguage(1/3)
• SimpleCase– Arithmetic,Logical,Shifts,andsoon– Allnecessaryinfoiswithintheinstructionalready
• WhataboutBranches?– PC-Relative– Sooncepseudo-instructionsarereplacedbyrealones,weknowbyhowmanyinstructionstobranch
• Sothesecanbehandled
36
ProducingMachineLanguage(2/3)
• “ForwardReference”problem– Branchinstructionscanrefertolabelsthatare“forward”intheprogram:
– Solvedbytaking2passesovertheprogram• Firstpassrememberspositionoflabels• Secondpassuseslabelpositionstogeneratecode
or $v0, $0, $0L1: slt $t0, $0, $a1
beq $t0, $0, L2addi $a1, $a1, -1j L1
L2: add $t1, $a0, $a1
37
ProducingMachineLanguage(3/3)• Whataboutjumps(j andjal)?– Jumpsrequireabsoluteaddress– So,forwardornot,stillcan’tgeneratemachineinstructionwithoutknowingthepositionofinstructionsinmemory
• Whataboutreferencestostaticdata?– la getsbrokenupintolui andori– Thesewillrequirethefull32-bitaddressofthedata
• Thesecan’tbedeterminedyet,sowecreatetwotables…
38
SymbolTable
• Listof“items”inthisfilethatmaybeusedbyotherfiles
• Whatarethey?– Labels:functioncalling– Data:anythinginthe.data section;variableswhichmaybeaccessedacrossfiles
39
RelocationTable• Listof“items”thisfileneedstheaddressoflater
• Whatarethey?– Anylabeljumpedto:j orjal• internal• external(includinglibfiles)
– Anypieceofdatainstaticsection• suchasthela instruction
40
ObjectFileFormat• objectfileheader:sizeandpositionoftheotherpiecesoftheobjectfile
• textsegment:themachinecode• datasegment:binaryrepresentationofthestaticdatainthesourcefile
• relocationinformation:identifieslinesofcodethatneedtobefixeduplater
• symboltable:listofthisfile’slabelsandstaticdatathatcanbereferenced
• debugginginformation• AstandardformatisELF(exceptMS)
http://www.skyfree.org/linux/references/ELF_Format.pdf 41
Admin
• Project1.1willbepublishedtoday(thistimeforreal;))
42
WhereAreWeNow?
43
Linker(1/3)• Input:Objectcodefiles,informationtables(e.g.,foo.o,libc.o forMIPS)
• Output:Executablecode(e.g.,a.out forMIPS)
• Combinesseveralobject(.o)filesintoasingleexecutable(“linking”)
• Enableseparatecompilationoffiles– Changestoonefiledonotrequirerecompilationofthewholeprogram• WindowsNTsource was>40Mlinesofcode!
– Oldname“LinkEditor”fromeditingthe“links”injumpandlinkinstructions
44
.o file 1text 1data 1info 1
.o file 2text 2data 2info 2
Linker
a.outRelocated text 1Relocated text 2Relocated data 1Relocated data 2
Linker(2/3)
45
Linker(3/3)
• Step1:Taketextsegmentfromeach.o fileandputthemtogether
• Step2:Takedatasegmentfromeach.o file,putthemtogether,andconcatenatethisontoendoftextsegments
• Step3:Resolvereferences– GothroughRelocationTable;handleeachentry– Thatis,fillinallabsoluteaddresses
46
FourTypesofAddresses
• PC-RelativeAddressing(beq,bne)– neverrelocate
• AbsoluteFunctionAddress(j,jal)– alwaysrelocate
• ExternalFunctionReference(usuallyjal)– alwaysrelocate
• StaticDataReference(oftenlui andori)– alwaysrelocate
47
AbsoluteAddressesinMIPS
• Whichinstructionsneedrelocationediting?– J-format:jump,jumpandlink
– Loadsandstorestovariablesinstaticarea,relativetoglobalpointer
– Whataboutconditionalbranches?
– PC-relativeaddressingpreservedevenifcodemoves
j/jal xxxxx
lw/sw $gp $x address
beq/bne $rs $rt address
48
ResolvingReferences(1/2)
• Linkerassumesfirstwordoffirsttextsegmentisataddress0x04000000.– (Morelaterwhenwestudy“virtualmemory”)
• Linkerknows:– lengthofeachtextanddatasegment– orderingoftextanddatasegments
• Linkercalculates:– absoluteaddressofeachlabeltobejumpedto(internalorexternal)andeachpieceofdatabeingreferenced
49
ResolvingReferences(2/2)
• Toresolvereferences:– searchforreference(dataorlabel)inall“user”symboltables
– ifnotfound,searchlibraryfiles(forexample,forprintf)
– onceabsoluteaddressisdetermined,fillinthemachinecodeappropriately
• Outputoflinker:executablefilecontainingtextanddata(plusheader)
50
WhereAreWeNow?
51
LoaderBasics
• Input:ExecutableCode(e.g.,a.out forMIPS)
• Output:(programisrun)• Executablefilesarestoredondisk• Whenoneisrun,loader’sjobistoloaditintomemoryandstartitrunning
• Inreality,loaderistheoperatingsystem(OS)– loadingisoneoftheOStasks
52
Loader…whatdoesitdo?• Readsexecutablefile’sheadertodeterminesizeoftextand
datasegments• Createsnewaddressspaceforprogramlargeenoughtohold
textanddatasegments,alongwithastacksegment• Copiesinstructionsanddatafromexecutablefileintothenew
addressspace• Copiesargumentspassedtotheprogramontothestack• Initializesmachineregisters
– Mostregisterscleared,butstackpointerassignedaddressof1stfreestacklocation
• Jumpstostart-uproutinethatcopiesprogram’sargumentsfromstacktoregisters&setsthePC– Ifmainroutinereturns,start-uproutineterminatesprogramwiththe
exitsystemcall 53
QuestionAtwhatpointinprocessareallthemachinecodebitsgeneratedforthefollowingassemblyinstructions:1)addu $6, $7, $82)jal fprintf
A:1)&2)AftercompilationB:1)Aftercompilation,2)AfterassemblyC:1)Afterassembly,2)AfterlinkingD:1)Afterassembly,2)AfterloadingE:1)Aftercompilation,2)Afterlinking
54
Example:CÞ AsmÞ ObjÞ ExeÞ Run
#include <stdio.h>int main (int argc, char *argv[]) {int i, sum = 0;for (i = 0; i <= 100; i++)
sum = sum + i * i;printf ("The sum of sq from 0 .. 100 is %d\n", sum);
}
C Program Source Code: prog.c
“printf” lives in “libc”
55
Compilation:MAL.text.align 2.globl main
main:subu $sp,$sp,32sw $ra, 20($sp)sd $a0, 32($sp)sw $0, 24($sp)sw $0, 28($sp)
loop:lw $t6, 28($sp)mul $t7, $t6,$t6lw $t8, 24($sp)addu $t9,$t8,$t7sw $t9, 24($sp)
addu $t0, $t6, 1sw $t0, 28($sp)ble $t0,100, loopla $a0, strlw $a1, 24($sp)jal printfmove $v0, $0lw $ra, 20($sp)addiu $sp,$sp,32jr $ra.data.align 0
str:.asciiz "The sum of sq from 0 .. 100 is %d\n"
Where are7 pseudo-instructions?
56
Compilation:MAL.text.align 2.globl main
main:subu $sp,$sp,32sw $ra, 20($sp)sd $a0, 32($sp)sw $0, 24($sp)sw $0, 28($sp)
loop:lw $t6, 28($sp)mul $t7, $t6,$t6lw $t8, 24($sp)addu $t9,$t8,$t7sw $t9, 24($sp)
addu $t0, $t6, 1sw $t0, 28($sp)ble $t0,100, loopla $a0, strlw $a1, 24($sp)jal printfmove $v0, $0lw $ra, 20($sp)addiu $sp,$sp,32jr $ra.data.align 0
str:.asciiz "The sum of sq from 0 .. 100 is %d\n"
7 pseudo-instructionsunderlined
57
Assemblystep1:
00 addiu $29, $29,-3204 sw $31, 20($29)08 sw $4, 32($29)0c sw $5, 36($29)10 sw $0, 24($29)14 sw $0, 28($29)18 lw $14, 28($29)1c multu $14, $1420 mflo $1524 lw $24, 24($29)28 addu $25, $24,$152c sw $25, 24($29)
30 addiu $8, $14, 134 sw $8, 28($29)38 slti $1, $8, 101 3c bne $1, $0, loop40 lui $4, l.str44 ori $4, $4,r.str 48 lw $5, 24($29)4c jal printf50 add $2, $0, $054 lw $31, 20($29) 58 addiu $29, $29,325c jr $31
Remove pseudoinstructions, assign addresses
58
Assemblystep2
• SymbolTableLabel address(inmodule) typemain: 0x00000000 global textloop: 0x00000018 local textstr: 0x00000000 local data
• RelocationInformationAddress Instr.type Dependency0x00000040 lui l.str0x00000044 ori r.str0x0000004c jal printf
Create relocation table and symbol table
59
Assemblystep3
00 addiu $29,$29,-3204 sw $31,20($29)08 sw $4, 32($29)0c sw $5, 36($29)10 sw $0, 24($29)14 sw $0, 28($29)18 lw $14, 28($29)1c multu $14, $1420 mflo $1524 lw $24, 24($29)28 addu $25,$24,$152c sw $25, 24($29)
30 addiu $8,$14, 134 sw $8,28($29)38 slti $1,$8, 101 3c bne $1,$0, -1040 lui $4, l.str44 ori $4,$4,r.str48 lw $5,24($29)4c jal printf50 add $2, $0, $054 lw $31,20($29) 58 addiu $29,$29,325c jr $31
Resolve local PC-relative labels
60
Assemblystep4
• Generateobject(.o)file:– Outputbinaryrepresentationfor• textsegment(instructions)• datasegment(data)• symbolandrelocationtables
– Usingdummy“placeholders”forunresolvedabsoluteandexternalreferences
61
Textsegmentinobjectfile0x000000 001001111011110111111111111000000x000004 101011111011111100000000000101000x000008 101011111010010000000000001000000x00000c 101011111010010100000000001001000x000010 101011111010000000000000000110000x000014 101011111010000000000000000111000x000018 100011111010111000000000000111000x00001c 100011111011100000000000000110000x000020 000000011100111000000000000110010x000024 001001011100100000000000000000010x000028 001010010000000100000000011001010x00002c 101011111010100000000000000111000x000030 000000000000000001111000000100100x000034 000000110000111111001000001000010x000038 000101000010000011111111111101110x00003c 101011111011100100000000000110000x000040 001111000000010000000000000000000x000044 100011111010010100000000000000000x000048 000011000001000000000000111011000x00004c 001001000000000000000000000000000x000050 100011111011111100000000000101000x000054 001001111011110100000000001000000x000058 000000111110000000000000000010000x00005c 00000000000000000001000000100001
62
Linkstep1:combineprog.o,libc.o
• Mergetext/datasegments• Createabsolutememoryaddresses• Modify&mergesymbolandrelocationtables• SymbolTable– Label Addressmain: 0x00000000loop: 0x00000018str: 0x10000430printf: 0x000003b0 …
• RelocationInformation– Address Instr.Type Dependency0x00000040 lui l.str0x00000044 ori r.str0x0000004c jal printf …
63
Linkstep2:
00 addiu $29,$29,-3204 sw$31,20($29)08 sw$4, 32($29)0c sw$5, 36($29)10 sw $0, 24($29)14 sw $0, 28($29)18 lw $14, 28($29)1c multu $14, $1420 mflo $1524 lw $24, 24($29)28 addu $25,$24,$152c sw $25, 24($29)
30 addiu $8,$14, 134 sw$8,28($29)38 slti $1,$8, 101 3c bne $1,$0, -1040 lui $4, 409644 ori $4,$4,107248 lw$5,24($29)4c jal 94450 add $2, $0, $054 lw $31,20($29) 58 addiu $29,$29,325c jr$31
• Edit Addresses in relocation table • (shown in TAL for clarity, but done in binary )
64
Linkstep3:
• Outputexecutableofmergedmodules– Singletext(instruction)segment– Singledatasegment– Headerdetailingsizeofeachsegment
• NOTE:– TheprecedingexamplewasamuchsimplifiedversionofhowELFandotherstandardformatswork,meantonlytodemonstratethebasicprinciples.
65