CSE 504: Compilers. Expressions. R. Sekar

Size: px
Start display at page:

Download "CSE 504: Compilers. Expressions. R. Sekar"

Transcription

1 CSE 504: Compilers Expressions R. Sekar Expression evaluation 1 / 83 Order of evaluation For the abstract syntax tree x the equivalent expression is (x + 3) + (2 + 4) + 5 Expression evaluation (Continued) 2 / 83 One possible semantics: evaluate AST bottom-up, left-to-right. This constrains optimization that uses mathematical properties of operators (e.g. commutativity and associativity) e.g.,it may be preferable to evaluate of e1+(e2+e3)instead of (e1+e2)+e3 (x+0)+(y+3)+(z+4)=>x+y+z+0+3+4=>x+y+z+7 the compiler can evaluate at compile time, so that at runtime, we have two fewer addition operations. 3 / 83

2 Expression evaluation (Continued) Some languages leave order of evaluation unspecified. order of evaluation of procedure parameters are also unspecified. Problem: Semantics of expressions with side-effects, e.g., (x++) + x If initial value of x is 5 left-to-right evaluation yields 11 as answer, but right-to-left evaluation yields 10 So, languages with expressions with side-effects forced to specify evaluation order Still, a bad programming practice to use expressions where different orders of evaluation can lead to different results Impacts readability (and maintainability) of programs 4 / 83 Left-to-right evaluation Left-to-right evaluation with short-circuit semantics is appropriate for boolean expressions. e1&&e2: e2 is evaluated only if e1 evaluates to true. e1 e2: e2 is evaluated only if e1 evaluates to false. This semantics is convenient in programming: Consider the statement: if((i<n) && a[i]!=0) With short-circuit evaluation, a[i] is never accessed if i>= n Another example: if ((p!=null) && p->value>0) 5 / 83 Left-to-right evaluation (Continued) Disadvantage: In an expression like if((a==b) (c=d)) The second expression has a statement. The value of c may or may not be the value of d, depending on if a == b is true or not. Bottom-up: No order specified among unrelated subexpressions. Short-circuit evaluation of boolean expressions. Delayed evaluation Delay evaluation of an expressions until its value is absolutely needed. Generalization of short-circuit evaluation. 6 / 83

3 Control Statements Structured Control Statements: Case Statements: Implementation using if-then-else Understand semantics in terms of the semantics of simple constructs actual implementation in a compiler Loops while, repeat, for 7 / 83 If-then-else. It is in two forms: if cond then s1 else s2 if cond then s1 evaluate condition: if and only if evaluates to true, then evaluate s1 otherwise evaluate s2. 8 / 83 Case (Switch) Statement Case statement switch(<expr>){ case <value> : case <value> :... default : Evaluate <expr> to get value v. Evaluate the case that corresponds to v. Restriction: <value> has to be a constant of an original type e.g., int, enum Why? 9 / 83

4 Implementation of case statement Naive algorithm: Sequential comparison of value v with case labels. This is simple, but inefficient. It involves O(N) comparisons switch(e){ case 0:s0; case 1:s1; case 2:s2; case 3:s3; can be translated as: v = e; if (v==0) s0; else if (v == 1) s1; else if (v == 2) s2; else if (v == 3) s3; Implementation of case statement (Continued) 10 / 83 Binary search: O(log N) comparisons, a drastic improvement over sequential search for large N. Using this, the above case statement can be translated as v = e; if (v<=1) if (v==0) s0; else if (v==1) s1; else if (v>=2) if (v==2) s2; else if (v==3) s3; Implementation of case statement (Continued) 11 / 83 Another technique is to use hash tables. This maps the value v to the case label that corresponds to the value v. This takes constant time (expected). 12 / 83

5 Control Statements (contd.) while: let s1 = while C do S then it can also be written as s1 = if C then {S; s1 repeat: let s2 = repeat S until C then it can also be written as s2 = S; if (!C) then s2 loop let s = loop S end its semantics can be understood as S; s S should contain a break statement, or else it won t terminate. 13 / 83 For-loop Semantics of for (S2; C; S3) S can be specified in terms of while: S2; while C do { S; S3 In some languages, additional restrictions imposed to enable more efficient code Value of index variable can t change loop body, and is undefined outside the loop Bounds may be evaluated only once 14 / 83 Unstructured Control Flow Unstructured control transfer statements (goto) can make programs hard to understand: 40:if (x > y) then goto 10 if (x < y) then goto 20 goto 30 10:x = x - y goto 40 20:y = y -x goto 40 30:gcd = x 15 / 83

6 Unstructured Control Flow (Continued) Unstructured control transfer statements (goto) can make programs hard to understand: 40:if (x > y) then goto 10 if (x < y) then goto 20 goto 30 10:x = x - y goto 40 20:y = y -x goto 40 30:gcd = x Equivalent program with structured control statements is easier to understand: while (x!=y) { if (x > y) then x=x-y else y=y-x 16 / 83 Control Statements (contd.) goto should be used in rare circumstances e.g., error handling. Java doesn t have goto. It uses labeled break instead: l1: for (... ) { while (...) {... break l1 break l1 causes exit from loop labeled with l1 17 / 83 Control Statements (contd.) Restrictions in use of goto: jumps across procedures jumps from outer blocks to inner blocks or unrelated blocks goto l1; if (...) then { int x; x = 5; l1: y = x*x; Jumps from inner to outer blocks are permitted. 18 / 83

7 Control Statements (Continued) Procedure calls: Communication between the calling and the called procedures takes place via parameters. Semantics: substitute formal parameters with actual parameters rename local variables so that they are unique in the program In an actual implementation, we will simply look up the local variables in a different environment (callee s environment) Renaming captures this semantics without having to model environments. replace procedure call with the body of called procedure Parameter-passing semantics 19 / 83 Call-by-value Call-by-reference Call-by-value-result Call-by-name Call-by-need Macros Call-by-value 20 / 83 Evaluate the actual parameters Assign them to corresponding formal parameters Execute the body of the procedure. int p(int x) { x =x +1 ; return x ; An expression y = p(5+3) is executed as follows: evaluate 5+3 = 8, call p with 8, assign 8 to x, increment x, return x which is assigned to y. 21 / 83

8 Call-by-value (Continued) Preprocessing create a block whose body is that of the procedure being called introduce declarations for each formal parameter, and initialize them with the values of the actual parameters Inline procedure body Substitute the block in the place of procedure invocation statement. 22 / 83 Call-by-value (Continued) Example: int z; void p(int x){ z = 2*x; main(){ int y; p(y); Replacing the invocation p(y) as described yields: int z; main(){ int y; { int x1=y; z = 2*x1; Name Capture 23 / 83 Same names may denote different entities in the called and calling procedures To avoid name clashes, need to rename local variables of called procedure Otherwise, local variables in called procedure may be confused with local variables of calling procedure or global variables 24 / 83

9 Call-by-value (Continued) Example: int z; void p(int x){ int y = 2; z = y*x; main(){ int y; p(y); After replacement: int z; main(){ int y; { int x1=y; int y1=2; z = y1*x1; Call-by-reference 25 / 83 Evaluate actual parameters (must have l-values) Assign these l-values to formal parameters Execute the body. int z = 8; y=p(z); After the call, y and z will both have value 9. Call-by-reference supported in C++, but not in C Effect realized by explicitly passing l-values of parameters using & operator 26 / 83 Call-by-reference (Continued) Explicit simulation in C provides a clearer understanding of the semantics of call-by-reference: int p(int *x){ *x = *x + 1; return *x;... int z; y= p(&z); 27 / 83

10 Call-By-Reference (Continued) Example: int z; void p(int x){ int y = 2; z = y*x; main(){ int y; p(y); After replacement: int z; main(){ int y; { int& x1=y; int y1=2; z = y1*x1; 28 / 83 Call-by-value-result Works like call by value but in addition, formal parameters are assigned to actual parameters at the end of procedure. void p (int x, int y) { x = x +1; y = y+ 1;... int a = 3; p(a, a) ; After the call, a will have the value 4, whereas with call-by- reference, a will have the value / 83 Call-by-value-result (Continued) The following is the equivalent of call-by-value-result call above: x = a; y =a ; x = x +1 ; y =y +1 ; a =x ; a =y ; thus, at the end, a = / 83

11 Call-By-Value-Result (Continued) Example: void p(int x, y){ x = x + 1; y = y + 1; main(){ int u = 3; p(u,u); After replacement: main(){ int u = 3; { int x1 = u; int y1 = u; x1 = x1 + 1; y1 = y1 + 1; u = x1; u = y1; 31 / 83 Call-by-Name Instead of assigning l-values or r-values, CBN works by substituting actual parameter expressions in place of formal parameters in the body of callee Preprocessing: Substitute formal parameters in procedure body by actual parameter expressions. Rename as needed to avoid name capture Inline: Substitute the invocation expression with the modified procedure body. 32 / 83 Call-By-Name (Continued) Example: void p(int x, y){ if (x==0) then return 1; else{ return y; main(){ int u=5; int v=0; p(v,u/v); After replacement: main(){ int u=5; int v=0; { if (v==0) then return 1; else{ return u/v; 33 / 83

12 Call-By-Need Similar to call-by-name, but the actual parameter is evaluated at most once Has same semantics as call-by-name in functional languages This is because the value of expressions does not change with time Has different semantics in imperative languages, as variables involved in the actual parameter expression may have different values each time the expression is evaluated in C-B-Name 34 / 83 Macros Macros work like CBN, with one important difference: No renaming of local variables This means that possible name clashes between actual parameters and variables in the body of the macro will lead to unexpected results. 35 / 83 Macros (Continued) given #define sixtimes(y) {int z=0; z = 2*y; y = 3*z; main() { int x=5, z=3; sixtimes(z); After macro substitution, we get the program: main(){ int x=5,z=3; {int z=0; z = 2*z; z = 3*z; 36 / 83

13 Macros (Continued) It is different from what we would have got with CBN parameter passing. In particular, the name confusion between the local variable z and the actual parameter z would have been avoided, leading to the following result: main() { int x = 5, z = 3; { int z1=0; // z renamed as z1 z1 = 2*z; // y replaced by z without z = 3*z1; // confusion with original z 37 / 83 Difficulties in Using CBV: Easiest to understand, no difficulties or unexpected results. CBVR: When the same parameter is passed in twice, the end result can differ depending on the order. The order of values assigning back to actual parameters. Otherwise, relatively easy to understand. 38 / 83 Difficulties With CBVR (Continued) Example: int f(int x, int y) { x=4; y=5; void g() { int z; f(z, z); If assignment of formal parameter values to actual parameters were performed left to right, then z would have a value of 5. If they were performed right to left, then z will be / 83

14 Difficulties in Using CBR Aliasing can create problems. int rev(int a[], int b[], int size) { for (int i = 0; i < size; i++) a[i] = b[size-i-1]; The above procedure will normally copy b into a, while reversing the order of elements in b. However, if a and b are the same, as in an invocation rev(c,c,4), the result is quite different. If c is 1,2,3,4 at the point of call, then its value on exit from rev will be 4,3,3,4. 40 / 83 Difficulties in Using CBN CBN is complicated, and can be confusing in the presence of side-effects. actual parameter expression with side-effects: void f(int x) { int y = x; int z = x; main() { int y = 0; f(y++); Note that after a call to f, y s value will be 2 rather than / 83 Difficulties in Using CBN (Continued) If the same variable is used in multiple parameters. void swap(int x, int y) { int tp = x; x = y; y = tp; main() { int a[] = {1, 1, 0; int i = 2; swap(i, a[i]); When using CBN, by replacing the call to swap by the body of swap: i will be 0, and a will be 2, 1, / 83

15 Difficulties in Using Macro Macros share all of the problems associated with CBN. In addition, macro substitution does not perform renaming of local variables, leading to additional problems. 43 / 83 Components of Runtime Environment (RTE) Static area: allocated at load/startup time. Examples: global/static variables and load-time constants. Stack area: for execution-time data that obeys a last-in first-out lifetime rule. Examples: nested declarations and temporaries. Heap: a dynamically allocated area for fully dynamic data, i.e. data that does not obey a LIFO rule. Examples: objects in Java, lists in OCaml. 44 / 83 Languages and Environments Languages differ on where activation records must go in the environment: (Old) Fortran is static: all data, including activation records, are statically allocated. Each function has only one activation record no recursion! Functional languages (Scheme, ML) and some OO languages (Smalltalk) are heap-oriented: almost all data, including AR, allocated dynamically. Most languages are in between: data can go anywhere ARs go on the stack. 45 / 83

16 Procedures and the environment An Activation Record (AR) is created for each invocation of a procedure Structure of AR: Base Pointer Actual parameters Return value Return address Saved BP (control link) Local variables Temporary variables Direction of stack growth Access to Local Variables 46 / 83 Local variables are allocated at a fixed offset on the stack Accessed using this constant offset from BP Example: to load a local variable at offset 8 into the EBX register (x86 architecture) mov 0x8(%ebp),%ebx Example: {int x; int y; { int z; { int w; Steps involved in a procedure call 47 / 83 Caller Save registers Evaluate actual parameters, push on the stack Push l-values for CBR, r-values in the case of CBV Allocate space for return value on stack (unless return is through a register) Call: Save return address, jump to the beginning of called function Callee Save BP (control link field in AR) Move SP to BP Allocate storage for locals and temporaries (Decrement SP) Local variables accessed as [BP-k], parameters using [BP+l] 48 / 83

17 Steps in return Callee Copy return value into its location on AR Increment SP to deallocate locals/temporaries Restore BP from Control link Jump to return address on stack Caller Copy return values and parameters Pop parameters from stack Restore saved registers 49 / 83 Example (C): int x; void p(int y){ int i = x; char c;... void q (int a){ int x; p(1); main(){ q(2); return 0; 50 / 83 Non-local variable access Requires that the environment be able to identify frames representing enclosing scopes. Using the control link results in dynamic scope (and also kills the fixed-offset property). If procedures can t be nested (C), the enclosing scope is always locatable: it is global/static (accessed directly) If procedures can be nested (Ada, Pascal), to maintain lexical scope a new link must be added to each frame: access link, pointing to the activation of the defining environment of each procedure. 51 / 83

18 Access Link vs Control Link Control Link is a reference to the AR of the caller Access link is a reference to the AR of the surrounding scope Dynamic Scoping: When an identifier is not found in the current AR, use control link to access caller s AR and look up the name there If not found, keep walking up the control links until name is found Static Scoping: When an identifier is not found in the AR of the current function, use access link to get to AR for the surrounding scope and look up the name there If not found, keep walking up the access links until the name is found. Note: Except for top-level functions, access links correspond to function scopes, so they cannot be determined statically They need to be passed in like a parameter. Access Link Vs Control Link: Example 52 / 83 int q(int x) { int p(int y) { if (y==0) return x+y; else { int x = 2*p(y-1); return x; return p(3); If p used its caller s BP to access x, then it ends up accessing the variable x defined within p This would be dynamic scoping. To get static scoping, access should use q s BP Access link: q explicitly passes a link to its BP Calls to self: pass access link without change. Calls to immediately nested functions: pass your BP Calls to outer functions: Follow your access link to find the right access link to pass Other calls: these will be invalid (like goto to an inner block) Supporting Closures 53 / 83 Closures are needed for Call-by-name and lazy evaluation Returning dynamically constructed functions containing references to variables in surrounding scope Variables inside closures may be accessed long after the functions defining them have returned Need to copy variable values into the closure, or Not free the AR of functions when they return, i.e., allocate ARs on heap and garbage collect them 54 / 83

19 Exception Handling Example: int fac(int n) { if (n <= 0) throw (-1) ; else if (n > 15) throw ("n too large"); else return n*fac(n-1); void g (int n) { int k; try { k = fac (n) ; catch (int i) { cout << "negative value invalid" ; catch (char *s) { cout << s; catch (...) { cout << "unknown exception" ; g(-1) will print negative value invalid, g(16) will print n too large If an unexpected error were to arise in evaluation of fac or g, such as running out of memory, then unknown exception will be printed. 55 / 83 Exception Vs Return Codes Exceptions are often used to communucate error values from a callee to its caller. Return values provide alternate means of communicating errors. Example use of exception handler: float g (int a, int b, int c) { float x = fac(a) + fac(b) + fac(c) ; return x ; main() { try { g(-1, 3, 25); catch (char *s) { cout << "Exception " << s << " raised, exiting\n"; catch (...) { cout << "Unknown exception, eixting\n"; We do not need to concern ourselves with every point in the program where an error may arise. 56 / 83 Exception Vs Return Codes (Continued) float g(int a, int b, int c) { int x1 = fac(a); if (x1 > 0) { int x2 = fac(b); if (x2 > 0) { int x3 = fac(c); if (x3 > 0) return x1 + x2 + x3; else return x3; else return x2; else return x1; main() { int x = g(-1, 2, 25); if (x < 0) { /* identify where error occurred, print */ Assume that fac returns 0 or a negative number to indicated errors If return codes were used to indicate errors, then we are forced to check return codes (and take appropriate action) at every point in code. 57 / 83

20 Use of Exceptions in C++ Vs Java In C++, exception handling was an after-thought. Earlier versions of C++ did not support exception handling. Exception handling not used in standard libraries Net result: continued use of return codes for error-checking In Java, exceptions were included from the beginning. All standard libraries communicate errors via exceptions. Net result: all Java programs use exception handling model for error-checking, as opposed to using return codes. 58 / 83 Implementation of Exception Handling Exception handling can be implemented by adding markers to ARs to indicate the points in program where exception handlers are available. In C++, entering a try-block at runtime would cause such a marker to be put on the stack When exception arises, the RTE gets control and searches down from stack top for a marker. Exception then "handed" to the catch statement of this try-block that matches the exception If no matching catch statement is present, search for a marker is continued further down the stack, and the whole process is repeated. Memory Allocation 59 / 83 A variable is stored in memory at a location corresponding to the variable. Constants do not need to be stored in memory. Environment stores the binding between variable names and the corresponding locations in memory. The process of setting up this binding is known as storage allocation. 60 / 83

21 Static Allocation Allocation performed at compile time. Compiler translates all names to corresponding location in the code generated by it. Examples: all variables in original FORTRAN all global and static variables in C/C++/Java Stack Allocation 61 / 83 Needed in any language that supports the notion of local variables for procedures. Also called automatic allocation, but this is somewhat of a misnomer now. Examples: all local variables in C/C++/Java procedures and blocks. Implementation: Compiler translates all names to relative offsets from a location called the base pointer or frame pointer. The value of this pointer varies will, in general, be different for different procedure invocations 62 / 83 Stack Allocation (Continued) The pointer refers to the base of the activation record (AR) for an invocation of a procedure. The AR holds such information as parameter values, local variables, return address, etc. int fact(int n){ if n=0 then 1 else{ int rv = n*fact(n-1); return rv; main(){ fact(5); 63 / 83

22 Stack Allocation (Continued) An activation record is created on the stack for each a call to function. The start of activation record is pointed to by a register called BP. On the first call to fact, BP is decremented to point to new activation record, n is initialized to 5, rv is pushed but not initialized. New activation record is created for the next recursive call and so on. When n becomes 0, stack is unrolled where successive rv s are assigned the value of n at that stage and the rv of previous stage. Heap Management 64 / 83 Issues No LIFO property, so management is difficult Fragmentation Locality Models explicit allocation, free e.g., malloc/free in C, new/delete in C++ explicit allocation, automatic free e.g., Java automatic allocation, automatic free e.g., Lisp, OCAML, Python, JavaScript 65 / 83 Fragmentation Internal fragmentation: When asked for x bytes, allocator returns y > x bytes y x represents internal fragmentation External fragmentation: When (small) free blocks of memory occur in between (i.e., external to) allocated blocks the memory manager may have a total of M N bytes of free memory available, but no contiguous block larger enough to satisfy a request of size N. 66 / 83

23 Approaches for Reducing Fragmentation Use blocks of single size (early LISP) Limits data-structures to use less efficient implementations. Use bins of fixed sizes, e.g., 2 n for n = 0, 1, 2,... When you run out of blocks of a certain size, break up a block of next available size Eliminates external fragmentation, but increases internal fragmentation Maintain bins as LIFO lists to increase locality malloc implementations (Doug Lea) For small blocks, use bins of size 8k bytes, 0 < k < 64 For larger blocks, use bins of sizes 2 n for n > 9 67 / 83 Coalescing What if a program allocates many 8 byte chunks, frees them all and then requests lots of 16 byte chunks? Need to coalesce 8-byte chunks into 16-byte chunks Requires additional information to be maintained for allocated blocks: where does the current block end, and whether the next block is free 68 / 83 Explicit Vs Automatic Management Explicit memory management can be more efficient, but takes a lot of programmer effort Programmers often ignore memory management early in coding, and try to add it later on But this is very hard, if not impossible Result: Majority of bugs in production code is due to memory management errors Memory leaks Null pointer or uninitalized pointer access Access through dangling pointers 69 / 83

24 Managing Manual Deallocation How to avoid errors due to manual deallocation of memory Never free memory!!! Use a convention of object ownership (owner responsible for freeing objects)âăŕ Tends to reduce errors, but still requires a careful design from the beginning. (Cannot ignore memory deallocation concerns initially and add it later.)âăŕ Smart data structures, e.g., reference counting objects Region-based allocation When a collection of objects having equal life time are allocated Example: Apache web server s handling of memory allocations while serving a HTTP request Garbage Collection 70 / 83 Garbage collection aims to avoid problems associated with manual deallocation Identify and collect garbage automatically What is garbage? Unreachable memory Automatic garbage collection techniques have been developed over a long time Since the days of LISP (1960s) Garbage Collection Techniques 71 / 83 Reference Counting Works if there are no cyclic structures Mark-and-sweep Generational collectors Issues Overhead (memory and space)âăŕ Pause-time Locality 72 / 83

25 Reference Counting Each heap block maintains a count of the number of pointers referencing it. Each pointer assignment increments/decrements this count Deallocation of a pointer variable decrements this count When reference count becomes zero, the block can be freed 73 / 83 Reference Counting (Continued) Disadvantages: Does not work with cyclic structures May impact locality Increases cost of each pointer update operation Advantages: Overhead is predictable, fixed Garbage is collected immediately, so more efficient use of space Mark-and-Sweep 74 / 83 Mark every allocated heap block as unreachable Start from registers, local and global variables Do a depth-first search, following the pointers Mark each heap block visited as reachable At the end of the sweep phase, reclaim all heap blocks still marked as unreachable 75 / 83

26 Garbage Collection Issues Memory fragmentation Memory pages may become sparsely populated Performance will be hit due to excessive virtual memory usage and page faults Can be a problem with explicit memory management as well But if a programmer is willing to put in the effort, the problem can be managed by freeing memory as soon as possible Solution: Compacting GC Copy live structures so that they are contiguous Copying GC Copying Garbage Collection 76 / 83 Instead of doing a sweep, simply copy over all reachable heap blocks into a new area After the copying phase, all original blocks can be freed Now, memory is compacted, so paging performance will be much better Needs up to twice the memory of compacting collector, but can be much faster Reachable memory is often a small fraction of total memory Generational Garbage Collection 77 / 83 Take advantage of the fact that most objects are short-lived Exploit this fact to perform GC faster Idea: Divide heap into generations If all references go from younger to older generation (as most do), can collect youngest generation without scanning regions occupied by other generations Need to track references from older to younger generation to make this work in all cases 78 / 83

27 Garbage collection in Java Generational GC for young objects Tenured objects stored in a second region Use mark-and-sweep with compacting Makes use of multiple processors if available References GC for C/C++: Conservative Garbage Collection 79 / 83 Cannot distinguish between pointers and nonpointers Need conservative garbage collection The idea: if something looks like a pointer, assume that it may be one! Problem: works for finding reachable objects, but cannot modify a value without being sure Copying and compaction are ruled out! Reasonable GC implementations are available, but they do have some drawbacks Unpredictable performance Can break some programs that modify pointer values before storing them in memory 80 / 83

CSE 504. Expression evaluation. Expression Evaluation, Runtime Environments. One possible semantics: Problem:

CSE 504. Expression evaluation. Expression Evaluation, Runtime Environments. One possible semantics: Problem: Expression evaluation CSE 504 Order of evaluation For the abstract syntax tree + + 5 Expression Evaluation, Runtime Environments + + x 3 2 4 the equivalent expression is (x + 3) + (2 + 4) + 5 1 2 (. Contd

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages CSE 307: Principles of Programming Languages Procedures and Parameter Passing R. Sekar Topics 1 / 28 1. Control Statements (Continued) 2 / 28 Procedure calls: Communication between the calling and the

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages 1 / 57 CSE 307: Principles of Programming Languages Course Review R. Sekar Course Topics Introduction and History Syntax Values and types Names, Scopes and Bindings Variables and Constants Expressions

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages 1 / 18 CSE 307: Principles of Programming Languages Statements and Control Flow R. Sekar 2 / 18 Topics If-Then-Else 1. If-Then-Else 3 / 18 Control Statements Structured Control Statements: Case Statements:

More information

Programming Languages Third Edition. Chapter 10 Control II Procedures and Environments

Programming Languages Third Edition. Chapter 10 Control II Procedures and Environments Programming Languages Third Edition Chapter 10 Control II Procedures and Environments Objectives Understand the nature of procedure definition and activation Understand procedure semantics Learn parameter-passing

More information

G Programming Languages - Fall 2012

G Programming Languages - Fall 2012 G22.2110-003 Programming Languages - Fall 2012 Lecture 2 Thomas Wies New York University Review Last week Programming Languages Overview Syntax and Semantics Grammars and Regular Expressions High-level

More information

Run-time Environments - 3

Run-time Environments - 3 Run-time Environments - 3 Y.N. Srikant Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Principles of Compiler Design Outline of the Lecture n What is run-time

More information

Weeks 6&7: Procedures and Parameter Passing

Weeks 6&7: Procedures and Parameter Passing CS320 Principles of Programming Languages Weeks 6&7: Procedures and Parameter Passing Jingke Li Portland State University Fall 2017 PSU CS320 Fall 17 Weeks 6&7: Procedures and Parameter Passing 1 / 45

More information

CS558 Programming Languages Winter 2018 Lecture 4a. Andrew Tolmach Portland State University

CS558 Programming Languages Winter 2018 Lecture 4a. Andrew Tolmach Portland State University CS558 Programming Languages Winter 2018 Lecture 4a Andrew Tolmach Portland State University 1994-2018 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.

More information

Concepts Introduced in Chapter 7

Concepts Introduced in Chapter 7 Concepts Introduced in Chapter 7 Storage Allocation Strategies Static Stack Heap Activation Records Access to Nonlocal Names Access links followed by Fig. 7.1 EECS 665 Compiler Construction 1 Activation

More information

CS558 Programming Languages

CS558 Programming Languages CS558 Programming Languages Fall 2016 Lecture 4a Andrew Tolmach Portland State University 1994-2016 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.

More information

Module 27 Switch-case statements and Run-time storage management

Module 27 Switch-case statements and Run-time storage management Module 27 Switch-case statements and Run-time storage management In this module we will discuss the pending constructs in generating three-address code namely switch-case statements. We will also discuss

More information

CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC 330 - Spring 2013 1 Memory Attributes! Memory to store data in programming languages has the following lifecycle

More information

G Programming Languages - Fall 2012

G Programming Languages - Fall 2012 G22.2110-003 Programming Languages - Fall 2012 Lecture 3 Thomas Wies New York University Review Last week Names and Bindings Lifetimes and Allocation Garbage Collection Scope Outline Control Flow Sequencing

More information

Name, Scope, and Binding. Outline [1]

Name, Scope, and Binding. Outline [1] Name, Scope, and Binding In Text: Chapter 3 Outline [1] Variable Binding Storage bindings and lifetime Type bindings Type Checking Scope Lifetime vs. Scope Referencing Environments N. Meng, S. Arthur 2

More information

Procedure and Object- Oriented Abstraction

Procedure and Object- Oriented Abstraction Procedure and Object- Oriented Abstraction Scope and storage management cs5363 1 Procedure abstractions Procedures are fundamental programming abstractions They are used to support dynamically nested blocks

More information

G Programming Languages - Fall 2012

G Programming Languages - Fall 2012 G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter

More information

Programming Languages Third Edition. Chapter 7 Basic Semantics

Programming Languages Third Edition. Chapter 7 Basic Semantics Programming Languages Third Edition Chapter 7 Basic Semantics Objectives Understand attributes, binding, and semantic functions Understand declarations, blocks, and scope Learn how to construct a symbol

More information

CS558 Programming Languages

CS558 Programming Languages CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.

More information

CSE 3302 Programming Languages Lecture 5: Control

CSE 3302 Programming Languages Lecture 5: Control CSE 3302 Programming Languages Lecture 5: Control (based on the slides by Chengkai Li) Leonidas Fegaras University of Texas at Arlington CSE 3302 L5 Fall 2009 1 Control Control: what gets executed, when,

More information

Programming Language Implementation

Programming Language Implementation A Practical Introduction to Programming Language Implementation 2014: Week 10 Garbage Collection College of Information Science and Engineering Ritsumeikan University 1 review of last week s topics dynamic

More information

Design Issues. Subroutines and Control Abstraction. Subroutines and Control Abstraction. CSC 4101: Programming Languages 1. Textbook, Chapter 8

Design Issues. Subroutines and Control Abstraction. Subroutines and Control Abstraction. CSC 4101: Programming Languages 1. Textbook, Chapter 8 Subroutines and Control Abstraction Textbook, Chapter 8 1 Subroutines and Control Abstraction Mechanisms for process abstraction Single entry (except FORTRAN, PL/I) Caller is suspended Control returns

More information

Scope, Functions, and Storage Management

Scope, Functions, and Storage Management Scope, Functions, and Storage Management Implementing Functions and Blocks cs3723 1 Simplified Machine Model (Compare To List Abstract Machine) Registers Code Data Program Counter (current instruction)

More information

CS 330 Lecture 18. Symbol table. C scope rules. Declarations. Chapter 5 Louden Outline

CS 330 Lecture 18. Symbol table. C scope rules. Declarations. Chapter 5 Louden Outline CS 0 Lecture 8 Chapter 5 Louden Outline The symbol table Static scoping vs dynamic scoping Symbol table Dictionary associates names to attributes In general: hash tables, tree and lists (assignment ) can

More information

CS558 Programming Languages

CS558 Programming Languages CS558 Programming Languages Winter 2017 Lecture 4a Andrew Tolmach Portland State University 1994-2017 Semantics and Erroneous Programs Important part of language specification is distinguishing valid from

More information

Compilers. 8. Run-time Support. Laszlo Böszörmenyi Compilers Run-time - 1

Compilers. 8. Run-time Support. Laszlo Böszörmenyi Compilers Run-time - 1 Compilers 8. Run-time Support Laszlo Böszörmenyi Compilers Run-time - 1 Run-Time Environment A compiler needs an abstract model of the runtime environment of the compiled code It must generate code for

More information

CS558 Programming Languages

CS558 Programming Languages CS558 Programming Languages Fall 2017 Lecture 3a Andrew Tolmach Portland State University 1994-2017 Binding, Scope, Storage Part of being a high-level language is letting the programmer name things: variables

More information

CMSC 330: Organization of Programming Languages. Memory Management and Garbage Collection

CMSC 330: Organization of Programming Languages. Memory Management and Garbage Collection CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC330 Fall 2018 1 Memory Attributes Memory to store data in programming languages has the following lifecycle

More information

Compiler Construction

Compiler Construction Compiler Construction Thomas Noll Software Modeling and Verification Group RWTH Aachen University https://moves.rwth-aachen.de/teaching/ss-16/cc/ Recap: Static Data Structures Outline of Lecture 18 Recap:

More information

CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC 330 Spring 2017 1 Memory Attributes Memory to store data in programming languages has the following lifecycle

More information

Runtime. The optimized program is ready to run What sorts of facilities are available at runtime

Runtime. The optimized program is ready to run What sorts of facilities are available at runtime Runtime The optimized program is ready to run What sorts of facilities are available at runtime Compiler Passes Analysis of input program (front-end) character stream Lexical Analysis token stream Syntactic

More information

Run-time Environments

Run-time Environments Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages 1 / 26 CSE 307: Principles of Programming Languages Names, Scopes, and Bindings R. Sekar 2 / 26 Topics Bindings 1. Bindings Bindings: Names and Attributes Names are a fundamental abstraction in languages

More information

Run-time Environments

Run-time Environments Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction

More information

Compiler Construction

Compiler Construction Compiler Construction Lecture 18: Code Generation V (Implementation of Dynamic Data Structures) Thomas Noll Lehrstuhl für Informatik 2 (Software Modeling and Verification) noll@cs.rwth-aachen.de http://moves.rwth-aachen.de/teaching/ss-14/cc14/

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages CSE 307: Principles of Programming Languages Variables and Constants R. Sekar 1 / 22 Topics 2 / 22 Variables and Constants Variables are stored in memory, whereas constants need not be. Value of variables

More information

CS 345. Garbage Collection. Vitaly Shmatikov. slide 1

CS 345. Garbage Collection. Vitaly Shmatikov. slide 1 CS 345 Garbage Collection Vitaly Shmatikov slide 1 Major Areas of Memory Static area Fixed size, fixed content, allocated at compile time Run-time stack Variable size, variable content (activation records)

More information

Run-Time Environments/Garbage Collection

Run-Time Environments/Garbage Collection Run-Time Environments/Garbage Collection Department of Computer Science, Faculty of ICT January 5, 2014 Introduction Compilers need to be aware of the run-time environment in which their compiled programs

More information

G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University

G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing

More information

CS558 Programming Languages. Winter 2013 Lecture 3

CS558 Programming Languages. Winter 2013 Lecture 3 CS558 Programming Languages Winter 2013 Lecture 3 1 NAMES AND BINDING One essential part of being a high-level language is having convenient names for things: variables constants types functions etc. classes

More information

Run-time Environments - 2

Run-time Environments - 2 Run-time Environments - 2 Y.N. Srikant Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Principles of Compiler Design Outline of the Lecture n What is run-time

More information

Run-time Environments -Part 3

Run-time Environments -Part 3 Run-time Environments -Part 3 Y.N. Srikant Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Compiler Design Outline of the Lecture Part 3 What is run-time support?

More information

Lecture 13: Garbage Collection

Lecture 13: Garbage Collection Lecture 13: Garbage Collection COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer/Mikkel Kringelbach 1 Garbage Collection Every modern programming language allows programmers

More information

Short Notes of CS201

Short Notes of CS201 #includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system

More information

CSC 533: Organization of Programming Languages. Spring 2005

CSC 533: Organization of Programming Languages. Spring 2005 CSC 533: Organization of Programming Languages Spring 2005 Language features and issues variables & bindings data types primitive complex/structured expressions & assignments control structures subprograms

More information

Run Time Environments

Run Time Environments Run Time Environments ALSU Textbook Chapter 7.1 7.3 Tsan-sheng Hsu tshsu@iis.sinica.edu.tw http://www.iis.sinica.edu.tw/~tshsu 1 Preliminaries During the execution of a program, the same name in the source

More information

CS 241 Honors Memory

CS 241 Honors Memory CS 241 Honors Memory Ben Kurtovic Atul Sandur Bhuvan Venkatesh Brian Zhou Kevin Hong University of Illinois Urbana Champaign February 20, 2018 CS 241 Course Staff (UIUC) Memory February 20, 2018 1 / 35

More information

Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004

Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004 Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004 CS 314, LS,BR,LTM: Scope and Memory 1 Review Functions as first-class objects What can you do with an integer?

More information

CS201 - Introduction to Programming Glossary By

CS201 - Introduction to Programming Glossary By CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with

More information

CS 480 Fall Runtime Environments. Mike Lam, Professor. (a.k.a. procedure calls and heap management)

CS 480 Fall Runtime Environments. Mike Lam, Professor. (a.k.a. procedure calls and heap management) CS 480 Fall 2015 Mike Lam, Professor Runtime Environments (a.k.a. procedure calls and heap management) Subprograms General characteristics Single entry point Caller is suspended while subprogram is executing

More information

Names, Bindings, Scopes

Names, Bindings, Scopes Names, Bindings, Scopes Variables In imperative l Language: abstractions of von Neumann machine Variables: abstraction of memory cell or cells Sometimes close to machine (e.g., integers), sometimes not

More information

Heap, Variables, References, and Garbage. CS152. Chris Pollett. Oct. 13, 2008.

Heap, Variables, References, and Garbage. CS152. Chris Pollett. Oct. 13, 2008. Heap, Variables, References, and Garbage. CS152. Chris Pollett. Oct. 13, 2008. Outline. Dynamic Allocation. Variables and Constants. Aliases and Problems. Garbage. Introduction. On Wednesday, we were talking

More information

CS558 Programming Languages. Winter 2013 Lecture 4

CS558 Programming Languages. Winter 2013 Lecture 4 CS558 Programming Languages Winter 2013 Lecture 4 1 PROCEDURES AND FUNCTIONS Procedures have a long history as an essential tool in programming: Low-level view: subroutines give a way to avoid duplicating

More information

Chapter 5. Names, Bindings, and Scopes

Chapter 5. Names, Bindings, and Scopes Chapter 5 Names, Bindings, and Scopes Chapter 5 Topics Introduction Names Variables The Concept of Binding Scope Scope and Lifetime Referencing Environments Named Constants 1-2 Introduction Imperative

More information

CS61C : Machine Structures

CS61C : Machine Structures inst.eecs.berkeley.edu/~cs61c/su06 CS61C : Machine Structures Lecture #6: Memory Management CS 61C L06 Memory Management (1) 2006-07-05 Andy Carle Memory Management (1/2) Variable declaration allocates

More information

1 Lexical Considerations

1 Lexical Considerations Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler

More information

Programming Languages Third Edition. Chapter 9 Control I Expressions and Statements

Programming Languages Third Edition. Chapter 9 Control I Expressions and Statements Programming Languages Third Edition Chapter 9 Control I Expressions and Statements Objectives Understand expressions Understand conditional statements and guards Understand loops and variation on WHILE

More information

LECTURE 18. Control Flow

LECTURE 18. Control Flow LECTURE 18 Control Flow CONTROL FLOW Sequencing: the execution of statements and evaluation of expressions is usually in the order in which they appear in a program text. Selection (or alternation): a

More information

CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11

CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11 CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11 CS 536 Spring 2015 1 Handling Overloaded Declarations Two approaches are popular: 1. Create a single symbol table

More information

Example. program sort; var a : array[0..10] of integer; procedure readarray; : function partition (y, z :integer) :integer; var i, j,x, v :integer; :

Example. program sort; var a : array[0..10] of integer; procedure readarray; : function partition (y, z :integer) :integer; var i, j,x, v :integer; : Runtime Environment Relationship between names and data objects (of target machine) Allocation & de-allocation is managed by run time support package Each execution of a procedure is an activation of the

More information

Advanced Programming & C++ Language

Advanced Programming & C++ Language Advanced Programming & C++ Language ~6~ Introduction to Memory Management Ariel University 2018 Dr. Miri (Kopel) Ben-Nissan Stack & Heap 2 The memory a program uses is typically divided into four different

More information

CIT Week13 Lecture

CIT Week13 Lecture CIT 3136 - Week13 Lecture Runtime Environments During execution, allocation must be maintained by the generated code that is compatible with the scope and lifetime rules of the language. Typically there

More information

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors

More information

System Software Assignment 1 Runtime Support for Procedures

System Software Assignment 1 Runtime Support for Procedures System Software Assignment 1 Runtime Support for Procedures Exercise 1: Nested procedures Some programming languages like Oberon and Pascal support nested procedures. 1. Find a run-time structure for such

More information

IMPORTANT QUESTIONS IN C FOR THE INTERVIEW

IMPORTANT QUESTIONS IN C FOR THE INTERVIEW IMPORTANT QUESTIONS IN C FOR THE INTERVIEW 1. What is a header file? Header file is a simple text file which contains prototypes of all in-built functions, predefined variables and symbolic constants.

More information

! Those values must be stored somewhere! Therefore, variables must somehow be bound. ! How?

! Those values must be stored somewhere! Therefore, variables must somehow be bound. ! How? A Binding Question! Variables are bound (dynamically) to values Subprogram Activation! Those values must be stored somewhere! Therefore, variables must somehow be bound to memory locations! How? Function

More information

The basic operations defined on a symbol table include: free to remove all entries and free the storage of a symbol table

The basic operations defined on a symbol table include: free to remove all entries and free the storage of a symbol table SYMBOL TABLE: A symbol table is a data structure used by a language translator such as a compiler or interpreter, where each identifier in a program's source code is associated with information relating

More information

Memory Allocation. Static Allocation. Dynamic Allocation. Dynamic Storage Allocation. CS 414: Operating Systems Spring 2008

Memory Allocation. Static Allocation. Dynamic Allocation. Dynamic Storage Allocation. CS 414: Operating Systems Spring 2008 Dynamic Storage Allocation CS 44: Operating Systems Spring 2 Memory Allocation Static Allocation (fixed in size) Sometimes we create data structures that are fixed and don t need to grow or shrink. Dynamic

More information

Types and Type Inference

Types and Type Inference CS 242 2012 Types and Type Inference Notes modified from John Mitchell and Kathleen Fisher Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on Web!! Outline General discussion of

More information

Advances in Programming Languages: Regions

Advances in Programming Languages: Regions Advances in Programming Languages: Regions Allan Clark and Stephen Gilmore The University of Edinburgh February 22, 2007 Introduction The design decision that memory will be managed on a per-language basis

More information

Lexical Considerations

Lexical Considerations Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler

More information

Garbage Collection. Akim D le, Etienne Renault, Roland Levillain. May 15, CCMP2 Garbage Collection May 15, / 35

Garbage Collection. Akim D le, Etienne Renault, Roland Levillain. May 15, CCMP2 Garbage Collection May 15, / 35 Garbage Collection Akim Demaille, Etienne Renault, Roland Levillain May 15, 2017 CCMP2 Garbage Collection May 15, 2017 1 / 35 Table of contents 1 Motivations and Definitions 2 Reference Counting Garbage

More information

The role of semantic analysis in a compiler

The role of semantic analysis in a compiler Semantic Analysis Outline The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors

More information

Project. there are a couple of 3 person teams. a new drop with new type checking is coming. regroup or see me or forever hold your peace

Project. there are a couple of 3 person teams. a new drop with new type checking is coming. regroup or see me or forever hold your peace Project there are a couple of 3 person teams regroup or see me or forever hold your peace a new drop with new type checking is coming using it is optional 1 Compiler Architecture source code Now we jump

More information

Automatic Garbage Collection

Automatic Garbage Collection Automatic Garbage Collection Announcements: PS6 due Monday 12/6 at 11:59PM Final exam on Thursday 12/16 o PS6 tournament and review session that week Garbage In OCaml programs (and in most other programming

More information

COP4020 Programming Languages. Subroutines and Parameter Passing Prof. Robert van Engelen

COP4020 Programming Languages. Subroutines and Parameter Passing Prof. Robert van Engelen COP4020 Programming Languages Subroutines and Parameter Passing Prof. Robert van Engelen Overview Parameter passing modes Subroutine closures as parameters Special-purpose parameters Function returns COP4020

More information

A.Arpaci-Dusseau. Mapping from logical address space to physical address space. CS 537:Operating Systems lecture12.fm.2

A.Arpaci-Dusseau. Mapping from logical address space to physical address space. CS 537:Operating Systems lecture12.fm.2 UNIVERSITY of WISCONSIN-MADISON Computer Sciences Department CS 537 A. Arpaci-Dusseau Intro to Operating Systems Spring 2000 Dynamic Memory Allocation Questions answered in these notes When is a stack

More information

Memory Management and Run-Time Systems

Memory Management and Run-Time Systems TDDD55 Compilers and Interpreters TDDB44 Compiler Construction Memory Management and Run-Time Systems Part of the Attribute Grammar Material Presented at the Beginning of this Lecture Peter Fritzson IDA,

More information

Attributes of Variable. Lecture 13: Run-Time Storage Management. Lifetime. Value & Location

Attributes of Variable. Lecture 13: Run-Time Storage Management. Lifetime. Value & Location Attributes of Variable Lecture 13 Run-Time Storage Management CSC 131 Kim Bruce Scope Lifetime Location Value Done! Lifetime Value & Location FORTRAN - all allocated statically - Stack-based (C/C++/Java/Pascal/...)

More information

Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes,

Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes, Chapter 5 Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes, and the Environment Variables

More information

Garbage Collection. Lecture Compilers SS Dr.-Ing. Ina Schaefer. Software Technology Group TU Kaiserslautern. Ina Schaefer Garbage Collection 1

Garbage Collection. Lecture Compilers SS Dr.-Ing. Ina Schaefer. Software Technology Group TU Kaiserslautern. Ina Schaefer Garbage Collection 1 Garbage Collection Lecture Compilers SS 2009 Dr.-Ing. Ina Schaefer Software Technology Group TU Kaiserslautern Ina Schaefer Garbage Collection 1 Content of Lecture 1. Introduction: Overview and Motivation

More information

Chapter 8 :: Composite Types

Chapter 8 :: Composite Types Chapter 8 :: Composite Types Programming Language Pragmatics, Fourth Edition Michael L. Scott Copyright 2016 Elsevier 1 Chapter08_Composite_Types_4e - Tue November 21, 2017 Records (Structures) and Variants

More information

CPSC 3740 Programming Languages University of Lethbridge. Data Types

CPSC 3740 Programming Languages University of Lethbridge. Data Types Data Types A data type defines a collection of data values and a set of predefined operations on those values Some languages allow user to define additional types Useful for error detection through type

More information

Procedures and Run-Time Storage

Procedures and Run-Time Storage Procedures and Run-Time Storage Compiler Design CSE 504 1 Parameterless Procedures 2 Parameter Passing 3 Storage Organization Last modifled: Mon Mar 21 2016 at 12:11:19 EDT Version: 1.3 20:58:09 2012/04/09

More information

Lecture Notes on Garbage Collection

Lecture Notes on Garbage Collection Lecture Notes on Garbage Collection 15-411: Compiler Design Frank Pfenning Lecture 21 November 4, 2014 These brief notes only contain a short overview, a few pointers to the literature with detailed descriptions,

More information

Control Abstraction. Hwansoo Han

Control Abstraction. Hwansoo Han Control Abstraction Hwansoo Han Review of Static Allocation Static allocation strategies Code Global variables Own variables (live within an encapsulation - static in C) Explicit constants (including strings,

More information

Informatica 3 Marcello Restelli

Informatica 3 Marcello Restelli Informatica 3 Marcello Restelli 9/15/07 Laurea in Ingegneria Informatica Politecnico di Milano Operational Semantics We describe the semantics of a programming language by means of an abstract semantic

More information

Procedure and Function Calls, Part II. Comp 412 COMP 412 FALL Chapter 6 in EaC2e. target code. source code Front End Optimizer Back End

Procedure and Function Calls, Part II. Comp 412 COMP 412 FALL Chapter 6 in EaC2e. target code. source code Front End Optimizer Back End COMP 412 FALL 2017 Procedure and Function Calls, Part II Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2017, Keith D. Cooper & Linda Torczon, all rights reserved. Students

More information

Review of the C Programming Language

Review of the C Programming Language Review of the C Programming Language Prof. James L. Frankel Harvard University Version of 11:55 AM 22-Apr-2018 Copyright 2018, 2016, 2015 James L. Frankel. All rights reserved. Reference Manual for the

More information

Garbage Collection (1)

Garbage Collection (1) Garbage Collection (1) Advanced Operating Systems Lecture 7 This work is licensed under the Creative Commons Attribution-NoDerivatives 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nd/4.0/

More information

Storage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage

Storage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage Storage 1 Variables and Updating Outline Composite Variables Total and selective updating Array variables Storables Lifetime Local and global variables Heap variables Persistent variables Garbage collection

More information

Control in Sequential Languages

Control in Sequential Languages CS 242 2012 Control in Sequential Languages Reading: Chapter 8, Sections 8.1 8.3 (only) Section 7.3 of The Haskell 98 Report, Exception Handling in the I/O Monad, http://www.haskell.org/onlinelibrary/io-13.html

More information

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

COP4020 Programming Languages. Names, Scopes, and Bindings Prof. Robert van Engelen COP4020 Programming Languages Names, Scopes, and Bindings Prof. Robert van Engelen Overview Abstractions and names Binding time Object lifetime Object storage management Static allocation Stack allocation

More information

Performance of Non-Moving Garbage Collectors. Hans-J. Boehm HP Labs

Performance of Non-Moving Garbage Collectors. Hans-J. Boehm HP Labs Performance of Non-Moving Garbage Collectors Hans-J. Boehm HP Labs Why Use (Tracing) Garbage Collection to Reclaim Program Memory? Increasingly common Java, C#, Scheme, Python, ML,... gcc, w3m, emacs,

More information

Storage. Outline. Variables and updating. Copy vs. Ref semantics Lifetime. Dangling References Garbage collection

Storage. Outline. Variables and updating. Copy vs. Ref semantics Lifetime. Dangling References Garbage collection Storage 1 Variables and updating Outline Copy vs. Ref semantics Lifetime Local and global variables Heap variables Persistent variables Dangling References Garbage collection 2 Variables and Updating Variable:

More information

Procedures and Run-Time Storage

Procedures and Run-Time Storage Procedures and Run-Time Storage Compiler Design CSE 504 1 Parameterless Procedures 2 Parameter Passing 3 Storage Organization Last modifled: Mon Mar 21 2016 at 12:11:19 EDT Version: 1.3 20:58:09 2012/04/09

More information

SE352b: Roadmap. SE352b Software Engineering Design Tools. W3: Programming Paradigms

SE352b: Roadmap. SE352b Software Engineering Design Tools. W3: Programming Paradigms SE352b Software Engineering Design Tools W3: Programming Paradigms Feb. 3, 2005 SE352b, ECE,UWO, Hamada Ghenniwa SE352b: Roadmap CASE Tools: Introduction System Programming Tools Programming Paradigms

More information

In Java we have the keyword null, which is the value of an uninitialized reference type

In Java we have the keyword null, which is the value of an uninitialized reference type + More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are

More information

Sustainable Memory Use Allocation & (Implicit) Deallocation (mostly in Java)

Sustainable Memory Use Allocation & (Implicit) Deallocation (mostly in Java) COMP 412 FALL 2017 Sustainable Memory Use Allocation & (Implicit) Deallocation (mostly in Java) Copyright 2017, Keith D. Cooper & Zoran Budimlić, all rights reserved. Students enrolled in Comp 412 at Rice

More information

Acknowledgements These slides are based on Kathryn McKinley s slides on garbage collection as well as E Christopher Lewis s slides

Acknowledgements These slides are based on Kathryn McKinley s slides on garbage collection as well as E Christopher Lewis s slides Garbage Collection Last time Compiling Object-Oriented Languages Today Motivation behind garbage collection Garbage collection basics Garbage collection performance Specific example of using GC in C++

More information