COP4020 Programming Languages. Names, Scopes, and Bindings Prof. Robert van Engelen

Transcription

1 COP4020 Programmig Laguages Names, Scopes, ad Bidigs Prof. Robert va Egele

2 Overview Abstractios ad ames Bidig time Object lifetime Object storage maagemet Static allocatio Stack allocatio Heap allocatio Scope rules Static versus dyamic scopig Referece eviromets Overloadig ad polymorphism COP4020 Fall

3 Name = Abstractio Names eable programmers to refer to variables, costats, operatios, ad types Names are cotrol abstractios ad data abstractios for program fragmets ad data structures Cotrol abstractio: Subrouties (procedures ad fuctios) allow programmers to focus o maageable subset of program text, subroutie iterface hides implemetatio details Cotrol flow costructs (if-the, while, for, retur) hide low-level machie ops Data abstractio: Object-orieted classes hide data represetatio details behid a set of operatios Abstractio i the cotext of high-level programmig laguages refers to the degree or level of workig with code ad data Ehaces the level of machie-idepedece "Power" of costructs COP4020 Fall

4 Bidig Time A bidig is a associatio betwee a ame ad a etity Bidig time is the time at which a implemetatio decisio is made to create a ame «etity bidig: Laguage desig time: the desig of specific program costructs (sytax), primitive types, ad meaig (sematics) Laguage implemetatio time: fixatio of implemetatio costats such as umeric precisio, ru-time memory sizes, max idetifier ame legth, umber ad types of built-i exceptios, etc. Program writig time: the programmer's choice of algorithms ad data structures Compile time: the time of traslatio of high-level costructs to machie code ad choice of memory layout for data objects Lik time: the time at which multiple object codes (machie code files) ad libraries are combied ito oe executable Load time: whe the operatig system loads the executable i memory Ru time: whe a program executes COP4020 Fall

5 Bidig Time Examples Laguage desig: Sytax (ames «grammar) if (a>0) b=a; (C sytax style) if a>0 the b:=a ed if (Ada sytax style) Keywords (ames «builtis) class (C++ ad Java), edif or ed if (Fortra, space isigificat) Reserved words (ames «special costructs) mai (C), writel (Pascal) Meaig of operators (operator «operatio) + (add), % (mod), ** (power) Built-i primitive types (type ame «type) float, short, it, log, strig Laguage implemetatio Iteral represetatio of types ad literals (type «byte ecodig) 3.1 (IEEE 754) ad "foo bar (\0 termiated or embedded strig legth) Storage allocatio method for variables (static/stack/heap) COP4020 Fall

6 Bidig Time Examples (cot d) Compile time The specific type of a variable i a declaratio (ame«type) Storage allocatio method for a global or local variable (ame«allocatio mechaism) Liker Likig calls to static library routies (fuctio«address) pritf (i libc) Mergig ad likig multiple object codes ito oe executable Loader Loadig executable i memory ad adjustig absolute addresses Mostly i older systems that do ot have virtual memory Ru time Dyamic likig of libraries (library fuctio«library code) DLL, dylib Nostatic allocatio of space for variable (variable«address) Stack ad heap COP4020 Fall

7 The Effect of Bidig Time Early bidig times (before ru time) are associated with greater efficiecy ad clarity of program code Compilers make implemetatio decisios at compile time (avoidig to geerate code that makes the decisio at ru time) Sytax ad static sematics checkig is performed oly oce at compile time ad does ot impose ay ru-time overheads Late bidig times (at ru time) are associated with greater flexibility (but may leave programmers sometimes guessig what s goig o) Iterpreters allow programs to be exteded at ru time Laguages such as Smalltalk-80 with polymorphic types allow variable ames to refer to objects of multiple types at ru time Method bidig i object-orieted laguages must be late to support dyamic bidig COP4020 Fall

8 Bidig Lifetime versus Object Lifetime Key evets i object lifetime: Object creatio Creatio of bidigs The object is maipulated via its bidig Deactivatio ad reactivatio of (temporarily ivisible) bidigs Destructio of bidigs Destructio of objects Bidig lifetime: time betwee creatio ad destructio of bidig to object Example: a poiter variable is set to the address of a object Example: a formal argumet is boud to a actual argumet Object lifetime: time betwee creatio ad destructio of a object COP4020 Fall

9 Bidig Lifetime versus Object Lifetime (cot d) Bidigs are temporarily ivisible whe code is executed where the bidig (ame «object) is out of scope Memory leak: object ever destroyed (bidig to object may have bee destroyed, rederig access impossible) Daglig referece: object destroyed before bidig is destroyed Garbage collectio prevets these allocatio/deallocatio problems COP4020 Fall

10 C++ Example { } SomeClass* myobject = ew SomeClass;... { OtherClass myobject;... // the myobject ame is boud to other object... }... // myobject bidig is visible agai... myobject->actio() // myobject i actio(): // the ame is ot i scope // but object is boud to this delete myobject; // myobject is a daglig referece COP4020 Fall

11 Object Storage Objects (program data ad code) have to be stored i memory durig their lifetime Static objects have a absolute storage address that is retaied throughout the executio of the program Global variables ad data Subroutie code ad class method code Stack objects are allocated i last-i first-out order, usually i cojuctio with subroutie calls ad returs Actual argumets passed by value to a subroutie Local variables of a subroutie Heap objects may be allocated ad deallocated at arbitrary times, but require a expesive storage maagemet algorithm Example: Lisp lists Example: Java class istaces are always stored o the heap COP4020 Fall

12 Typical Program ad Data Layout i Memory Upper addr Virtual memory address space stack heap static data Program code is at the bottom of the memory regio (code sectio) The code sectio is protected from ru-time modificatio by the OS Static data objects are stored i the static regio Stack grows dowward Heap grows upward code 0000 COP4020 Fall

13 Static Allocatio Program code is statically allocated i most implemetatios of imperative laguages Statically allocated variables are history sesitive Global variables keep state durig etire program lifetime Static local variables i C fuctios keep state across fuctio ivocatios Static data members are shared by objects ad keep state durig program lifetime Advatage of statically allocated object is the fast access due to absolute addressig of the object So why ot allocate local variables statically? Problem: static allocatio of local variables caot be used for recursive subrouties: each ew fuctio istatiatio eeds fresh locals COP4020 Fall

14 Static Allocatio i Fortra 77 Temporary storage (e.g. for expressio evaluatio) Local variables Bookkeepig (e.g. saved CPU registers) Retur address Subroutie argumets ad returs Typical static subroutie frame layout Fortra 77 has o recursio Global ad local variables are statically allocated as decided by the compiler Global ad local variables are refereced at absolute addresses Avoids overhead of creatio ad destructio of local objects for every subroutie call Each subroutie i the program has a subroutie frame that is statically allocated This subroutie frame stores all subroutie-relevat data that is eeded to execute COP4020 Fall

15 Stack Allocatio Each istace of a subroutie that is active has a subroutie frame (sometimes called activatio record) o the ru-time stack Compiler geerates subroutie callig sequece to setup frame, call the routie, ad to destroy the frame afterwards Method ivocatio works the same way, but i additio methods are typically dyamically boud Subroutie frame layouts vary betwee laguages, implemetatios, ad machie platforms COP4020 Fall

16 Typical Stack-Allocated Subroutie Frame Lower addr Temporary storage (e.g. for expressio evaluatio) Local variables Bookkeepig (e.g. saved CPU registers) A frame poiter (fp) poits to the frame of the curretly active subroutie at ru time Subroutie argumets, local variables, ad retur values are accessed by costat address offsets from the fp fp Higher addr Retur address Subroutie argumets ad returs Typical subroutie frame layout COP4020 Fall

17 Subroutie Frames o the Stack sp fp Higher addr A B A M Temporaries Local variables Bookkeepig Retur address Argumets Temporaries Local variables Bookkeepig Retur address Argumets Temporaries Local variables Bookkeepig Retur address Argumets Temporaries Local variables Bookkeepig Retur address Argumets Stack growth Subroutie frames are pushed ad popped oto/from the rutime stack The stack poiter (sp) poits to the ext available free space o the stack to push a ew frame oto whe a subroutie is called The frame poiter (fp) poits to the frame of the curretly active subroutie, which always the topmost frame o the stack The fp of the previous active frame is saved i the curret frame ad restored after the call I this example: M called A A called B B called A COP4020 Fall

18 Example Subroutie Frame Lower addr fp-32 fp fp+4 Higher addr Temporaries -36: foo (4 bytes) -32: bar (8 bytes) -24: p (4 bytes) Bookkeepig (16 bytes) Retur address to the caller of P (4 bytes) 0: a (4 bytes) 4: b (4 bytes) The size of the types of local variables ad argumets determies the fp offset i a frame Example Pascal procedure: procedure P(a:iteger, var b:real) (* a is passed by value b is passed by referece, = poiter to b's value *) var foo:iteger;(* 4 bytes *) bar:real; (* 8 bytes *) p:^iteger; (* 4 bytes *) begi... ed COP4020 Fall

19 Heap Allocatio Implicit heap allocatio: Doe automatically Java class istaces are placed o the heap Scriptig laguages ad fuctioal laguages make extesive use of the heap for storig objects Some procedural laguages allow array declaratios with rutime depedet array size Resizable character strigs Explicit heap allocatio: Statemets ad/or fuctios for allocatio ad deallocatio Malloc/free, ew/delete COP4020 Fall

20 Heap Allocatio Algorithms Heap allocatio is performed by searchig the heap for available free space For example, suppose we wat to allocate a ew object E of 20 bytes, where would it fit? Object A Free Object B Object C Free Object D Free 30 bytes 8 bytes 10 bytes 24 bytes 24 bytes 8 bytes 20 bytes Deletio of objects leaves free blocks i the heap that ca be reused Iteral heap fragmetatio: if allocated object is smaller tha the free block the extra space is wasted Exteral heap fragmetatio: smaller free blocks caot always be reused resultig i wasted space COP4020 Fall

21 Heap Allocatio Algorithms (cot d) Maitai a liked list of free heap blocks First-fit: select the first block i the list that is large eough Best-fit: search the etire list for the smallest free block that is large eough to hold the object If a object is smaller tha the block, the extra space ca be added to the list of free blocks Whe a block is freed, adjacet free blocks are coalesced Buddy system: use heap pools of stadard sized blocks of size 2 k If o free block is available for object of size betwee 2 k-1 +1 ad 2 k the fid block of size 2 k+1 ad split it i half, addig the halves to the pool of free 2 k blocks, etc. Fiboacci heap: use heap pools of stadard size blocks accordig to Fiboacci umbers More complex but leads to slower iteral fragmatatio COP4020 Fall

22 Ulimited Extet A object declared i a local scope has ulimited extet if its lifetime potetially cotiues idefiitely, as log as bidigs to the object exist that may be out of scope A local stack-allocated variable has a lifetime limited to the lifetime of the subroutie I C/C++ fuctios should ever retur poiters to local variables Ulimited extet requires static or heap allocatio Issues with static: limited, o mechaism to allocate more variables Issues with heap: should deallocate whe o loger refereced by bidigs Solutio usig heap: garbage collectio removes object whe o loger boud (by ay refereces) COP4020 Fall

23 Garbage Collectio Explicit maual deallocatio errors are amog the most expesive ad hard to detect problems i real-world applicatios If a object is deallocated too soo, a referece to the object becomes a daglig referece If a object is ever deallocated, the program leaks memory Automatic garbage collectio removes all objects from the heap that are ot accessible, i.e. are ot refereced Used i Lisp, Scheme, Prolog, Ada, Java, Haskell Disadvatage is GC overhead, but GC algorithm efficiecy has bee improved Not always suitable for real-time processig COP4020 Fall

24 Ada C Storage Allocatio Compared C++ Java Fortra77 Pascal N/A Static Stack Heap global variables; static local variables Same as C, ad static class members N/A global variables (i commo blocks), local variables, ad subroutie argumets (implemetatio depedet); SAVE forces static allocatio global variables (compiler depedet) local variables ad subroutie argumets of fixed size local variables ad subroutie argumets Same as C oly local variables of primitive types local variables ad subroutie argumets (implemetatio depedet implicit: local variables of variable size; explicit: ew (destructio with garbage collectio or explicit with uchecked deallocatio) explicit with malloc ad free explicit with ew ad delete implicit: all class istaces (destructio with garbage collectio) N/A global variables Explicit: ew ad dispose (compiler depedet), local variables, ad subroutie argumets COP4020 Fall

25 Scope Scope is the textual regio of a program i which a ame-to-object bidig is active Statically scoped laguage: the scope of bidigs is determied at compile time Used by almost all but a few programmig laguages More ituitive to user compared to dyamic scopig Dyamically scoped laguage: the scope of bidigs is determied at ru time Used i Lisp (early versios), APL, Sobol, ad Perl (selectively) COP4020 Fall

26 Effect of Static Scopig Program executio: a:iteger bidig mai() a:=2 secod() a:iteger first() a:=1 write_iteger(a) Program prits 1 The followig pseudo-code program demostrates the effect of scopig o variable bidigs: a:iteger procedure first a:=1 procedure secod a:iteger first() procedure mai a:=2 secod() write_iteger(a) COP4020 Fall

27 Effect of Dyamic Scopig Program executio: a:iteger mai() a:=2 secod() bidig a:iteger first() a:=1 write_iteger(a) Program prits 2 The followig pseudo-code program demostrates the effect of scopig o variable bidigs: a:iteger procedure first a:=1 Bidig depeds o executio procedure secod a:iteger first() procedure mai a:=2 secod() write_iteger(a) COP4020 Fall

28 Static Scopig The bidigs betwee ames ad objects ca be determied by examiatio of the program text Scope rules of a program laguage defie the scope of variables ad subrouties, which is the regio of program text i which a ame-to-object bidig is usable Early Basic: all variables are global ad visible everywhere Fortra 77: the scope of a local variable is limited to a subroutie; the scope of a global variable is the whole program text uless it is hidde by a local variable declaratio with the same variable ame Algol 60, Pascal, ad Ada: these laguages allow ested subrouties defiitios ad adopt the closest ested scope rule with slight variatios i implemetatio COP4020 Fall

29 Closest Nested Scope Rule procedure P1(A1:T1) var X:real;... procedure P2(A2:T2);... procedure P3(A3:T3);... begi (* body of P3: P3,A3,P2,A2,X of P1,P1,A1 are visible *) ed;... begi (* body of P2: P3,P2,A2,X of P1,P1,A1 are visible *) ed; procedure P4(A4:T4);... fuctio F1(A5:T5):T6; var X:iteger;... begi (* body of F1: X of F1,F1,A5,P4,A4,P2,P1,A1 are visible *) ed;... begi (* body of P4: F1,P4,A4,P2,X of P1,P1,A1 are visible *) ed;... begi (* body of P1: X of P1,P1,A1,P2,P4 are visible *) ed To fid the object refereced by a give ame: Look for a declaratio i the curret iermost scope If there is oe, look for a declaratio i the immediately surroudig scope, etc. COP4020 Fall

30 Static Scope Implemetatio with Static Liks Scope rules are desiged so that we ca oly refer to variables that are alive: the variable must have bee stored i the frame of a subroutie If a variable is ot i the local scope, we are sure there is a frame for the surroudig scope somewhere below o the stack: The curret subroutie ca oly be called whe it was visible The curret subroutie is visible oly whe the surroudig scope is active Each frame o the stack cotais a static lik poitig to the frame of the static paret COP4020 Fall

31 Example Static Liks Subrouties C ad D are declared ested i B B is static paret of C ad D B ad E are ested i A A is static paret of B ad E The fp poits to the frame at the top of the stack to access locals The static lik i the frame poits to the frame of the static paret COP4020 Fall

32 Static Chais How do we access o-local objects? The static liks form a static chai, which is a liked list of static paret frames Whe a subroutie at estig level j has a referece to a object declared i a static paret at the surroudig scope ested at level k, the j-k static liks forms a static chai that is traversed to get to the frame cotaiig the object The compiler geerates code to make these traversals over frames to reach o-local objects COP4020 Fall

33 Example Static Chais Subroutie A is at estig level 1 ad C at estig level 3 Whe C accesses a object of A, 2 static liks are traversed to get to A's frame that cotais that object COP4020 Fall

34 Out of Scope No-local objects ca be hidde by local ame-to-object bidigs ad the scope is said to have a hole i which the o-local bidig is temporarily iactive but ot destroyed Some laguages, otably Ada ad C++ use qualifiers or scope resolutio operators to access o-local objects that are hidde P1.X i Ada to access variable X of P1 ad ::X to access global variable X i C++ COP4020 Fall

35 Out of Scope Example procedure P1; var X:real; procedure P2; var X:iteger begi... (* X of P1 is hidde *) ed; begi... ed P2 is ested i P1 P1 has a local variable X P2 has a local variable X that hides X i P1 Whe P2 is called, o extra code is executed to iactivate the bidig of X to P1 COP4020 Fall

36 Dyamic Scope Scope rule: the "curret" bidig for a give ame is the oe ecoutered most recetly durig executio Typically adopted i (early) fuctioal laguages that are iterpreted Perl v5 allows you to choose scope method for each variable separately With dyamic scope: Name-to-object bidigs caot be determied by a compiler i geeral Easy for iterpreter to look up ame-to-object bidig i a stack of declaratios Geerally cosidered to be "a bad programmig laguage feature" Hard to keep track of active bidigs whe readig a program text Most laguages are ow compiled, or a compiler/iterpreter mix Sometimes useful: Uix eviromet variables have dyamic scope COP4020 Fall

37 Dyamic Scopig Problems I this example, fuctio scaled_score probably does ot do what the programmer iteded: with dyamic scopig, max_score i scaled_score is boud to foo's local variable max_score after foo calls scaled_score, which was the most recet bidig durig executio: max_score:iteger fuctio scaled_score(raw_score:iteger):real retur raw_score/max_score* procedure foo max_score:real := 0... foreach studet i class studet.percet := scaled_score(studet.poits) if studet.percet > max_score max_score := studet.percet COP4020 Fall

38 Dyamic Scope Implemetatio with Bidigs Stacks Each time a subroutie is called, its local variables are pushed o a stack with their ame-to-object bidig Whe a referece to a variable is made, the stack is searched top-dow for the variable's ame-to-object bidig After the subroutie returs, the bidigs of the local variables are popped Differet implemetatios of a bidig stack are used i programmig laguages with dyamic scope, each with advatages ad disadvatages COP4020 Fall

39 Referecig Eviromets If a subroutie is passed as a argumet to aother subroutie, whe are the static/dyamic scopig rules applied? Whe the referece to the subroutie is first created (i.e. whe it is passed as a argumet) Or whe the argumet subroutie is fially called That is, what is the referecig eviromet of a subroutie passed as a argumet? Evetually the subroutie passed as a argumet is called ad may access o-local variables which by defiitio are i the referecig eviromet of usable bidigs The choice is fudametal i laguages with dyamic scope The choice is limited i laguages with static scope COP4020 Fall

40 Effect of Deep Bidig i Dyamically-Scoped Laguages Program executio: mai(p) thres:iteger bidig thres := 35 show(p,older) thres:iteger thres := 20 older(p) retur p.age>thres if retur value is true write(p) Program prits persos older tha 35 The followig program demostrates the differece betwee deep ad shallow bidig: fuctio older(p:perso):boolea retur p.age>thres procedure show(p:perso,c:fuctio) thres:iteger thres := 20 if c(p) write(p) procedure mai(p) thres:iteger thres := 35 show(p,older) COP4020 Fall

41 Effect of Shallow Bidig i Dyamically-Scoped Laguages Program executio: mai(p) thres:iteger thres := 35 show(p,older) thres:iteger bidig thres := 20 older(p) retur p.age>thres if retur value is true write(p) Program prits persos older tha 20 The followig program demostrates the differece betwee deep ad shallow bidig: fuctio older(p:perso):boolea retur p.age>thres procedure show(p:perso,c:fuctio) thres:iteger thres := 20 if c(p) write(p) procedure mai(p) thres:iteger thres := 35 show(p,older) COP4020 Fall

42 Implemetig Deep Bidigs with Subroutie Closures The referecig eviromet is budled with the subroutie as a closure ad passed as a argumet A subroutie closure cotais A poiter to the subroutie code The curret set of ame-to-object bidigs Depedig o the implemetatio, the whole curret set of bidigs may have to be copied or the head of a list is copied if liked lists are used to implemet a stack of bidigs COP4020 Fall

43 Statemet Blocks C Ada C++ Java C# { it t = a; a = b; b = t; } declare t:iteger begi t := a; a := b; b := t; ed; { it a,b;... it t; t=a; a=b; b=t;... } I Algol, C, ad Ada local variables are declared i a block or compoud statemet I C++, Java, ad C# declaratios may appear aywhere statemets ca be used ad the scope exteds to the ed of the block Local variables declared i ested blocks i a sigle fuctio are all stored i the subroutie frame for that fuctio (most programmig laguages, e.g. C/C++, Ada, Java) COP4020 Fall

44 Modules ad Module Scope Modules are the most importat feature of a programmig laguage that supports the costructio of large applicatios Teams of programmers ca work o separate modules i a project No laguage support for modules i C ad Pascal Modula-2 modules, Ada packages, C++ amespaces Java packages Scopig: modules ecapsulate variables, data types, ad subrouties i a package Objects iside are visible to each other Objects iside are ot visible outside uless exported Objects outside are ot visible iside uless imported A module iterface specifies exported variables, data types, ad subrouties The module implemetatio is compiled separately ad implemetatio details are hidde from the user of the module COP4020 Fall

45 First, Secod, ad Third-Class Subrouties First-class object: a object etity that ca be passed as a parameter, retured from a subroutie, ad assiged to a variable Primitive types such as itegers i most programmig laguages Secod-class object: a object that ca be passed as a parameter, but ot retured from a subroutie or assiged to a variable Fixed-size arrays i C/C++ Third-class object: a object that caot be passed as a parameter, caot be retured from a subroutie, ad caot be assiged to a variable Labels of goto-statemets ad subrouties i Ada 83 Fuctios i Lisp, ML, ad Haskell are urestricted first-class objects With certai restrictios, subrouties are first-class objects i Modula-2 ad 3, Ada 95, (C ad C++ use fuctio poiters) COP4020 Fall

46 First-Class Subroutie Implemetatio Requiremets fuctio ew_it_priter(port:iteger):procedure procedure prit_it(val:it) begi write(port, val) ed begi retur prit_it ed procedure mai begi myprit:procedure myprit := ew_it_priter(80) myprit(7) ed Problem: subroutie retured as object may lose part of its referece eviromet i its closure! Procedure prit_it uses argumet port of ew_it_priter, which is i the referecig eviromet of prit_it After the call to ew_it_priter, argumet port should be kept alive somehow (it is ormally removed from the ru-time stack ad it will become a daglig referece) COP4020 Fall

47 First-Class Subroutie Implemetatios I fuctioal laguages, local objects have ulimited extet: their lifetime cotiue idefiitely Local objects are allocated o the heap Garbage collectio will evetually remove uused objects I imperative laguages, local objects have limited extet with stack allocatio To avoid the problem of daglig refereces, alterative mechaisms are used: C, C++, ad Java: o ested subroutie scopes Modula-2: oly outermost routies are first-class Ada 95 "cotaimet rule": ca retur a ier subroutie uder certai coditios COP4020 Fall

48 Overloaded Bidigs A ame that ca refer to more tha oe object is said to be overloaded Example: + (additio) is used for iteger ad ad floatig-poit additio i most programmig laguages Sematic rules of a programmig laguage require that the cotext of a overloaded ame should cotai sufficiet clues to deduce the iteded bidig Sematic aalyzer of compiler uses type checkig to resolve bidigs Ada ad C++ fuctio overloadig eables programmer to defie alterative implemetatios depedig o argumet types Ada, C++, ad Fortra 90 allow built-i operators to be overloaded with user-defied fuctios, which ehaces expressiveess but may mislead programmers that are ufamiliar with the code COP4020 Fall

49 Overloaded Bidigs Example Example i C++: struct complex {...}; eum base {dec, bi, oct, hex}; void prit_um(it ) {... } void prit_um(it, base b) {... } void prit_um(struct complex c) {... } COP4020 Fall

50 Dyamic Bidigs Object data VMT poiter Method #4 Overridde Method code Method #4 Derived Class VMT Base Class VMT Polymorphic fuctios ad operators based o overloadig are statically boud by the compiler based o type iformatio Polymorphism with dyamic bidigs is supported by class iheritace (C++ virtual methods) Each class has a virtual method table (VMT) with poiters to methods, where each method is idexed ito the table Method ivocatio proceeds by gettig the class VMT from the object ad idexig it to select the method to ivoke Method code COP4020 Fall