Changeset ee68e11


Ignore:
Timestamp:
Mar 30, 2017, 1:36:51 PM (5 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
814525c
Parents:
b2daebd4 (diff), a4dd728 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    rb2daebd4 ree68e11  
    4242\newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
    4343\newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
     44\newcommand{\CCtwenty}{\rm C\kern-.1em\hbox{+\kern-.25em+}20} % C++20 symbolic name
    4445\newcommand{\Celeven}{C11\xspace}               % C11 symbolic name
    4546\newcommand{\Csharp}{C\raisebox{0.4ex}{\#}\xspace}      % C# symbolic name
     
    200201\newcommand{\opt}{$_{opt}$\ }
    201202
     203\usepackage{varioref}                 % extended references
    202204% adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers
    203205% \VRef{label} => Section 2.7, \VPageref{label} => page 17
     
    251253                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    252254                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert,
    253                 _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,zero_t},
     255                _Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t},
    254256}%
    255257
  • doc/generic_types/generic_types.tex

    rb2daebd4 ree68e11  
    148148\label{sec:poly-fns}
    149149
    150 \CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name): 
     150\CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name):
    151151\begin{lstlisting}
    152152forall(otype T)
     
    174174forall(otype S | { S ?+?(S, S); })
    175175S twice(S x) { return x + x; }  // (2)
    176 \end{lstlisting} 
    177 This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@. 
     176\end{lstlisting}
     177This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@.
    178178The translator accomplishes this polymorphism by creating a wrapper function calling @twice // (2)@ with @S@ bound to @double@, then providing this wrapper function to @four_times@\footnote{\lstinline@twice // (2)@ could also have had a type parameter named \lstinline@T@; \CFA{} specifies renaming of the type parameters, which would avoid the name conflict with the type variable \lstinline@T@ of \lstinline@four_times@.}.
    179179
     
    196196forall(otype M | has_magnitude(M))
    197197M max_magnitude( M a, M b ) {
    198     return abs(a) < abs(b) ? b : a; 
     198    return abs(a) < abs(b) ? b : a;
    199199}
    200200\end{lstlisting}
     
    213213Given the information provided for an @otype@, variables of polymorphic type can be treated as if they were a complete struct type -- they can be stack-allocated using the @alloca@ compiler builtin, default or copy-initialized, assigned, and deleted. As an example, the @abs@ function above produces generated code something like the following (simplified for clarity and brevity):
    214214\begin{lstlisting}
    215 void abs( size_t _sizeof_M, size_t _alignof_M, 
    216                 void (*_ctor_M)(void*), void (*_copy_M)(void*, void*), 
    217                 void (*_assign_M)(void*, void*), void (*_dtor_M)(void*), 
    218                 bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*), 
    219         void (*_ctor_M_zero)(void*, int), 
     215void abs( size_t _sizeof_M, size_t _alignof_M,
     216                void (*_ctor_M)(void*), void (*_copy_M)(void*, void*),
     217                void (*_assign_M)(void*, void*), void (*_dtor_M)(void*),
     218                bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*),
     219        void (*_ctor_M_zero)(void*, int),
    220220                void* m, void* _rtn ) {  // polymorphic parameter and return passed as void*
    221221        // M zero = { 0 };
     
    223223        _ctor_M_zero(zero, 0);  // initialize using zero_t constructor
    224224        // return m < zero ? -m : m;
    225         void *_tmp = alloca(_sizeof_M)
     225        void *_tmp = alloca(_sizeof_M);
    226226        _copy_M( _rtn,  // copy-initialize return value
    227227                _lt_M( m, zero ) ?  // check condition
     
    323323In some cases the offset arrays cannot be statically generated. For instance, modularity is generally provided in C by including an opaque forward-declaration of a struct and associated accessor and mutator routines in a header file, with the actual implementations in a separately-compiled \texttt{.c} file. \CFA{} supports this pattern for generic types, and in this instance the caller does not know the actual layout or size of the dynamic generic type, and only holds it by pointer. The \CFA{} translator automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed in to a function from that function's caller. These layout functions take as arguments pointers to size and alignment variables and a caller-allocated array of member offsets, as well as the size and alignment of all @sized@ parameters to the generic struct (un-@sized@ parameters are forbidden from the language from being used in a context that affects layout). Results of these layout functions are cached so that they are only computed once per type per function.%, as in the example below for @pair@.
    324324% \begin{lstlisting}
    325 % static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair, 
     325% static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair,
    326326%               size_t _szeof_R, size_t _alignof_R, size_t _szeof_S, size_t _alignof_S) {
    327327%     *_szeof_pair = 0; // default values
     
    332332%     *_szeof_pair += _szeof_R;
    333333%     if ( *_alignof_pair < _alignof_R ) *_alignof_pair = _alignof_R;
    334        
     334
    335335%       // padding, offset, size, and alignment of second field
    336336%     if ( *_szeof_pair & (_alignof_S - 1) )
     
    754754f(x.field_0, (_tuple2){ x.field_1, 'z' });
    755755\end{lstlisting}
    756 Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, a the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
     756Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
    757757
    758758Expressions that may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion. Each unique expression is assigned an identifier and is guaranteed to be executed exactly once:
     
    774774);
    775775\end{lstlisting}
    776 Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity.
     776Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity.
    777777
    778778Currently, the \CFA{} translator has a very broad, imprecise definition of impurity, where any function call is assumed to be impure. This notion could be made more precise for certain intrinsic, auto-generated, and builtin functions, and could analyze function bodies when they are available to recursively detect impurity, to eliminate some unique expressions.
  • doc/rob_thesis/ctordtor.tex

    rb2daebd4 ree68e11  
    135135%   at the global scope (which is likely the most common case)
    136136% * [9]
    137 
    138 % Move semantics
    139 % * <ongoing discussion about this. this will be filled in
    140 %    once we come to a consensus>
    141137
    142138% Changes to polymorphic type classes
  • doc/rob_thesis/tuples.tex

    rb2daebd4 ree68e11  
    615615\end{cfacode}
    616616Note that due to flattening, @x@ used in the argument position is converted into the list of its fields.
    617 In the call to @f@, a the second and third argument components are structured into a tuple argument.
     617In the call to @f@, the second and third argument components are structured into a tuple argument.
    618618
    619619Expressions which may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion.
     
    643643\end{cfacode}
    644644Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order.
    645 The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true.
     645The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true.
    646646Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression.
    647647
     
    12991299Thunks 0 through 3 provide wrappers for the @otype@ parameters for @const char *@, while @_thunk4@ translates a call to @print([int, const char *])@ into a call to @print_variadic(int, [const char *])@.
    13001300This all builds to a call to @print_variadic@, with the appropriate copy construction of the tuple argument.
     1301
     1302\section{Future Work}
  • src/InitTweak/FixInit.cc

    rb2daebd4 ree68e11  
    738738                                                stmtsToAddAfter.push_back( ifStmt );
    739739
    740                                                 if ( ctorInit->get_dtor() ) {
     740                                                Statement * dtor = ctorInit->get_dtor();
     741                                                objDecl->set_init( NULL );
     742                                                ctorInit->set_ctor( NULL );
     743                                                ctorInit->set_dtor( nullptr );
     744                                                if ( dtor ) {
    741745                                                        // if the object has a non-trivial destructor, have to
    742746                                                        // hoist it and the object into the global space and
    743747                                                        // call the destructor function with atexit.
    744748
    745                                                         Statement * dtorStmt = ctorInit->get_dtor()->clone();
     749                                                        Statement * dtorStmt = dtor->clone();
    746750
    747751                                                        // void __objName_dtor_atexitN(...) {...}
     
    772776                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
    773777
    774                                                         objDecl->set_init( NULL );
    775                                                         ctorInit->set_ctor( NULL );
    776                                                         delete ctorInit;
    777 
    778778                                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
    779779                                                        // create a new object which is never used
    780780                                                        static UniqueName dummyNamer( "_dummy" );
    781781                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
     782                                                        delete ctorInit;
    782783                                                        return dummy;
    783784                                                }
  • src/InitTweak/GenInit.cc

    rb2daebd4 ree68e11  
    294294                handleDWT( objDecl );
    295295                // hands off if @=, extern, builtin, etc.
    296                 // if global but initializer is not constexpr, always try to construct, since this is not legal C
    297                 if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
     296                // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
     297                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
    298298                        // constructed objects cannot be designated
    299                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl );
     299                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
    300300                        // constructed objects should not have initializers nested too deeply
    301301                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
  • src/libcfa/iostream.c

    rb2daebd4 ree68e11  
    154154ostype * ?|?( ostype * os, const char * cp ) {
    155155        enum { Open = 1, Close, OpenClose };
    156         static const unsigned char mask[256] = {
     156        static const unsigned char mask[256] @= {
    157157                // opening delimiters, no space after
    158158                ['('] : Open, ['['] : Open, ['{'] : Open,
Note: See TracChangeset for help on using the changeset viewer.