CSE 452 Programming Languages Subprograms Outline u Subprograms

CSE 452: Programming Languages Subprograms

Outline u Subprograms l Parameter passing l Type checking l Using multidimensional arrays as parameters l Using subprograms as parameters l Overloaded subprograms l Generic subprograms l Implementation Organization of Programming Languages-Cheng (Fall 2004) 2

Parameter Passing u Pass-by-value u Pass-by-result u Pass-by-value-result u Pass-by-reference u Pass-by-name Organization of Programming Languages-Cheng (Fall 2004) 3

Parameter Passing in PL u u Fortran l Always use inout-model of parameter passing l Before Fortran 77, mostly used pass-by-reference l Later implementations mostly use pass-by-value-result C l mostly pass by value l Pass-by-reference is achieved using pointers as parameters int *p = { 1, 2, 3 }; void change( int *q) { q[0] = 4; } main() { change(p); /* calling the change function */ } Organization of Programming Languages-Cheng (Fall 2004) p[0] = 4 after 4

Parameter Passing in PL u C l Pass-by reference: value of pointer is copied to the called function and nothing is copied back #include <stdio. h> void swap (int *p, int *q) { int *temp; temp = p; p = q; q = temp; } main() { int p[] = {1, 2, 3}; int q[] = {4, 5, 6}; int i; swap (p, q); } Organization of Programming Languages-Cheng (Fall 2004) 5

Parameter Passing in PL u C++ l includes a special pointer type called a reference type void Get. Data(double &Num 1, const int &Num 2) { int temp; for (int i=0; i<Num 2; i++) { cout << “Enter a number: “; cin >> temp; if (temp > Num 1) { Num 1 = temp; return; } } l l Num 1 and Num 2 are passed by reference const modifier prevents a function from changing the values of reference parameters Referenced parameters are implicitly dereferenced Why do we need a constant reference parameter? Organization of Programming Languages-Cheng (Fall 2004) 6

Parameter Passing in PL u Ada l Reserved words: in, out, in out (in is the default mode) procedure temp(A : in out Integer; B : in Integer; C : in Integer ) out mode can be assigned but not referenced l in mode can be referenced but not assigned l in out can be both referenced and assigned Fortran l Semantic modes are declared using Intent attribute l u Subroutine temp(A, B, C) Integer, Intent(Inout) : : A Integer, Intent(In) : : B Integer, Intent(Out) : : C Organization of Programming Languages-Cheng (Fall 2004) 7

Parameter Passing in PL u Perl l Actual parameters are implicitly placed in a predefined array named @_ sub foo { local $i, $a=0, $b = 1; for ($i=0; $i<scalar(@_); $i++) { $a = $a + $_[$i]; $b = $b * $_[$i]; } return ($a, $b); } … ($a, $b) = foo(1, 2, 3); Organization of Programming Languages-Cheng (Fall 2004) 8

Implementing Parameter Passing Memory contents Code program code Data global and static data Heap Dynamically allocated variables Stack local data Organization of Programming Languages-Cheng (Fall 2004) 10

Implementing Parameter Passing u Pass by Value l Values copied into stack locations l Stack locations serve as storage for corresponding formal parameters u Pass by Result l Implemented opposite of pass-by-value l Values assigned to actual parameters are placed in the stack, where they can be retrieved by calling program unit upon termination of called subprogram Pass by Value Result l Stack location for parameters is initialized by by the call and then copied back to actual parameters upon called subprogram Organizationtermination of Programming of Languages-Cheng (Fall 2004) u 11

Implementing Parameter Passing u Pass by Reference l Regardless of type of parameter, put the address in the stack l For literals, address of literal is put in the stack l For expressions, compiler must build code to evaluate expression before the transfer of control to the called subprogram u l l Address of memory cell in which code places the result of its evaluation is then put in the stack Compiler must make sure to prevent called subprogram from changing parameters that are literals or expressions Access to formal parameters is by indirect addressing from the stack location of the address Organization of Programming Languages-Cheng (Fall 2004) 12

Implementing Parameter Passing val res valres ref sub(w, x, y, z) sub(a, b, c, d) Main program calls sub(w, x, y, z) where w is passed by value, x is passed by result, y is passed by value-result, and z is passed by reference Organization of Programming Languages-Cheng (Fall 2004) 13

Implementing Parameter Passing u Pass by Name l run-time resident code segments or subprograms evaluate the address of the parameter l called for each reference to the formal l Very expensive, compared to pass by reference or value-result Organization of Programming Languages-Cheng (Fall 2004) 14

Multidimensional Arrays as Parameters u C: l l Uses row major order for matrices address(mat[i, j]) = address(mat[0, 0]) + i*num_columns +j Must specify num_columns but not num_rows void fun (int matrix[][10]) { … } void main() { int mat[5][10]; fun(mat); … } l l Does not allow programmers to write function that accepts different number of columns Alternative: use pointers Organization of Programming Languages-Cheng (Fall 2004) 15

Multidimensional Arrays as Parameters u Ada: type Mat_Type is array (Integer range <> Integer range<>) of Float; Mat 1 : Mat_Type(1. . 100, 1. . 20); No need to specify function Sumer(Mat : in Mat_Type) return Flat is size of array Sum : Float : = 0. 0; begin Use range attribute for Row in Mat’range(1) loop to obtain size of for Col in Mat’range(2) loop Sum : = Sum + Mat(Row, Col); arrray end loop; return Sum; end Sumer; Organization of Programming Languages-Cheng (Fall 2004) 16

Multidimensional Arrays as Parameters u Fortran l Array parameters must have declaration after the header Subroutine Sub (Matrix, Rows, Cols, Result) Integer, Intent(In) : : Rows, Cols Real, Dimension(Rows, Cols), Intent(In) : : Matrix Real, Intent (In) : : Result … End Subroutine Sub Organization of Programming Languages-Cheng (Fall 2004) 17

Subprogram Names as Parameters u Issues: 1. Are parameter types checked? u u 2. Early Pascal and FORTRAN 77 do not; later versions of Pascal and FORTRAN 90 do Ada does not allow subprogram parameters Java does not allow method names to be passed as parameters C and C++ - pass pointers to functions; parameters can be type checked What is the correct referencing environment for a subprogram that was sent as a parameter? u Environment of the call statement that enacts the passed subprogram l u Environment of the definition of the passed subprogram l u Shallow binding Deep binding Environment of the call statement that passed the subprogram as actual parameter l Ad hoc binding (Has never been used) Organization of Programming Languages-Cheng (Fall 2004) 18

Subprogram Names as Parameters function sub 1() { var x; function sub 2() { alert(x); }; function sub 3() { var x; x = 3; sub 4(sub 2); } function sub 4(subx) { var x; x = 4; subx(); }; x = 1; sub 3(); }; Shallow binding: l Referencing environment of sub 2 is that of sub 4 Deep binding l Referencing environment of sub 2 is that of sub 1 Ad-hoc binding l Referencing environment of sub 2 is that of sub 3 Organization of Programming Languages-Cheng (Fall 2004) 19

Overloaded Subprograms u u A subprogram that has the same name as another subprogram in the same referencing environment Every version of the overloaded subprogram must have a unique protocol l Must be different from others in the number, order, or types of its parameters, or its return type (if it is a function) C++, Java, Ada, and C# include predefined overloaded subprograms – e. g. , overloaded constructors in C++ Overloaded subprograms with default parameters can lead to ambiguous subprogram calls void foo( float b = 0. 0 ); void foo(); … foo(); /* call is ambiguous; may lead to compilation error */ Organization of Programming Languages-Cheng (Fall 2004) 20

Generic (Polymorphic) Subprograms u Polymorphism: l Increase reusability of software l Types: u Ad hoc polymorphism = Overloaded subprogram u Parametric polymorphism l l Provided by a subprogram that takes a generic parameter that is used in a type expression Ada and C++ provide compile-time parametric polymorphism Organization of Programming Languages-Cheng (Fall 2004) 21

Generic Subprograms generic type Index_Type is (<>); type Element_Type is private; type Vector is array (Integer range <>) of Element_Type; procedure Generic_Sort(List : in out Vector) is Temp : Element_Type; begin for Top in List'First. . Index_Type’Pred(List’Last) loop for Bottom in Index_Type’Succ(Top). . List’Last loop if List(Top) > List(Bottom) then Temp : = List (Top); List(Top) : = List(Bottom); List(Bottom) : = Temp; end if; end loop; -- for Bottom. . . end loop; -- for Top. . . end Generic_Sort; Organization of Programming Languages-Cheng (Fall 2004) Example: procedure Integer_Sort is new Generic_Sort( Index_Type => Integer; Element_Type => Integer; Vector => Int_Array); 22

Generic Subprograms template <class Type> void generic_sort(Type list[], int len) { int top, bottom; Type temp; for (top = 0; top < len - 2; top++) for (bottom = top + 1; bottom < len - 1; bottom++) { if (list[top] > list[bottom]) { temp = list [top]; list[top] = list[bottom]; list[bottom] = temp; } //** end of for (bottom. . . } //** end of generic_sort float flt_list[100]; . . . generic_sort(flt_list, 100); // Implicit instantiation Organization of Programming Languages-Cheng (Fall 2004) 23

Implementing Subprograms u The subprogram call and return operations are together called subprogram linkage u Implementation of subprograms must be based on semantics of subprogram linkage u Implementation: l Simple u no subprograms recursion, use only static local variables l Subprograms with stack-dynamic variables l Nested subprograms Organization of Programming Languages-Cheng (Fall 2004) 24

Simple Subprograms u u u Simple l subprograms are not nested and all local variables are static l Example: early versions of Fortran Call Semantics require the following actions: l Save execution status of current program unit l Carry out parameter passing process l Pass return address to the callee l Transfer control to the callee Return Semantics require the following actions: l If pass by value-result or out-mode, move values of those parameters to the corresponding actual parameters l If subprogram is a function, move return value of function to a place accessible to the caller l Restore execution status of caller l Transfer control back to caller Organization of Programming Languages-Cheng (Fall 2004) 25

Simple Subprograms u u Required Storage: l Status information of the caller l Parameters l return address l functional value (if it is a function) Subprogram consists of 2 parts: l Subprogram code l Subprogram data The format, or layout, of the noncode part of an executing subprogram is called an activation record u An activation record instance (ARI) is a concrete example of an activation record (the collection of data for a particular subprogram activation) u Organization of Programming Languages-Cheng (Fall 2004) 26

v Code and Activation record of a program with simple subprograms v. Activation record instance for simple subprograms has fixed size. Therefore, it can be statically allocated v. Since simple subprograms do not support recursion, there can be only one active version of a given subprogram

Subprograms with Stack-Dynamic Variables u Compiler must generate code to cause implicit allocation and deallocation of local variables Run-time stack Top of the stack Local variables Activation record instance Parameters Dynamic link Return address Pointer to code segment of the caller and an offset address of the instruction following the call Organization of Programming Languages-Cheng (Fall 2004) Points to top of activation record instance of caller 28

Subprograms with Stack-Dynamic Variables void sub(float total, int part) { int list[4]; float sum; … } Local variable sum Local variable list[3] Local variable list[2] Local variable list[1] Local variable list[0] Parameter part Parameter total Dynamic link Return address Organization of Programming Languages-Cheng (Fall 2004) 29

Example: without Recursion void A(int X) { int Y; 2 … C(Y); } void B(float R) { int S, T; … 1 A(S); … } void C(int Q) { … 3 } void main() { float P; … B(P); … Collection of dynamic links present in the stack } any given time is called the dynamic chain Organization of Programming Languages-Cheng (Fall 2004) at 30

Subprograms with Stack-Dynamic Variables u Recursion adds possibility of multiple simultaneous activations of a subprogram l Each activation requires its own copy of formal parameters and dynamically allocated local variables, along with return address Organization of Programming Languages-Cheng (Fall 2004) 31

Subprograms with Recursion int factorial (int n) { … if (n <= 1) return 1; else return n*factorial(n-1); … } void main() { int value; value = factorial(3); … } Organization of Programming Languages-Cheng (Fall 2004) 32

Subprograms with Recursion int factorial (int n) { … if (n <= 1) return 1; else return n*factorial(n-1); … } void main() { int value; value = factorial(3); … } Organization of Programming Languages-Cheng (Fall 2004) 33

Subprograms with Recursion int factorial (int n) { … if (n <= 1) return 1; else return n*factorial(n-1); … } void main() { int value; value = factorial(3); … } Organization of Programming Languages-Cheng (Fall 2004) 34

Subprograms with Recursion int factorial (int n) { 1 … if (n <= 1) return 1; else return n*factorial(n-1); … 2 } void main() { int value; value = factorial(3); … 3 } Organization of Programming Languages-Cheng (Fall 2004) 35

Subprograms with Recursion int factorial (int n) { 1 … if (n <= 1) return 1; else return n*factorial(n-1); … 2 } void main() { int value; value = factorial(3); … 3 } Organization of Programming Languages-Cheng (Fall 2004) 36

Subprograms with Recursion int factorial (int n) { 1 … if (n <= 1) return 1; else return n*factorial(n-1); … 2 } void main() { int value; value = factorial(3); … 3 } Organization of Programming Languages-Cheng (Fall 2004) 37

Subprograms with Recursion int factorial (int n) { 1 … if (n <= 1) return 1; else return n*factorial(n-1); … 2 } void main() { int value; value = factorial(3); … 3 } Organization of Programming Languages-Cheng (Fall 2004) 38

Nested Subprograms u Support for static scoping l Implemented using static link (also called static scope pointer), which points to the bottom of the activation record instance of its static parent Organization of Programming Languages-Cheng (Fall 2004) 39

Nested Subprograms u u u Static chain: l links all static ancestors of executing subprogram Static_depth l an integer associated with static scope that indicates how deeply it is nested in outermost scope Chain offset l Difference between static_depth of procedure containing reference to variable x and static_depth of procedure containing declaration of x procedure A is procedure B is procedure C is … end; -- of C … end; -- of B … end; -- of A v. Static_depths of A, B, and C are 0, 1, and 2, respectively v. If procedure C references a variable declared in A, the chain_offset of that reference is 2 Organization of Programming Languages-Cheng (Fall 2004) 40

Nested Subprograms program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB 1; var A, D : integer; begin { SUB 1 } A : = B + C; <---------1 end; { SUB 1 } procedure SUB 2(X : integer); var B, E : integer; procedure SUB 3; var C, E : integer; begin { SUB 3 } SUB 1; E : = B + A: <-------2 end; { SUB 3 } begin { SUB 2 } SUB 3; A : = D + E; <--------3 end; { SUB 2 } begin { BIGSUB } SUB 2(7); end; { BIGSUB } begin BIGSUB; end. { MAIN_2 } Organization of Programming Languages-Cheng (Fall 2004) Calling sequence: Main_2 calls BIGSUB calls Sub 2 calls Sub 3 calls Sub 1 41

Example program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB 1; var A, D : integer; begin { SUB 1 } A : = B + C; <---------1 end; { SUB 1 } procedure SUB 2(X : integer); var B, E : integer; procedure SUB 3; var C, E : integer; begin { SUB 3 } SUB 1; E : = B + A: <-------2 end; { SUB 3 } begin { SUB 2 } SUB 3; A : = D + E; <--------3 end; { SUB 2 } begin { BIGSUB } SUB 2(7); end; { BIGSUB } begin References to A: BIGSUB; 1: (0, 3) (local) end. { MAIN_2 } 2: (2, 3) (two levels away) 3: (1, 3) (one level away)

Nested Subprograms u At position 1 in SUB 1: l A - (0, 3) ======> (chain_offset, local_offset) l B - (1, 4) l C - (1, 5) u At position 2 in SUB 3: l E - (0, 4) l B - (1, 4) l A - (2, 3) u At position 3 in SUB 2: l A - (1, 3) l D - an error l E - (0, 5) ==== ARI for sub 1 has been removed Organization of Programming Languages-Cheng (Fall 2004) 43

Nested Subprograms u u Drawbacks l A nonlocal reference is slow if the number of scopes between the reference and the declaration of the referenced variable is large l Time-critical code is difficult, because the costs of nonlocal references are hard to estimate Displays l Alternative to static chains l Store static links in a single array called display, instead of storing in the activation records l Accesses to nonlocals require exactly two steps for every access, regardless of the number of scope levels Link to correct activation record is found using a statically computed value called the display_offset u Compute local_offset within activation record instance u Organization of Programming Languages-Cheng (Fall 2004) 44

Buffer overflow attack u The effectiveness of the buffer overflow attack has been common knowledge in software circles since the 1980’s u The Internet Worm used it in November 1988 to gain unauthorized access to many networks and systems nationwide u Still used today by hacking tools to gain “root” access to otherwise protected computers u The fix is a very simple change in the way we write array accesses; unfortunately, once code that has this vulnerability is deployed in the field, it is nearly impossible to stop a buffer overflow attack Organization of Programming Languages-Cheng (Fall 2004) 49

Overview of Buffer Overflow Attacks The buffer overflow attack exploits a common problem in many programs. u In several high-level programming languages such as C, “boundary checking”, i. e. checking to see if the length of a variable you are copying is what you were expecting, is not done. u void main(){ char buffer. A[256]; void my. Function(char *str) { char buffer. B[16]; my. Function(buffer. A); } strcpy(buffer. B, str); } Organization of Programming Languages-Cheng (Fall 2004) 50

Overview of Buffer Overflow Attacks void main(){ char buffer. A[256]; void my. Function(char *str) { char buffer. B[16]; my. Function(buffer. A); } strcpy(buffer. B, str); } § main() passes a 256 byte array to my. Function(), and my. Function() copies it into a 16 byte array! § Since there is no check on whether buffer. B is big enough, the extra data overwrites other unknown space in memory. § This vulnerability is the basis of buffer overflow attacks § How is it used to harm a system? Ø It modifies the system stack Organization of Programming Languages-Cheng (Fall 2004) 51

Overview of Buffer Overflow Attacks Stack content void main(){ char buffer. A[256]; my. Function(buffer. A); } buffer. A Organization of Programming Languages-Cheng (Fall 2004) 52

Overview of Buffer Overflow Attacks Stack content void main(){ buffer. B char buffer. A[256]; my. Function(buffer. A); OS data } Str void my. Function(char *str) { Dynamic link char buffer. B[16]; strcpy(buffer. B, str); Return Address to Main } buffer. A Organization of Programming Languages-Cheng (Fall 2004) 53

Overview of Buffer Overflow Attacks Stack content void main(){ buffer. B char buffer. A[256]; my. Function(buffer. A); OS data } Str void my. Function(char *str) { Dynamic link char buffer. B[16]; strcpy(buffer. B, str); This region is now contaminated with data from str Return Address to Main } buffer. A May overwrite the return address!! Organization of Programming Languages-Cheng (Fall 2004) 54

Overview of Buffer Overflow Attacks n n If the content of str is carefully selected, we can point the return address to a piece of code we have written When the system returns from the function call, it will begin executing the malicious code Stack content Malicious Code New Address buffer. A Organization of Programming Languages-Cheng (Fall 2004) 55

A Possible Solution void main(){ char buffer. A[256]; my. Function(buffer. A, 256); } void my. Function(char *str, int len) { char buffer. B[16]; if (len <= 16) strcpy(buffer. B, str); } Organization of Programming Languages-Cheng (Fall 2004) 56

Buffer Overflow Attack Organization of Programming Languages-Cheng (Fall 2004) 57