Changeset 45c43e5


Ignore:
Timestamp:
Feb 26, 2018, 12:49:55 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
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:
eddb399
Parents:
17fc7a5 (diff), 2c39855 (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:/u/cforall/software/cfa/cfa-cc

Files:
3 added
24 edited

Legend:

Unmodified
Added
Removed
  • doc/papers/general/Paper.tex

    r17fc7a5 r45c43e5  
    4141
    4242\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
    43 \newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
    44 %\newcommand{\TODO}[1]{} % TODO elided
     43%\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
     44\newcommand{\TODO}[1]{} % TODO elided
    4545
    4646% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
     
    117117                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
    118118                __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
    119                 __const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru,
     119                __const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru,
    120120                finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
    121121                otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
     
    261261The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@.
    262262Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names.
     263Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that}
    263264
    264265% http://fanf.livejournal.com/144696.html
     
    13561357\subsection{Exception Handling}
    13571358
    1358 \CFA provides two forms of exception handling: \newterm{resumption} (fix-up) and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
     1359The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts.
     1360\CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
    13591361Both mechanisms provide dynamic call to a handler using dynamic name-lookup, where fix-up has dynamic return and recovery has static return from the handler.
    1360 \CFA restricts exception types to those defined by aggregate type @_Exception@.
     1362\CFA restricts exception types to those defined by aggregate type @exception@.
    13611363The form of the raise dictates the set of handlers examined during propagation: \newterm{resumption propagation} (@resume@) only examines resumption handlers (@catchResume@); \newterm{terminating propagation} (@throw@) only examines termination handlers (@catch@).
    13621364If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation.
    1363 If there is no current exception, the reresume/rethrow results in an error.
     1365If there is no current exception, the reresume/rethrow results in a runtime error.
    13641366
    13651367\begin{figure}
     
    13691371\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}}       & \multicolumn{1}{c}{\textbf{Recovery}} \\
    13701372\begin{cfa}
    1371 `_Exception R { int fix; };`
     1373`exception R { int fix; };`
    13721374void f() {
    13731375        R r;
    13741376        ... `resume( r );` ...
    13751377        ... r.fix // control does return here after handler
     1378}
    13761379`try` {
    13771380        ... f(); ...
     
    13821385&
    13831386\begin{cfa}
    1384 `_Exception T {};`
     1387`exception T {};`
    13851388void f() {
    13861389
    13871390        ... `throw( T{} );` ...
    13881391        // control does NOT return here after handler
     1392}
    13891393`try` {
    13901394        ... f(); ...
     
    14191423        ... write( `datafile`, ... ); ...               $\C{// may throw IOError}$
    14201424        ... write( `logfile`, ... ); ...
    1421 } catch ( IOError err; `err == datafile` ) { ... } $\C{// handle datafile error}$
    1422    catch ( IOError err; `err == logfile` ) { ... } $\C{// handle logfile error}$
     1425} catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$
     1426   catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$
    14231427   catch ( IOError err ) { ... }                        $\C{// handler error from other files}$
    14241428\end{cfa}
     
    14281432The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}:
    14291433\begin{cfa}
    1430 resume [ $\emph{exception-type}$ ] [ _At $\emph{alternate-stack}$ ] ;
    1431 \end{cfa}
    1432 The @_At@ clause raises the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
     1434resume( $\emph{exception-type}$, $\emph{alternate-stack}$ )
     1435resume( $\emph{alternate-stack}$ )
     1436\end{cfa}
     1437These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
    14331438Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handle returns.
    14341439
     
    16211626\lstMakeShortInline@%
    16221627\end{cquote}
    1623 Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}.
     1628Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}
    16241629The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}}.
    16251630
     
    16761681* [ * int, int ] ( int ) jp;                            $\C{// pointer to routine returning pointer to int and int, with int parameter}$
    16771682\end{cfa}
    1678 Note, \emph{a routine name cannot be specified}:
     1683Note, a routine name cannot be specified:
    16791684\begin{cfa}
    16801685* [ int x ] f () fp;                                            $\C{// routine name "f" is disallowed}$
     
    19841989
    19851990In C, @0@ has the special property that it is the only ``false'' value; by the standard, any value which compares equal to @0@ is false, while any value that compares unequal to @0@ is true.
    1986 As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to an @&&@, @||@, or ternary operator) can be rewritten as @x != 0@ without changing its semantics.
     1991As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to @&&@, @||@, or @?:@) can be rewritten as @x != 0@ without changing its semantics.
    19871992The operator overloading feature of \CFA provides a natural means to implement this truth value comparison for arbitrary types, but the C type system is not precise enough to distinguish an equality comparison with @0@ from an equality comparison with an arbitrary integer or pointer.
    1988 To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that standard C code involving @0@ continues to work properly.
     1993To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that C code involving @0@ continues to work properly.
    19891994With this addition, the \CFA compiler rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ can be made ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
    19901995\CC makes types truthy by adding a conversion to @bool@; prior to the addition of explicit cast operators in \CCeleven this approach had the pitfall of making truthy types transitively convertable to any numeric type; our design for \CFA avoids this issue.
     
    26142619\section{Acknowledgments}
    26152620
    2616 The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen and the three anonymous reviewers for valuable feedback.
     2621The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen for feedback in the writing.
    26172622%This work is supported in part by a corporate partnership with \grantsponsor{Huawei}{Huawei Ltd.}{http://www.huawei.com}, and Aaron Moss and Peter Buhr are funded by the \grantsponsor{Natural Sciences and Engineering Research Council} of Canada.
    26182623% the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship.
  • src/Parser/DeclarationNode.cc

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Nov 20 09:21:52 2017
    13 // Update Count     : 1031
     12// Last Modified On : Thu Feb 22 15:37:17 2018
     13// Update Count     : 1033
    1414//
    1515
     
    120120} // DeclarationNode::clone
    121121
    122 bool DeclarationNode::get_hasEllipsis() const {
    123         return hasEllipsis;
    124 }
    125 
    126122void DeclarationNode::print( std::ostream &os, int indent ) const {
    127123        os << string( indent, ' ' );
     
    167163}
    168164
    169 DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
     165DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
    170166        DeclarationNode * newnode = new DeclarationNode;
    171167        newnode->name = name;
    172168        newnode->type = new TypeData( TypeData::Function );
    173169        newnode->type->function.params = param;
    174         newnode->type->function.newStyle = newStyle;
    175170        newnode->type->function.body = body;
    176171
  • src/Parser/ParseNode.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Nov 27 17:33:35 2017
    13 // Update Count     : 824
     12// Last Modified On : Thu Feb 22 17:49:31 2018
     13// Update Count     : 827
    1414//
    1515
     
    209209        enum Length { Short, Long, LongLong, NoLength };
    210210        static const char * lengthNames[];
    211         enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
     211        enum Aggregate { Struct, Union, Exception, Trait, Coroutine, Monitor, Thread, NoAggregate };
    212212        static const char * aggregateNames[];
    213213        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
     
    226226        static DeclarationNode * newForall( DeclarationNode * );
    227227        static DeclarationNode * newFromTypedef( std::string * );
    228         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
     228        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
    229229        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    230230        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
     
    288288        Type * buildType() const;
    289289
    290         bool get_hasEllipsis() const;
    291290        LinkageSpec::Spec get_linkage() const { return linkage; }
    292291        DeclarationNode * extractAggregate() const;
  • src/Parser/TypeData.cc

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 25 18:33:41 2017
    13 // Update Count     : 587
     12// Last Modified On : Thu Feb 22 15:49:00 2018
     13// Update Count     : 597
    1414//
    1515
     
    5454                function.oldDeclList = nullptr;
    5555                function.body = nullptr;
    56                 function.newStyle = false;
    5756                function.withExprs = nullptr;
    5857                break;
     
    195194                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
    196195                newtype->function.body = maybeClone( function.body );
    197                 newtype->function.newStyle = function.newStyle;
    198196                newtype->function.withExprs = maybeClone( function.withExprs );
    199197                break;
     
    881879FunctionType * buildFunction( const TypeData * td ) {
    882880        assert( td->kind == TypeData::Function );
    883         bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true;
    884         if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle;
    885         FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis );
     881        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
    886882        buildList( td->function.params, ft->get_parameters() );
    887883        buildForall( td->forall, ft->get_forall() );
  • src/Parser/TypeData.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  1 23:33:45 2017
    13 // Update Count     : 190
     12// Last Modified On : Thu Feb 22 15:21:23 2018
     13// Update Count     : 191
    1414//
    1515
     
    6464                mutable DeclarationNode * oldDeclList;
    6565                StatementNode * body;
    66                 bool newStyle;
    6766                ExpressionNode * withExprs;             // expressions from function's with_clause
    6867        };
  • src/Parser/lex.ll

    r17fc7a5 r45c43e5  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Oct 25 13:53:56 2017
    13  * Update Count     : 634
     12 * Last Modified On : Thu Feb 22 18:11:27 2018
     13 * Update Count     : 637
    1414 */
    1515
     
    232232enum                    { KEYWORD_RETURN(ENUM); }
    233233__extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
     234exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
    234235extern                  { KEYWORD_RETURN(EXTERN); }
    235236fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
  • src/Parser/parser.yy

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 15 17:12:31 2018
    13 // Update Count     : 3006
     12// Last Modified On : Thu Feb 22 17:48:54 2018
     13// Update Count     : 3028
    1414//
    1515
     
    187187%token TYPEOF LABEL                                                                             // GCC
    188188%token ENUM STRUCT UNION
     189%token EXCEPTION                                                                                // CFA
    189190%token COROUTINE MONITOR THREAD                                                 // CFA
    190191%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
     
    314315%type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
    315316
    316 %type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list cfa_parameter_type_list_opt
     317%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
    317318
    318319%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
     
    322323%type<decl> KR_declaration_list KR_declaration_list_opt
    323324
    324 %type<decl> parameter_declaration parameter_list parameter_type_list
    325 %type<decl> parameter_type_list_opt
     325%type<decl> parameter_declaration parameter_list parameter_type_list_opt
    326326
    327327%type<decl> paren_identifier paren_type
     
    779779        | unary_expression assignment_operator assignment_expression
    780780                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    781         | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
    782                 { $$ = nullptr; }
     781        | unary_expression '=' '{' initializer_list comma_opt '}'
     782                { throw SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
    783783        ;
    784784
     
    849849        | waitfor_statement
    850850        | exception_statement
     851        | enable_disable_statement
     852                { throw SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
    851853        | asm_statement
    852854        ;
     
    10641066        | RETURN comma_expression_opt ';'
    10651067                { $$ = new StatementNode( build_return( $2 ) ); }
    1066         | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
    1067                 { $$ = nullptr; }
     1068        | RETURN '{' initializer_list comma_opt '}'
     1069                { throw SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
    10681070        | THROW assignment_expression_opt ';'                           // handles rethrow
    10691071                { $$ = new StatementNode( build_throw( $2 ) ); }
     
    11931195        ;
    11941196
     1197enable_disable_statement:
     1198        enable_disable_key identifier_list compound_statement
     1199        ;
     1200
     1201enable_disable_key:
     1202        ENABLE
     1203        | DISABLE
     1204        ;
     1205
    11951206asm_statement:
    11961207        ASM asm_volatile_opt '(' string_literal ')' ';'
     
    13921403                        DeclarationNode * ret = new DeclarationNode;
    13931404                        ret->type = maybeClone( $1->type->base );
    1394                         $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr, true ) );
     1405                        $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) );
    13951406                }
    13961407        ;
     
    14221433                // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
    14231434                {
    1424                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
     1435                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    14251436                }
    14261437        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
    14271438                {
    1428                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
     1439                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    14291440                }
    14301441        ;
     
    18811892        | UNION
    18821893                { $$ = DeclarationNode::Union; }
     1894        | EXCEPTION
     1895                { $$ = DeclarationNode::Exception; }
    18831896        | COROUTINE
    18841897                { $$ = DeclarationNode::Coroutine; }
     
    19902003        ;
    19912004
    1992 // Minimum of one parameter after which ellipsis is allowed only at the end.
    1993 
    1994 cfa_parameter_type_list_opt:                                                    // CFA
     2005cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
    19952006        // empty
     2007                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     2008        | ELLIPSIS
    19962009                { $$ = nullptr; }
    1997         | cfa_parameter_type_list
    1998         ;
    1999 
    2000 cfa_parameter_type_list:                                                                // CFA, abstract + real
    2001         cfa_abstract_parameter_list
     2010        | cfa_abstract_parameter_list
    20022011        | cfa_parameter_list
    20032012        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
     
    20302039        // empty
    20312040                { $$ = nullptr; }
    2032         | parameter_type_list
    2033         ;
    2034 
    2035 parameter_type_list:
    2036         parameter_list
     2041        | ELLIPSIS
     2042                { $$ = nullptr; }
     2043        | parameter_list
    20372044        | parameter_list pop ',' push ELLIPSIS
    20382045                { $$ = $1->addVarArgs(); }
  • src/benchmark/bench.h

    r17fc7a5 r45c43e5  
    1010#if defined(__cforall)
    1111}
     12#include <bits/cfatime.h>
    1213#endif
     14
    1315
    1416static inline unsigned long long int Time() {
     
    4547        ( EndTime - StartTime ) / n;
    4648
    47 unsigned int default_preemption() {
     49__cfa_time_t default_preemption() {
    4850        return 0;
    4951}
  • src/libcfa/Makefile.am

    r17fc7a5 r45c43e5  
    101101        gmp                             \
    102102        bits/align.h            \
     103        bits/cfatime.h          \
    103104        bits/containers.h               \
    104105        bits/defs.h             \
  • src/libcfa/Makefile.in

    r17fc7a5 r45c43e5  
    264264        concurrency/thread concurrency/kernel concurrency/monitor \
    265265        ${shell find stdhdr -type f -printf "%p "} math gmp \
    266         bits/align.h bits/containers.h bits/defs.h bits/debug.h \
    267         bits/locks.h concurrency/invoke.h
     266        bits/align.h bits/cfatime.h bits/containers.h bits/defs.h \
     267        bits/debug.h bits/locks.h concurrency/invoke.h
    268268HEADERS = $(nobase_cfa_include_HEADERS)
    269269am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
     
    437437        gmp                             \
    438438        bits/align.h            \
     439        bits/cfatime.h          \
    439440        bits/containers.h               \
    440441        bits/defs.h             \
  • src/libcfa/bits/cfatime.h

    r17fc7a5 r45c43e5  
    4848// ctors
    4949static inline void ?{}( __cfa_time_t & this ) { this.val = 0; }
     50static inline void ?{}( __cfa_time_t & this, const __cfa_time_t & rhs ) { this.val = rhs.val; }
    5051static inline void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
    5152
     
    9293static inline __cfa_time_t from_us ( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
    9394static inline __cfa_time_t from_ns ( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
     95
     96static inline uint64_t to_s  ( __cfa_time_t t ) { return t.val / 1_000_000_000ul; }
     97static inline uint64_t to_ms ( __cfa_time_t t ) { return t.val /     1_000_000ul; }
     98static inline uint64_t to_us ( __cfa_time_t t ) { return t.val /         1_000ul; }
     99static inline uint64_t to_ns ( __cfa_time_t t ) { return t.val /             1ul; }
  • src/libcfa/concurrency/coroutine.c

    r17fc7a5 r45c43e5  
    9999// Wrapper for co
    100100void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    101         verify( preemption.enabled || this_processor->do_terminate );
     101        verify( preemption_state.enabled || this_processor->do_terminate );
    102102        disable_interrupts();
    103103
     
    117117
    118118        enable_interrupts( __cfaabi_dbg_ctx );
    119         verify( preemption.enabled || this_processor->do_terminate );
     119        verify( preemption_state.enabled || this_processor->do_terminate );
    120120} //ctxSwitchDirect
    121121
  • src/libcfa/concurrency/kernel

    r17fc7a5 r45c43e5  
    1919
    2020#include "invoke.h"
     21#include "bits/cfatime.h"
    2122
    2223extern "C" {
     
    4849
    4950        // Preemption rate on this cluster
    50         unsigned long long int preemption;
     51        __cfa_time_t preemption_rate;
    5152};
     53
     54extern __cfa_time_t default_preemption();
    5255
    5356void ?{} (cluster & this);
  • src/libcfa/concurrency/kernel.c

    r17fc7a5 r45c43e5  
    6060// volatile thread_local unsigned short disable_preempt_count = 1;
    6161
    62 volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
     62volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
    6363
    6464//-----------------------------------------------------------------------------
     
    180180        ready_queue_lock{};
    181181
    182         preemption = default_preemption();
     182        preemption_rate = default_preemption();
    183183}
    184184
     
    209209                        if(readyThread)
    210210                        {
    211                                 verify( !preemption.enabled );
     211                                verify( !preemption_state.enabled );
    212212
    213213                                runThread(this, readyThread);
    214214
    215                                 verify( !preemption.enabled );
     215                                verify( !preemption_state.enabled );
    216216
    217217                                //Some actions need to be taken from the kernel
     
    262262void finishRunning(processor * this) with( this->finish ) {
    263263        if( action_code == Release ) {
    264                 verify( !preemption.enabled );
     264                verify( !preemption_state.enabled );
    265265                unlock( *lock );
    266266        }
     
    269269        }
    270270        else if( action_code == Release_Schedule ) {
    271                 verify( !preemption.enabled );
     271                verify( !preemption_state.enabled );
    272272                unlock( *lock );
    273273                ScheduleThread( thrd );
    274274        }
    275275        else if( action_code == Release_Multi ) {
    276                 verify( !preemption.enabled );
     276                verify( !preemption_state.enabled );
    277277                for(int i = 0; i < lock_count; i++) {
    278278                        unlock( *locks[i] );
     
    306306        this_coroutine = NULL;
    307307        this_thread = NULL;
    308         preemption.enabled = false;
    309         preemption.disable_count = 1;
     308        preemption_state.enabled = false;
     309        preemption_state.disable_count = 1;
    310310        // SKULLDUGGERY: We want to create a context for the processor coroutine
    311311        // which is needed for the 2-step context switch. However, there is no reason
     
    351351        coroutine_desc * dst = get_coroutine(*this->runner);
    352352
    353         verify( !preemption.enabled );
     353        verify( !preemption_state.enabled );
    354354
    355355        create_stack(&dst->stack, dst->stack.size);
    356356        CtxStart(this->runner, CtxInvokeCoroutine);
    357357
    358         verify( !preemption.enabled );
     358        verify( !preemption_state.enabled );
    359359
    360360        dst->last = src;
     
    382382        src->state = Active;
    383383
    384         verify( !preemption.enabled );
     384        verify( !preemption_state.enabled );
    385385}
    386386
     
    392392        verify( thrd->self_cor.state != Halted );
    393393
    394         verify( !preemption.enabled );
     394        verify( !preemption_state.enabled );
    395395
    396396        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
     
    402402        }
    403403
    404         verify( !preemption.enabled );
     404        verify( !preemption_state.enabled );
    405405}
    406406
    407407thread_desc * nextThread(cluster * this) with( *this ) {
    408         verify( !preemption.enabled );
     408        verify( !preemption_state.enabled );
    409409        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
    410410        thread_desc * head = pop_head( ready_queue );
    411411        unlock( ready_queue_lock );
    412         verify( !preemption.enabled );
     412        verify( !preemption_state.enabled );
    413413        return head;
    414414}
     
    416416void BlockInternal() {
    417417        disable_interrupts();
    418         verify( !preemption.enabled );
     418        verify( !preemption_state.enabled );
    419419        returnToKernel();
    420         verify( !preemption.enabled );
     420        verify( !preemption_state.enabled );
    421421        enable_interrupts( __cfaabi_dbg_ctx );
    422422}
     
    427427        this_processor->finish.lock        = lock;
    428428
    429         verify( !preemption.enabled );
     429        verify( !preemption_state.enabled );
    430430        returnToKernel();
    431         verify( !preemption.enabled );
     431        verify( !preemption_state.enabled );
    432432
    433433        enable_interrupts( __cfaabi_dbg_ctx );
     
    439439        this_processor->finish.thrd        = thrd;
    440440
    441         verify( !preemption.enabled );
     441        verify( !preemption_state.enabled );
    442442        returnToKernel();
    443         verify( !preemption.enabled );
     443        verify( !preemption_state.enabled );
    444444
    445445        enable_interrupts( __cfaabi_dbg_ctx );
     
    453453        this_processor->finish.thrd        = thrd;
    454454
    455         verify( !preemption.enabled );
     455        verify( !preemption_state.enabled );
    456456        returnToKernel();
    457         verify( !preemption.enabled );
     457        verify( !preemption_state.enabled );
    458458
    459459        enable_interrupts( __cfaabi_dbg_ctx );
     
    466466        this_processor->finish.lock_count  = count;
    467467
    468         verify( !preemption.enabled );
     468        verify( !preemption_state.enabled );
    469469        returnToKernel();
    470         verify( !preemption.enabled );
     470        verify( !preemption_state.enabled );
    471471
    472472        enable_interrupts( __cfaabi_dbg_ctx );
     
    481481        this_processor->finish.thrd_count  = thrd_count;
    482482
    483         verify( !preemption.enabled );
     483        verify( !preemption_state.enabled );
    484484        returnToKernel();
    485         verify( !preemption.enabled );
     485        verify( !preemption_state.enabled );
    486486
    487487        enable_interrupts( __cfaabi_dbg_ctx );
     
    489489
    490490void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
    491         verify( !preemption.enabled );
     491        verify( !preemption_state.enabled );
    492492        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
    493493        this_processor->finish.lock        = lock;
     
    503503// Kernel boot procedures
    504504void kernel_startup(void) {
    505         verify( !preemption.enabled );
     505        verify( !preemption_state.enabled );
    506506        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    507507
     
    548548        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
    549549
    550         verify( !preemption.enabled );
     550        verify( !preemption_state.enabled );
    551551        enable_interrupts( __cfaabi_dbg_ctx );
    552         verify( preemption.enabled );
     552        verify( preemption_state.enabled );
    553553}
    554554
     
    556556        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    557557
    558         verify( preemption.enabled );
     558        verify( preemption_state.enabled );
    559559        disable_interrupts();
    560         verify( !preemption.enabled );
     560        verify( !preemption_state.enabled );
    561561
    562562        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
  • src/libcfa/concurrency/kernel_private.h

    r17fc7a5 r45c43e5  
    7878// extern volatile thread_local unsigned short disable_preempt_count;
    7979
    80 struct __cfa_kernel_preemption_data_t {
     80struct __cfa_kernel_preemption_state_t {
    8181        bool enabled;
    8282        bool in_progress;
     
    8484};
    8585
    86 extern volatile thread_local __cfa_kernel_preemption_data_t preemption;
     86extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state;
    8787
    8888//-----------------------------------------------------------------------------
  • src/libcfa/concurrency/preemption.c

    r17fc7a5 r45c43e5  
    2323}
    2424
     25#include "bits/cfatime.h"
    2526#include "bits/signal.h"
    2627
    27 //TODO move to defaults
    28 #define __CFA_DEFAULT_PREEMPTION__ 10000
    29 
    30 //TODO move to defaults
    31 __attribute__((weak)) unsigned int default_preemption() {
     28#if !defined(__CFA_DEFAULT_PREEMPTION__)
     29#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
     30#endif
     31
     32__cfa_time_t default_preemption() __attribute__((weak)) {
    3233        return __CFA_DEFAULT_PREEMPTION__;
    3334}
     
    149150        // Disable interrupts by incrementing the counter
    150151        void disable_interrupts() {
    151                 preemption.enabled = false;
    152                 __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
    153                 preemption.disable_count = new_val;
     152                preemption_state.enabled = false;
     153                __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
     154                preemption_state.disable_count = new_val;
    154155                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
    155156        }
     
    161162                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    162163
    163                 unsigned short prev = preemption.disable_count;
    164                 preemption.disable_count -= 1;
     164                unsigned short prev = preemption_state.disable_count;
     165                preemption_state.disable_count -= 1;
    165166                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
    166167
    167168                // Check if we need to prempt the thread because an interrupt was missed
    168169                if( prev == 1 ) {
    169                         preemption.enabled = true;
     170                        preemption_state.enabled = true;
    170171                        if( proc->pending_preemption ) {
    171172                                proc->pending_preemption = false;
     
    181182        // Don't execute any pending CtxSwitch even if counter reaches 0
    182183        void enable_interrupts_noPoll() {
    183                 unsigned short prev = preemption.disable_count;
    184                 preemption.disable_count -= 1;
     184                unsigned short prev = preemption_state.disable_count;
     185                preemption_state.disable_count -= 1;
    185186                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
    186187                if( prev == 1 ) {
    187                         preemption.enabled = true;
     188                        preemption_state.enabled = true;
    188189                }
    189190        }
     
    235236// If false : preemption is unsafe and marked as pending
    236237static inline bool preemption_ready() {
    237         bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
     238        bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
    238239        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
    239240        return ready;
     
    250251
    251252        // Start with preemption disabled until ready
    252         preemption.enabled = false;
    253         preemption.disable_count = 1;
     253        preemption_state.enabled = false;
     254        preemption_state.disable_count = 1;
    254255
    255256        // Initialize the event kernel
     
    294295        this.proc->preemption_alarm = &this.alarm;
    295296
    296         update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
     297        update_preemption( this.proc, this.proc->cltr->preemption_rate );
    297298}
    298299
     
    330331        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
    331332
    332         preemption.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
     333        preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
    333334        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
    334         preemption.in_progress = false;                     // Clear the in progress flag
     335        preemption_state.in_progress = false;                     // Clear the in progress flag
    335336
    336337        // Preemption can occur here
  • src/libcfa/concurrency/preemption.h

    r17fc7a5 r45c43e5  
    1919#include "kernel_private.h"
    2020
    21 __attribute__((weak)) unsigned int default_preemption();
    2221void kernel_start_preemption();
    2322void kernel_stop_preemption();
  • src/libcfa/concurrency/thread.c

    r17fc7a5 r45c43e5  
    9898
    9999void yield( void ) {
    100         verify( preemption.enabled );
     100        verify( preemption_state.enabled );
    101101        BlockInternal( this_thread );
    102         verify( preemption.enabled );
     102        verify( preemption_state.enabled );
    103103}
    104104
  • src/libcfa/exception.c

    r17fc7a5 r45c43e5  
    1010// Created On       : Mon Jun 26 15:13:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  9 14:41:55 2018
    13 // Update Count     : 8
     12// Last Modified On : Thu Feb 22 18:17:34 2018
     13// Update Count     : 11
    1414//
    1515
     
    5252    struct __cfaabi_ehm__try_resume_node * current_resume;
    5353
    54     exception * current_exception;
     54    exception_t * current_exception;
    5555    int current_handler_index;
    5656} shared_stack = {NULL, NULL, 0, 0};
     
    7171// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
    7272// in termination.
    73 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *)
     73// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
    7474#define MATCHER_FROM_CONTEXT(ptr_to_context) \
    75         (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8))
     75        (*(_Unwind_Reason_Code(**)(exception_t *))(_Unwind_GetCFA(ptr_to_context) + 8))
    7676
    7777
    7878// RESUMPTION ================================================================
    7979
    80 void __cfaabi_ehm__throw_resume(exception * except) {
     80void __cfaabi_ehm__throw_resume(exception_t * except) {
    8181
    8282        __cfaabi_dbg_print_safe("Throwing resumption exception\n");
     
    106106
    107107void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
    108                         _Bool (*handler)(exception * except)) {
     108                        _Bool (*handler)(exception_t * except)) {
    109109        node->next = shared_stack.top_resume;
    110110        node->handler = handler;
     
    126126};
    127127
    128 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
     128#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))
    129129#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
    130130
    131131// Creates a copy of the indicated exception and sets current_exception to it.
    132 static void __cfaabi_ehm__allocate_exception( exception * except ) {
     132static void __cfaabi_ehm__allocate_exception( exception_t * except ) {
    133133        struct exception_context_t * context = this_exception_context();
    134134
     
    151151
    152152// Delete the provided exception, unsetting current_exception if relivant.
    153 static void __cfaabi_ehm__delete_exception( exception * except ) {
     153static void __cfaabi_ehm__delete_exception( exception_t * except ) {
    154154        struct exception_context_t * context = this_exception_context();
    155155
     
    179179// If this isn't a rethrow (*except==0), delete the provided exception.
    180180void __cfaabi_ehm__cleanup_terminate( void * except ) {
    181         if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
     181        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except );
    182182}
    183183
     
    233233}
    234234
    235 void __cfaabi_ehm__throw_terminate( exception * val ) {
     235void __cfaabi_ehm__throw_terminate( exception_t * val ) {
    236236        __cfaabi_dbg_print_safe("Throwing termination exception\n");
    237237
     
    348348                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
    349349
    350                                         _Unwind_Reason_Code (*matcher)(exception *) =
     350                                        _Unwind_Reason_Code (*matcher)(exception_t *) =
    351351                                                MATCHER_FROM_CONTEXT(context);
    352352                                        int index = matcher(shared_stack.current_exception);
     
    409409__attribute__((noinline))
    410410void __cfaabi_ehm__try_terminate(void (*try_block)(),
    411                 void (*catch_block)(int index, exception * except),
    412                 __attribute__((unused)) int (*match_block)(exception * except)) {
     411                void (*catch_block)(int index, exception_t * except),
     412                __attribute__((unused)) int (*match_block)(exception_t * except)) {
    413413        //! volatile int xy = 0;
    414414        //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
  • src/libcfa/exception.h

    r17fc7a5 r45c43e5  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Jun 26 15:11:00 2017
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Aug 17 15:44:00 2017
    13 // Update Count     : 6
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Feb 22 18:11:15 2018
     13// Update Count     : 8
    1414//
    1515
     
    2222
    2323struct __cfaabi_ehm__base_exception_t;
    24 typedef struct __cfaabi_ehm__base_exception_t exception;
     24typedef struct __cfaabi_ehm__base_exception_t exception_t;
    2525struct __cfaabi_ehm__base_exception_t_vtable {
    2626        const struct __cfaabi_ehm__base_exception_t_vtable * parent;
     
    3939
    4040// Used in throw statement translation.
    41 void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
     41void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn));
    4242void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
    43 void __cfaabi_ehm__throw_resume(exception * except);
     43void __cfaabi_ehm__throw_resume(exception_t * except);
    4444
    4545// Function catches termination exceptions.
    4646void __cfaabi_ehm__try_terminate(
    4747    void (*try_block)(),
    48     void (*catch_block)(int index, exception * except),
    49     int (*match_block)(exception * except));
     48    void (*catch_block)(int index, exception_t * except),
     49    int (*match_block)(exception_t * except));
    5050
    5151// Clean-up the exception in catch blocks.
     
    5555struct __cfaabi_ehm__try_resume_node {
    5656    struct __cfaabi_ehm__try_resume_node * next;
    57     _Bool (*handler)(exception * except);
     57    _Bool (*handler)(exception_t * except);
    5858};
    5959
     
    6161void __cfaabi_ehm__try_resume_setup(
    6262    struct __cfaabi_ehm__try_resume_node * node,
    63     _Bool (*handler)(exception * except));
     63    _Bool (*handler)(exception_t * except));
    6464void __cfaabi_ehm__try_resume_cleanup(
    6565    struct __cfaabi_ehm__try_resume_node * node);
  • src/libcfa/stdhdr/math.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 20:38:18 2016
    13 // Update Count     : 12
     12// Last Modified On : Thu Feb 22 18:16:07 2018
     13// Update Count     : 13
    1414//
    1515
    1616extern "C" {
     17#if ! defined( exception )                                                              // nesting ?
     18#define exception `exception`                                                   // make keyword an identifier
     19#define __CFA_MATH_H__
     20#endif
     21
    1722#include_next <math.h>                                                                  // has internal check for multiple expansion
     23
     24#if defined( exception ) && defined( __CFA_MATH_H__ )   // reset only if set
     25#undef exception
     26#undef __CFA_MATH_H__
     27#endif
    1828} // extern "C"
    1929
  • src/prelude/builtins.c

    r17fc7a5 r45c43e5  
    2323void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    2424void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
     25
     26// increment/decrement unification
     27
     28static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
     29T& ++? ( T& x ) { return x += 1; }
     30
     31static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
     32T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
     33
     34static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
     35T& --? ( T& x ) { return x -= 1; }
     36
     37static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
     38T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
    2539
    2640// exponentiation operator implementation
  • tools/Makefile.am

    r17fc7a5 r45c43e5  
    1818CFLAGS = -Wall -Wextra -O2 -g
    1919
    20 noinst_PROGRAMS = catchsig repeat
     20noinst_PROGRAMS = busy catchsig repeat
    2121
     22busy_SOURCES     = busy.c
     23busy_LDFLAGS     = -pthread
    2224catchsig_SOURCES = catchsig.c
    2325repeat_SOURCES   = repeat.c
  • tools/Makefile.in

    r17fc7a5 r45c43e5  
    9292build_triplet = @build@
    9393host_triplet = @host@
    94 noinst_PROGRAMS = catchsig$(EXEEXT) repeat$(EXEEXT)
     94noinst_PROGRAMS = busy$(EXEEXT) catchsig$(EXEEXT) repeat$(EXEEXT)
    9595subdir = tools
    9696ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    104104CONFIG_CLEAN_VPATH_FILES =
    105105PROGRAMS = $(noinst_PROGRAMS)
     106am_busy_OBJECTS = busy.$(OBJEXT)
     107busy_OBJECTS = $(am_busy_OBJECTS)
     108busy_LDADD = $(LDADD)
     109busy_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(busy_LDFLAGS) $(LDFLAGS) \
     110        -o $@
    106111am_catchsig_OBJECTS = catchsig.$(OBJEXT)
    107112catchsig_OBJECTS = $(am_catchsig_OBJECTS)
     
    138143am__v_CCLD_0 = @echo "  CCLD    " $@;
    139144am__v_CCLD_1 =
    140 SOURCES = $(catchsig_SOURCES) $(repeat_SOURCES)
    141 DIST_SOURCES = $(catchsig_SOURCES) $(repeat_SOURCES)
     145SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
     146DIST_SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
    142147am__can_run_installinfo = \
    143148  case $$AM_UPDATE_INFO_DIR in \
     
    286291top_builddir = @top_builddir@
    287292top_srcdir = @top_srcdir@
     293busy_SOURCES = busy.c
     294busy_LDFLAGS = -pthread
    288295catchsig_SOURCES = catchsig.c
    289296repeat_SOURCES = repeat.c
     
    325332        -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS)
    326333
     334busy$(EXEEXT): $(busy_OBJECTS) $(busy_DEPENDENCIES) $(EXTRA_busy_DEPENDENCIES)
     335        @rm -f busy$(EXEEXT)
     336        $(AM_V_CCLD)$(busy_LINK) $(busy_OBJECTS) $(busy_LDADD) $(LIBS)
     337
    327338catchsig$(EXEEXT): $(catchsig_OBJECTS) $(catchsig_DEPENDENCIES) $(EXTRA_catchsig_DEPENDENCIES)
    328339        @rm -f catchsig$(EXEEXT)
     
    339350        -rm -f *.tab.c
    340351
     352@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/busy.Po@am__quote@
    341353@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/catchsig.Po@am__quote@
    342354@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/repeat.Po@am__quote@
Note: See TracChangeset for help on using the changeset viewer.