1 lao getting started. 2 plan architecture tests xcc coding rules information to start use cases

1

LAO Getting Started

2

Plan

Architecture Tests XCC Coding Rules Information To Start Use Cases

3

Linear Assembly Optimizer

Gather a set of packages Two possible modes:

Mode LAO: CDT ECL PRO

Mode JIT: CDT ECL

Hierarchy: LAO > Packages > Libraries > Modules

Repository: svn+ssh://stmicro.lipforge.ens-lyon.fr/svnroot/ecc/lao/trunk/LAO

4

LAO Structure LAO

PACK1/ ; A package PACK2/

Makefile ; Package makefile DOC/ ; Documentation LIB1/ ; A library LIB2/

Makefile ; Library makefile 0/ ; Input files for (self-)tests (MyModule.0) (e.g. foo.0) 1/ ; Expected output files for tests (MyModule.1) (e.g. foo.1)

MyTarget1/ ; MyTarget1 specific expected output MyTarget2/

LIB2.xcc ; Global interface of the library Module1 ; (Module1.xcc) (e.g. foo.xcc) Module2 MyTarget1/ ; Contains targeting of modules for MyTarget1 when

needed MyModule.xcc ; One file per module with a targeting (e.g.

foo.xcc) MyTarget2/

5

Packages Properties

GNU like configure automake

6

Available Packages CDT: Compiler Development Tools: Utilities package

BSL: Basic Services Library (memory, etc.) CCL: C Container Library (list, set, etc.) CAL: Combinatorial Algorithm Library (dominator graph, etc.)

ECL: Embedded Compiler Libraries: IR + optimizations AIR: Assembler Intermediate Representation MDS: Target machine description library configured by the MDS LIR: Layered Intermediate Representation PFA: Program Flow Analyses (Liveness, SSA Form) CGO: Code Generator Optimizations JIT: Just-In-Time compiler

PRO: Heavy optimization and Open64 bridge GRA: Register Allocation XFA: Extra Flow Analyses SCD: Scheduling algorithms O64: Open64 interface and LAO compilation driver

7

Makefile – LAO extract: extract CDT, ECL and PRO install: installation (see next slide) clean: Remove built files distclean: Remove built files and files created by configure build: all + install MyTarget: If MyTarget does not exist, it tries to parse a file

named MyTarget.def and launch make build with that definition

Note: LAO builds directly in the sources Note: To do an optimized compiler: make speed (cf. speed.def) Note: To do a development compiler: make debug (cf.

debug.def)

8

Makefile – LAO install: Create the following structure export/

lib/ ; For Open64 lao.so

include/ ; For Open64 MyTarget1/

lao_....h ; Should not diff with files under Open64 svn MyTarget2/

lao_....h

include/ ; include file to use LAO as a library bin/ lib/ share/

doc/ ; Documentation of LAO (extracted from xcc files)

9

Makefile – Package

all: Build all libraries check: Build and run self tests clean: Remove built files install: Copy libraries at a defined

prefix

10

Makefile - Library

all: Launch xccgen on all xcc files clean: Remove built files check: Build and run self tests refs: Update references. I.e. move

generated output file into 1/ directory again: Check that used libraries are up-

to-date. E.g. make clean again check This is configure process of LAO which

create the makefile

11

Tests & Self Tests

12

Tests

Embedded directly in .xcc (//@XCC_.c) Test locally a module Tests process (make check)

xccgen tool extracts the tests code in a file host compiler compile the test file host execute test file with input file comparison is done between output and expected output status (fail or pass) is printed

To sum up: xccgen MyModule.xcc # extract a test file: MyModule_.c gcc MyModule_.c -o MyModule.tst # produce executable

(simplified command) MyModule.tst < 0/MyModule.0 > MyModule.1 # execution (diff MyModule.1 1/MyModule.1 && echo PASS) || echo FAIL

# status

13

Self Tests Used to ensure that a modification in LAO will not

break its integration in Open64 Create a LAO IR and call some optimizations on it Output must be conformed to what it is kept in svn

Structure: Working Copy/

LAO/ CDT/ ; Created by make extract ECL/ ; Idem PRO/ ; Idem Makefile

LAO_INPUT/ ; In svn, contains all the sources of the self tests LAO_TRACE/ ; Created by hand. This directory will contain the

traces of the self tests. It also contains the optimization to be passed (cf. next slides)

14

Self Tests – Makefile Self Tests are available for PRO module only

refs: Move generated output into related references directories

tests: Build and run all self tests Use makefile variables to specify:

Input directory: LAO_INPUT (default ../../LAO_INPUT) Trace directory: LAO_TRACE (default ../../LAO_TRACE).

Use LAO options overrideable both by: Environment variables Created files named MyOption=MyValue in directory specified by

LAO_TRACE inputs: Create input files from input.c files

(compilation) traces: Create trace files from input files (execution)

15

Self Tests – Remarks Three classes of optimizations:

Register allocation Scheduling Other

All the input tests have not a call to the three classes of optimization. For instance, the allocation phase is not always available

Overrideable options for LAO optimizations are listed in: ECL/LIR/Configure.xcc ECL/LIR/Optimize.xcc ... E.g.: FORCE_SCHEDULING=MyMask,

LIR_TRACE=MyFileDescriptor

You can directly do: ‘make foo.trace’, the condition is: a foo.input.c file must exist

16

XCC

17

Files

XCC: eXtra C Comment One xcc file = one module Merge of

Interface Implementation Test Documentation (see

share/doc/CDT/WLMDoc.html after make install)

18

Commands Embedded in C command Start with @

/*@cmd */ //@cmd

Two kind of commands Dispatcher “Structure helper”

Dispatcher command XCCMyExtension Extract next paragraph in MyModuleMyExtension A paragraph is a sequence of text which stops at \n\n no dispatch imply .c for a paragraph

Structure helper: Valid only in between the two braces of a C struct code

19

Processing – Dispatching

.xcc

Preprocessing: xccgen .c

dispatch

Implementation

Public Interface

Test

Documentation

Private Interface_.h

.h

_.c

.wlm

20

Processing – C Structure Generate several typedef (assume struct

MyStruct_): MyStruct_: Define the type for the structure MyStruct: Define the type of a pointer to the

structure const_MyStruct: Define the type of a pointer to

the constant structure Generate getter and setter for all structure

fields using macro. E.g. int FIELD: Getter: MyStruct_FIELD(this) ((this)->FIELD) Setter: MyStruct__FIELD(this) (&(this)->FIELD)

Process structure helper and generate related code

21

Structure Helper args MyArgs: Specify additional arguments to be set on generated

constructor and size function for the structure by xccgen ctor MyContribution: Add MyContribution code to the constructor

function of the structure. All the contributions set with that command are emitted from top to bottom in the constructor (MyStruct_Ctor(this + @args)).

dtor MyContribution: Add MyContribution code to the destructor function of the structure. All the contributions set with that command are emitted from top to bottom in the constructor (MyStruct_Dtor(this)).

size MyContribution: Add MyContribution code to function used to get the size of the structure. This size will be used by operation like malloc (MyStruct_Size(@args))

copy MyContribution: Contribution for the function to copy that structure (MyStruct_Copy(this, const that)).

decl MyContribution: Contribution to do forward declaration. E.g. to emit declaration of utility functions used by the constructor.

access MyField MyCode: Define getter code. Allow to create virtual fields or override default xccgen generation. (Produce #define MyStruct_MyField(this) MyCode).

mutate MyField MyCode: Define setter code. Allow to create virtual fields or override default xccgen generation. (Produce #define MyStruct__MyField(this) MyCode).

22

XCCGEN Common Error

Dispatching: /*@XCC.h*/ => MyModule.h*/ // ERROR //@XCC.h => MyModule.h // OK /*@XCC.h */ => MyModule.h // OK

Paragraph//@XCC.hstruct MyStruct {int32_t FIELD1;

int32_t FIELD2;

}; // => End of the paragraph in the structure: end of the structure dispatched in .c file Compilation error

23

Example (1) – foo.xcc//@XCC_.hstruct MyStruct_ { //@args Memory memory, CodeRegion codeRegion //@ctor TemporaryTable globalTable = //@ctor CodeRegion_globalTable(codeRegion); //@ctor Procedure procedure = //@ctor CodeRegion_procedure(codeRegion); //@ctor Temporary_ *dedicated = //@ctor Procedure_dedicated(procedure); Memory MEMORY; //@ctor *MyStruct__MEMORY(this) = memory; //@access VIRTUALFIELD MyStruct_MEMORY(this)+12 //@decl void MyStruct_ctor_(MyStruct this, //@decl Temporary_ *dedicated, bool doIt); //@ctor MyStruct_ctor_(this, dedicated, true); //@size sizeof(MyStruct_)};

24

Example (2)

//@XCC_.h

struct MyStruct_ { typedef struct MyStruct_ MyStruct_, *MyStruct;typedef const struct MyStruct_ *const_MyStruct;

//@args Memory memory, CodeRegion codeRegion

//@ctor TemporaryTable globalTable =

• First contribution to constructor• Generate prototype with arguments specified by @args

MyStructMyStruct_Ctor(MyStruct this, Memory memory, CodeRegion codeRegion) {// Add the contributionTemporaryTable globalTable =

• Specify additional arguments of constructor and size functions

• Next paragraph will be dispatched in foo_.h

25

Example (3)

//@ctor CodeRegion_globalTable(codeRegion);//@ctor Procedure procedure =//@ctor CodeRegion_procedure(codeRegion);//@ctor Temporary_ *dedicated =//@ctor Procedure_dedicated(procedure);

• New contributions to constructor CodeRegion_globalTable(codeRegion);Procedure procedure = CodeRegion_procedure(codeRegion);Temporary_ *dedicated = Procedure_dedicated(procedure);

Memory MEMORY • Field detection• Emit field in the structure

Memory MEMORY;• Emit getter/setter

#define MyStruct_MEMORY(this) ((this)->MEMORY)#define MyStruct__MEMORY(this) (&(this)->MEMORY)

//@ctor *MyStruct__MEMORY(this) = memory;• New contribution to constructor*MyStruct__MEMORY(this) = memory;

26

Example (4)//@access VIRTUALFIELD MyStruct_MEMORY(this)+12

• Definition of a getter on a virtual field#define MyStruct_VIRTUALFIELD(this) MyStruct_MEMORY(this)+12

//@decl void MyStruct_ctor_(MyStruct this,//@decl Temporary_ *dedicated, bool doIt);

• Contributions to declarationsvoid MyStruct_ctor_(MyStruct this,

Temporary_ *dedicated, bool doIt);

//@size sizeof(MyStruct_)• Contribution to size function• Generate prototype with arguments specified by @argssize_tMyStruct_Size(Memory memory, CodeRegion codeRegion) { return sizeof(MyStruct_) // My contribution

////@ctor MyStruct_ctor_(this, dedicated, true);

• New contribution to constructorMyStruct_ctor_(this, dedicated, true);

27

Example (5)

}; • End of the structure• Emit in foo_.h file with that order:

• Structure definition• Macros• Declarations• Generated functions

28

Example (6)

Final result without comments

struct MyStruct_ { Memory MEMORY;};typedef struct MyStruct_ MyStruct_, *MyStruct;typedef const struct MyStruct_ *const_MyStruct;

#define MyStruct_MEMORY(this) ((this)->MEMORY)#define MyStruct__MEMORY(this) (&(this)->MEMORY)#define MyStruct_VIRTUALFIELD(this) MyStruct_MEMORY(this)+12

void MyStruct_ctor_(MyStruct this, Temporary_ *dedicated, bool doIt);

MyStructMyStruct_Ctor(MyStruct this, Memory memory, CodeRegion codeRegion) { TemporaryTable globalTable =

CodeRegion_globalTable(codeRegion); Procedure procedure =

CodeRegion_procedure(codeRegion); Temporary_ *dedicated =

Procedure_dedicated(procedure); *MyStruct__MEMORY(this) = memory; MyStruct_ctor_(this, dedicated, true); return this;}

size_tMyStruct_Size(Memory memory, CodeRegion codeRegion) { return sizeof(MyStruct_) ;}

29

Coding Rules

30

“Enhanced” C89 Write “enhanced” C89

Mix declaration and code is forbidden Use standard C library (e.g. alloca is

forbidden) and standard type (stdint.h, stdbool.h)

Usage of GNU extension is fordidden Only rely on C89 norm (behavior, syntax, …)

Exceptions C99 comments allow (//) static inline restrict

31

Lexical Conventions (1)

Lines length ≤ 90 characters Indent with space (2) <TAB> is forbidden except in comment Use K&R recommended layout:

if (cond1) { ...} else if (cond2) { ...} else { ...}

32

Lexical Conventions (2)

Control expression must check a logical valueif (pointer) // forbiddenif (pointer != NULL) // OK

Attach the opening ‘(‘ of a function call to the function namefoo (bar) // forbiddenfoo(bar) // OK

Use ‘, ‘ to separate function arguments Function definitions have the function name

and the return type on two linesstatic intfoo(int bar)

33

Lexical Convention (3) When an expression does not fit on a single

line, break it up according to these rules: Break after a comma. Break before an operator. Prefer higher-level breaks to lower-level breaks. Align the new line with the beginning of the

expression at the same level on the previous line.if ( cond1 && ( cond 2 || cond 3)) { ...}for (iter1 = val1, iter2 = val2;

34

Identifier Names (1)

Type name BackColor Should be prefixed by module name

// Module.htypedef int (*ModuleCompare)(int, int);typedef struct { int16_t REAL; int16_t IMAG;} ModuleComplex;

Function name Simple function: backColor. Object function: Object_backColor External linkage function: Module_backColor

35

Identifier Names (2) Structure:

Structure name: struct MyStruct_ Field name: BACKCOLOR Related function: MyStruct_someFunc

Enumeration: All enumeration values should start with the name of the enumerationtypedef enum { ModuleFlag_Opened, ModuleFlag_Closed, ModuleFlag_} ModuleFlag;

Variable: backColor Macro: Namespace_BACKCOLOR

36

Information To Start

37

Useful Interfaces (1)

Create temporaries Procedure (ECL/LIR) SSAForm (ECL/PFA)

Create operations Selector (ECL/LIR) BasicBlock (ECL/LIR)

Create basic blocks Procedure (ECL/LIR)

SSA Creation/Destruction SSAForm (ECL/PFA)

38

Useful Interfaces (2)

Browse basic blocks’ succs/preds CodeRegion (ECL/LIR)

Browse basic blocks CodeRegion (ECL/LIR)

Browse basic blocks’ operations BasicBlock (ECL/LIR)

Browse operations’ arguments/results Operation (ECL/LIR)

39

Convention (1)

Constructor initializes structure’s members

MyStruct_make Performs memory allocation Call constructor Return a pointer to new “object”

MyStruct_kill Call destructor Performs memory release

40

Convention (2)

Result of module analysis available between MyStruct_make MyStruct_kill

Use functions to access/mutate fields members, or at least generated macros MyStruct_myField MyStruct_MYFIELD

41

Use Cases

42

Start With LAO Create your working directory (WD) Checkout LAO in your working directory

svn co svn+ssh://stmicro.lipforge.ens-lyon.fr/svnroot/ecc/lao/trunk/LAO

Enter LAO directory and retrieve packages cd LAO; make extract

Build LAO make debug

Test LAO make check

43

Create Self Test References

Retrieve and build LAO (cf. previous slide) Go to WD and extract tests bed

svn co svn+ssh://stmicro.lipforge.ens-lyon.fr/svnroot/ecc/lao/trunk/LAO_INPUT

Create a directory for the traces mkdir LAO_TRACE

Set the optimizations options you want E.g. touch LAO_TRACE/FORCE_CONVERSION=127

Create References make refs –C LAO/PRO

Note: To test against references make tests –C LAO/PRO

44

New Module Create MyModule.xcc file Add it to the repository

svn add MyModule.xcc Add it in the build process

Add MyModule.c on the lines of the library you belong to in Makefile.am of your package

Launch automake (version 1.9.6) Ensure it works Commit your changes (at least adding

of your file and makefile modification)

45

Use Liveness Information For My Optimization

Call Liveness_make Set live in and live out attributes on basic

blocks Do your optimization Call Liveness_kill

Kill live in and live out attributes on basic blocks