Changes in / [9802f4c:f2d1335]

Files:

• Jenkinsfile_disabled (modified) (1 diff)
• automake/missing (modified) (1 diff, 1 prop)
• libcfa/src/bits/defs.hfa (modified) (1 diff)
• libcfa/src/concurrency/invoke.h (modified) (2 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (1 diff)
• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Expr.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Print.cpp (modified) (1 diff)
• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/Common/PassVisitor.impl.h (modified) (3 diffs)
• src/Parser/parser.yy (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (2 diffs)
• src/SynTree/Expression.cc (modified) (1 diff)
• src/SynTree/Expression.h (modified) (1 diff)
• src/main.cc (modified) (1 diff)
• tests/.expect/gccExtensions.x64.txt (modified) (1 diff)
• tests/.expect/gccExtensions.x86.txt (modified) (1 diff)

Jenkinsfile_disabled

@@ -102 +102 @@
 
                 echo GitLogMessage()
-
-                // This is a complete hack but it solves problems with automake thinking it needs to regenerate makefiles
-                // We fudged automake/missing to handle that but automake stills bakes prints inside the makefiles
-                // and these cause more problems.
-                sh 'find . -name Makefile.in -exec touch {} +'
         }
 }

automake/missing

@@ -1 @@
-/usr/share/automake-1.15/missing
+#! /bin/sh
+# Tdelisle : having the Makefiles.in automatically regenerated causes problems
+#            when using multiple versions of automake, even if only on end user machines
+#            therefore I am disabling that feature by commenting this script
+exit 0

libcfa/src/bits/defs.hfa

@@ -47 +47 @@
 #define OPTIONAL_THREAD __attribute__((weak))
 #endif
-
-static inline long long rdtscl(void) {
-    unsigned int lo, hi;
-    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
-    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
-}

libcfa/src/concurrency/invoke.h

@@ -46 +46 @@
         #ifdef __cforall
         extern "Cforall" {
-                extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
+                extern thread_local struct KernelThreadData {
                         struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
@@ -55 +55 @@
                                 volatile bool in_progress;
                         } preemption_state;
-
-                        uint32_t rand_seed;
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
         }

libcfa/src/concurrency/kernel.cfa

@@ -133 +133 @@
         NULL,
         NULL,
-        { 1, false, false },
-        6u //this should be seeded better but due to a bug calling rdtsc doesn't work
+        { 1, false, false }
 };
 
@@ -261 +260 @@
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
-        // Because of a bug, we couldn't initialized the seed on construction
-        // Do it here
-        kernelTLS.rand_seed ^= rdtscl();
-
         processor * this = runner.proc;
         verify(this);

libcfa/src/concurrency/kernel_private.hfa

@@ -101 +101 @@
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
 
-static inline uint32_t tls_rand() {
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 7;
-        return kernelTLS.rand_seed;
-}
-
 
 void doregister( struct cluster & cltr );

src/AST/Convert.cpp

@@ -898 +898 @@
                 auto expr = visitBaseExpr( node,
                         new AsmExpr(
-                                new std::string(node->inout),
+                                get<Expression>().accept1(node->inout),
                                 get<Expression>().accept1(node->constraint),
                                 get<Expression>().accept1(node->operand)
@@ -2270 +2270 @@
                         new ast::AsmExpr(
                                 old->location,
-                                old->inout,
+                                GET_ACCEPT_1(inout, Expr),
                                 GET_ACCEPT_1(constraint, Expr),
                                 GET_ACCEPT_1(operand, Expr)

src/AST/Expr.hpp

@@ -583 +583 @@
 class AsmExpr final : public Expr {
 public:
-        std::string inout;
+        ptr<Expr> inout;
         ptr<Expr> constraint;
         ptr<Expr> operand;
 
-        AsmExpr( const CodeLocation & loc, const std::string & io, const Expr * con, const Expr * op )
+        AsmExpr( const CodeLocation & loc, const Expr * io, const Expr * con, const Expr * op )
         : Expr( loc ), inout( io ), constraint( con ), operand( op ) {}
 

src/AST/Pass.impl.hpp

@@ -1315 +1315 @@
                         maybe_accept( node, &AsmExpr::result );
                 }
+                maybe_accept( node, &AsmExpr::inout      );
                 maybe_accept( node, &AsmExpr::constraint );
                 maybe_accept( node, &AsmExpr::operand    );

src/AST/Print.cpp

@@ -1011 +1011 @@
                 os << "Asm Expression:" << endl;
                 ++indent;
-                if ( !node->inout.empty() ) os << "[" << node->inout << "] ";
+                if ( node->inout ) node->inout->accept( *this );
                 if ( node->constraint ) node->constraint->accept( *this );
                 if ( node->operand ) node->operand->accept( *this );

src/CodeGen/CodeGenerator.cc

@@ -786 +786 @@
 
         void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
-                if ( !asmExpr->inout.empty() ) {
+                if ( asmExpr->get_inout() ) {
                         output << "[ ";
-                        output << asmExpr->inout;
+                        asmExpr->get_inout()->accept( *visitor );
                         output << " ] ";
                 } // if
-                asmExpr->constraint->accept( *visitor );
+                asmExpr->get_constraint()->accept( *visitor );
                 output << " ( ";
-                asmExpr->operand->accept( *visitor );
+                asmExpr->get_operand()->accept( *visitor );
                 output << " )";
         }

src/Common/PassVisitor.impl.h

@@ -2452 +2452 @@
 
         indexerScopedAccept( node->result    , *this );
+        maybeAccept_impl   ( node->inout     , *this );
         maybeAccept_impl   ( node->constraint, *this );
         maybeAccept_impl   ( node->operand   , *this );
@@ -2463 +2464 @@
 
         indexerScopedAccept( node->result    , *this );
+        maybeAccept_impl   ( node->inout     , *this );
         maybeAccept_impl   ( node->constraint, *this );
         maybeAccept_impl   ( node->operand   , *this );
@@ -2475 +2477 @@
         indexerScopedMutate( node->env       , *this );
         indexerScopedMutate( node->result    , *this );
+        maybeMutate_impl   ( node->inout     , *this );
         maybeMutate_impl   ( node->constraint, *this );
         maybeMutate_impl   ( node->operand   , *this );

src/Parser/parser.yy

@@ -1423 +1423 @@
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild< Expression >( $3 ) ) ); }
-        | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild< Expression >( $6 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ), $1, maybeMoveBuild< Expression >( $3 ) ) ); }
+        | '[' constant_expression ']' string_literal '(' constant_expression ')'
+                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( $2 ), $4, maybeMoveBuild< Expression >( $6 ) ) ); }
         ;
 

src/ResolvExpr/Resolver.cc

@@ -485 +485 @@
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
+                if ( asmExpr->get_inout() ) {
+                        findVoidExpression( asmExpr->inout, indexer );
+                } // if
         }
 
@@ -1362 +1365 @@
                 asmExpr = ast::mutate_field(
                         asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
+
+                if ( asmExpr->inout ) {
+                        asmExpr = ast::mutate_field(
+                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
+                }
 
                 return asmExpr;

src/SynTree/Expression.cc

@@ -527 +527 @@
 }
 
-AsmExpr::AsmExpr( const AsmExpr & other ) : Expression( other ), inout( other.inout ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}
+AsmExpr::AsmExpr( const AsmExpr & other ) : Expression( other ), inout( maybeClone( other.inout ) ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}
 
 
 void AsmExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
-        if ( !inout.empty() ) os <<  "[" << inout << "] ";
+        if ( inout ) inout->print( os, indent+1 );
         if ( constraint ) constraint->print( os, indent+1 );
         if ( operand ) operand->print( os, indent+1 );

src/SynTree/Expression.h

@@ -575 +575 @@
 class AsmExpr : public Expression {
   public:
-        std::string inout;
+        Expression * inout;
         Expression * constraint;
         Expression * operand;
 
-        AsmExpr( const std::string * _inout, Expression * constraint, Expression * operand ) : inout( _inout ? *_inout : "" ), constraint( constraint ), operand( operand ) { delete _inout; }
+        AsmExpr( Expression * inout, Expression * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
         AsmExpr( const AsmExpr & other );
-        virtual ~AsmExpr() { delete constraint; delete operand; };
+        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
+
+        Expression * get_inout() const { return inout; }
+        void set_inout( Expression * newValue ) { inout = newValue; }
+
+        Expression * get_constraint() const { return constraint; }
+        void set_constraint( Expression * newValue ) { constraint = newValue; }
+
+        Expression * get_operand() const { return operand; }
+        void set_operand( Expression * newValue ) { operand = newValue; }
 
         virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }

src/main.cc

@@ -414 +414 @@
 
 
-static const char optstring[] = ":hlLmNnpP:S:tgwW:D:";
+static const char optstring[] = ":hlLmNnpP:S:twW:D:";
 
 enum { PreludeDir = 128 };

tests/.expect/gccExtensions.x64.txt

@@ -12 +12 @@
     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
-    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ src ] "r" ( _X3dsti_2 ) : "r0" );
+    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
     double _Complex _X2c1Cd_2;

tests/.expect/gccExtensions.x86.txt

@@ -12 +12 @@
     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
-    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ src ] "r" ( _X3dsti_2 ) : "r0" );
+    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
     double _Complex _X2c1Cd_2;