Merge pull request #115 from ThePortlandGroup/nv_stage

Pull 2017-06-28T16-49 Recent NVIDIA Changes

Author: sscalpone

tools/flang2/docs/xflag.n

@@ -2180,7 +2180,7 @@ do loops in pgf90.
 linux 64 C++ : revert to .rodata sections, instead of linkonce.r sections for
 jump tables in weak(templated) functions
 .XB 0x1000:
-use to enable new atomic implementation
+Disable new OpenMP atomic and reduction implementation.
 .XB 0x2000:
 Temporary disable collapse clause for distribute parallel loop in Fortran
 .XB 0x4000:

tools/flang2/flang2exe/atomic_common.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef PGI_ATOMIC_COMMON_DEF
+#define PGI_ATOMIC_COMMON_DEF
+
+/** Specifies memory order of an atomic operation.
+    Values corresponding to C11/C++11 memory orders are guaranteed
+    to match those of the target's C11/C++11 header. */
+typedef enum MEMORY_ORDER {
+  MO_RELAXED,
+  MO_CONSUME,
+  MO_ACQUIRE,
+  MO_RELEASE,
+  MO_ACQ_REL,
+  MO_SEQ_CST,
+  MO_MAX_DEF = MO_SEQ_CST, /**< maximum value with defined meaning */
+  MO_UNDEF = 0xFF          /**< denotes "undefined" */
+} MEMORY_ORDER;
+
+/** Specifies scope an atomic operation. */
+typedef enum SYNC_SCOPE {
+  SS_SINGLETHREAD, /**< Synchronize only within a thread (e.g. a signal fence). */
+  SS_PROCESS       /**< Synchronize with other threads. */
+} SYNC_SCOPE;
+
+/** Specifies source of an atomic operation. */
+typedef enum ATOMIC_ORIGIN {
+  AORG_CPLUS,                 /**< C++11 or C11 atomic operation */
+  AORG_OPENMP,                /**< OpenMP */
+  AORG_OPENACC,               /**< OpenACC */
+  AORG_MAX_DEF = AORG_OPENACC /**< maximum value with defined meaning */
+} ATOMIC_ORIGIN;
+
+/** Specifies a read-modify-write operation. */
+typedef enum ATOMIC_RMW_OP {
+  AOP_XCHG,
+  AOP_ADD,
+  AOP_SUB,
+  AOP_AND,
+  AOP_OR,
+  AOP_MIN,
+  AOP_MAX,
+  AOP_XOR,
+  AOP_MUL,
+  AOP_DIV,
+  AOP_SHR,
+  AOP_SHL,
+  AOP_EQV,
+  AOP_NEQV,
+  AOP_MAX_DEF = AOP_XOR, /**< maximum value with defined meaning */
+  AOP_UNDEF = 0xFF
+} ATOMIC_RMW_OP;
+
+typedef struct CMPXCHG_MEMORY_ORDER {
+  MEMORY_ORDER success;
+  MEMORY_ORDER failure;
+} CMPXCHG_MEMORY_ORDER;
+
+/** Information about an atomic operation.
+    The fields are declared unsigned because pgcc/pgc++ 17.1 sign-extends
+    them if they are declared as enum types. */
+typedef struct ATOMIC_INFO {
+  /*MSZ*/ unsigned msz : 8; /**< size of memory operand */
+  /*ATOMIC_RMW_OP*/ unsigned op : 8; /**< AOP_UNDEF except for ATOMICRMWx instructions. */
+  /*ATOMIC_ORIGIN*/ unsigned origin : 2;
+  /*SYNC_SCOPE*/ unsigned scope : 1;
+} ATOMIC_INFO;
+
+/** True if MEMORY_ORDER m performs an acquire operation.
+    MO_CONSUME is considered to perform an acquire. */
+#define MO_HAS_ACQUIRE(m) ((m) != MO_RELAXED && (m) != MO_RELEASE)
+
+/** True if MEMORY_ORDER m performs a release operation */
+#define MO_HAS_RELEASE(m) ((m) >= MO_RELEASE)
+
+#endif
+
+

tools/flang2/flang2exe/cgmain.c

@@ -5491,6 +5491,28 @@ find_load_cse(int ilix, OPERAND *load_op, LL_Type *llt)
   return NULL;
 }
 
+static LOGICAL
+openmp_atomic_ld(int ilix)
+{
+  ATOMIC_INFO info;
+  switch(ILI_OPC(ilix)) {
+  case IL_ATOMICLDI:
+  case IL_ATOMICLDKR:
+  case IL_ATOMICLDA:
+  case IL_ATOMICLDSP:
+  case IL_ATOMICLDDP:
+    break;
+  default:
+    return FALSE;
+  }
+  info = atomic_info(ilix);
+
+  if (info.origin == AORG_OPENMP)
+    return TRUE;
+  else
+    return FALSE;
+}
+
 /**
    \brief return new operand of type OT_TMP as result of loading \p load_op
    
@@ -5514,7 +5536,7 @@ make_load(int ilix, OPERAND *load_op, LL_Type *rslt_type, MSZ msz,
          0, ERR_Fatal);
 
   cse_op = NULL;
-  if (ENABLE_CSE_OPT) {
+  if (ENABLE_CSE_OPT && !openmp_atomic_ld(ilix)) {
     operand = find_load_cse(ilix, load_op, rslt_type);
     if (operand != NULL) {
       const int bits = ll_type_int_bits(operand->ll_type);
@@ -6858,6 +6880,9 @@ gen_llvm_expr(int ilix, LL_Type *expected_type)
           make_load(ilix, operand, operand->ll_type->sub_types[0], msz, flags);
     }
     break;
+  case IL_ATOMICLDA:
+  case IL_ATOMICLDSP:
+  case IL_ATOMICLDDP:
   case IL_ATOMICLDI:
   case IL_ATOMICLDKR: {
     LL_InstrListFlags flags;
@@ -7425,6 +7450,12 @@ gen_llvm_expr(int ilix, LL_Type *expected_type)
   case IL_DFRCS:
     if (expected_type == NULL)
       expected_type = make_lltype_from_dtype(DT_CMPLX);
+    goto _process_define_ili;
+  case IL_FREECD:
+    cse_opc = 1;
+  case IL_DFRCD:
+    if (expected_type == NULL)
+      expected_type = make_lltype_from_dtype(DT_DCMPLX);
 
   _process_define_ili:
     /* llvm_info.curr_ret_ili = ilix; */
@@ -8033,6 +8064,7 @@ gen_llvm_expr(int ilix, LL_Type *expected_type)
   case IL_ATOMICRMWKR:
     operand = gen_llvm_atomicrmw_expr(ilix);
     break;
+  case IL_CMPXCHG_OLDA:
   case IL_CMPXCHG_OLDI:
   case IL_CMPXCHG_OLDKR:
     operand = gen_llvm_cmpxchg_component(ilix, 0);
@@ -8042,6 +8074,7 @@ gen_llvm_expr(int ilix, LL_Type *expected_type)
     /* Any widening should do zero-extend, not sign-extend. */
     operand->flags |= OPF_ZEXT;
     break;
+  case IL_CMPXCHGA:
   case IL_CMPXCHGI:
   case IL_CMPXCHGKR:
     operand = gen_llvm_cmpxchg(ilix);

tools/flang2/flang2exe/expand.h

@@ -337,6 +337,10 @@ LOGICAL exp_end_atomic(int, int);
 #ifdef PD_IS_ATOMIC
 bool exp_atomic_intrinsic(PD_KIND pd, ILM *ilmp, int curilm);
 #endif
+void exp_mp_atomic_read(ILM *);
+void exp_mp_atomic_write(ILM *);
+void exp_mp_atomic_update(ILM *);
+void exp_mp_atomic_capture(ILM *);
 #endif /* EXPANDER_DECLARE_INTERNAL */
 
 int gethost_dumlen(int arg, ISZ_T address);