source: patches/gcc-4.8.2-branch_update-1.patch@ f21a0c4

ChangeLog

@@ -7 +7 @@
         * configure.ac: Also allow ISL 0.12.
         * configure: Regenerated.
 
+        PR tree-optimization/54094
+        * graphite-clast-to-gimple.c (translate_clast_for_loop): Derive the
+          scheduling dimension for the parallelism check from the polyhedral
+          information in the AST.
+        * graphite-dependences.c (carries_deps): Do not assume the schedule is
+          in 2D + 1 form.
+
 2013-05-31  Release Manager
 
         * GCC 4.8.1 released.

contrib/gcc_update

@@ -382 +382 @@
         fi
 
         revision=`$GCC_SVN info | awk '/Revision:/ { print $2 }'`
-        branch=`$GCC_SVN info | sed -ne "/URL:/ {
+        branch=`$GCC_SVN info | sed -ne "/^URL:/ {
             s,.*/trunk,trunk,
             s,.*/branches/,,
             s,.*/tags/,,

gcc/DATESTAMP

@@ -1 @@
-20131016
+20131101

gcc/ada/gcc-interface/utils.c

@@ -232 +232 @@
 static tree split_plus (tree, tree *);
 static tree float_type_for_precision (int, enum machine_mode);
 static tree convert_to_fat_pointer (tree, tree);
+static unsigned int scale_by_factor_of (tree, unsigned int);
 static bool potential_alignment_gap (tree, tree, tree);
 static void process_attributes (tree, struct attrib *);
 

gcc/alias.c

@@ -2871 +2871 @@
       /* Wipe the reg_seen array clean.  */
       bitmap_clear (reg_seen);
 
-      /* Mark all hard registers which may contain an address.
-         The stack, frame and argument pointers may contain an address.
-         An argument register which can hold a Pmode value may contain
-         an address even if it is not in BASE_REGS.
-
-         The address expression is VOIDmode for an argument and
-         Pmode for other registers.  */
-
-      memcpy (new_reg_base_value, static_reg_base_value,
-              FIRST_PSEUDO_REGISTER * sizeof (rtx));
+      /* Initialize the alias information for this pass.  */
+      for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+        if (static_reg_base_value[i])
+          {
+            new_reg_base_value[i] = static_reg_base_value[i];
+            bitmap_set_bit (reg_seen, i);
+          }
 
       /* Walk the insns adding values to the new_reg_base_value array.  */
       for (i = 0; i < rpo_cnt; i++)

gcc/cfgexpand.c

@@ -4707 +4707 @@
           if (e->insns.r)
             {
               rebuild_jump_labels_chain (e->insns.r);
-              /* Avoid putting insns before parm_birth_insn.  */
+              /* Put insns after parm birth, but before
+                 NOTE_INSNS_FUNCTION_BEG.  */
               if (e->src == ENTRY_BLOCK_PTR
-                  && single_succ_p (ENTRY_BLOCK_PTR)
-                  && parm_birth_insn)
+                  && single_succ_p (ENTRY_BLOCK_PTR))
                 {
                   rtx insns = e->insns.r;
                   e->insns.r = NULL_RTX;
-                  emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
+                  if (NOTE_P (parm_birth_insn)
+                      && NOTE_KIND (parm_birth_insn) == NOTE_INSN_FUNCTION_BEG)
+                    emit_insn_before_noloc (insns, parm_birth_insn, e->dest);
+                  else
+                    emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
                 }
               else
                 commit_one_edge_insertion (e);

gcc/cgraph.c

@@ -2596 +2596 @@
   FOR_EACH_FUNCTION (node)
     verify_cgraph_node (node);
 }
+
+/* Create external decl node for DECL.
+   The difference i nbetween cgraph_get_create_node and
+   cgraph_get_create_real_symbol_node is that cgraph_get_create_node
+   may return inline clone, while cgraph_get_create_real_symbol_node
+   will create a new node in this case.
+   FIXME: This function should be removed once clones are put out of decl
+   hash.  */
+
+struct cgraph_node *
+cgraph_get_create_real_symbol_node (tree decl)
+{
+  struct cgraph_node *first_clone = cgraph_get_node (decl);
+  struct cgraph_node *node;
+  /* create symbol table node.  even if inline clone exists, we can not take
+     it as a target of non-inlined call.  */
+  node = cgraph_get_node (decl);
+  if (node && !node->global.inlined_to)
+    return node;
+
+  node = cgraph_create_node (decl);
+
+  /* ok, we previously inlined the function, then removed the offline copy and
+     now we want it back for external call.  this can happen when devirtualizing
+     while inlining function called once that happens after extern inlined and
+     virtuals are already removed.  in this case introduce the external node
+     and make it available for call.  */
+  if (first_clone)
+    {
+      first_clone->clone_of = node;
+      node->clones = first_clone;
+      symtab_prevail_in_asm_name_hash ((symtab_node) node);
+      symtab_insert_node_to_hashtable ((symtab_node) node);
+      if (dump_file)
+        fprintf (dump_file, "Introduced new external node "
+                 "(%s/%i) and turned into root of the clone tree.\n",
+                 xstrdup (cgraph_node_name (node)), node->uid);
+    }
+  else if (dump_file)
+    fprintf (dump_file, "Introduced new external node "
+             "(%s/%i).\n", xstrdup (cgraph_node_name (node)), node->uid);
+  return node;
+}
 #include "gt-cgraph.h"

gcc/cgraph.h

@@ -575 +575 @@
 struct cgraph_node * cgraph_create_node (tree);
 struct cgraph_node * cgraph_create_empty_node (void);
 struct cgraph_node * cgraph_get_create_node (tree);
+struct cgraph_node * cgraph_get_create_real_symbol_node (tree);
 struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree);
 struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT,
                                        HOST_WIDE_INT, tree, tree);

gcc/cgraphbuild.c

@@ -73 +73 @@
       decl = get_base_var (*tp);
       if (TREE_CODE (decl) == FUNCTION_DECL)
         {
-          struct cgraph_node *node = cgraph_get_create_node (decl);
+          struct cgraph_node *node = cgraph_get_create_real_symbol_node (decl);
           if (!ctx->only_vars)
             cgraph_mark_address_taken_node (node);
           ipa_record_reference ((symtab_node)ctx->varpool_node,
@@ -143 +143 @@
     {
       struct cgraph_node *per_node;
 
-      per_node = cgraph_get_create_node (DECL_FUNCTION_PERSONALITY (node->symbol.decl));
+      per_node = cgraph_get_create_real_symbol_node (DECL_FUNCTION_PERSONALITY (node->symbol.decl));
       ipa_record_reference ((symtab_node)node, (symtab_node)per_node, IPA_REF_ADDR, NULL);
       cgraph_mark_address_taken_node (per_node);
     }
@@ -223 +223 @@
   addr = get_base_address (addr);
   if (TREE_CODE (addr) == FUNCTION_DECL)
     {
-      struct cgraph_node *node = cgraph_get_create_node (addr);
+      struct cgraph_node *node = cgraph_get_create_real_symbol_node (addr);
       cgraph_mark_address_taken_node (node);
       ipa_record_reference ((symtab_node)data,
                             (symtab_node)node,
@@ -252 +252 @@
     {
       /* ??? This can happen on platforms with descriptors when these are
          directly manipulated in the code.  Pretend that it's an address.  */
-      struct cgraph_node *node = cgraph_get_create_node (t);
+      struct cgraph_node *node = cgraph_get_create_real_symbol_node (t);
       cgraph_mark_address_taken_node (node);
       ipa_record_reference ((symtab_node)data,
                             (symtab_node)node,
@@ -330 +330 @@
             {
               tree fn = gimple_omp_parallel_child_fn (stmt);
               ipa_record_reference ((symtab_node)node,
-                                    (symtab_node)cgraph_get_create_node (fn),
+                                    (symtab_node)cgraph_get_create_real_symbol_node (fn),
                                     IPA_REF_ADDR, stmt);
             }
           if (gimple_code (stmt) == GIMPLE_OMP_TASK)
@@ -338 +338 @@
               tree fn = gimple_omp_task_child_fn (stmt);
               if (fn)
                 ipa_record_reference ((symtab_node)node,
-                                      (symtab_node) cgraph_get_create_node (fn),
+                                      (symtab_node) cgraph_get_create_real_symbol_node (fn),
                                       IPA_REF_ADDR, stmt);
               fn = gimple_omp_task_copy_fn (stmt);
               if (fn)
                 ipa_record_reference ((symtab_node)node,
-                                      (symtab_node)cgraph_get_create_node (fn),
+                                      (symtab_node)cgraph_get_create_real_symbol_node (fn),
                                       IPA_REF_ADDR, stmt);
             }
         }

gcc/combine.c

@@ -5798 +5798 @@
                 return x;
             }
 
-          /* If the code changed, return a whole new comparison.  */
-          if (new_code != code)
+          /* If the code changed, return a whole new comparison.
+             We also need to avoid using SUBST in cases where
+             simplify_comparison has widened a comparison with a CONST_INT,
+             since in that case the wider CONST_INT may fail the sanity
+             checks in do_SUBST.  */
+          if (new_code != code
+              || (CONST_INT_P (op1)
+                  && GET_MODE (op0) != GET_MODE (XEXP (x, 0))
+                  && GET_MODE (op0) != GET_MODE (XEXP (x, 1))))
             return gen_rtx_fmt_ee (new_code, mode, op0, op1);
 
           /* Otherwise, keep this operation, but maybe change its operands.

gcc/config/i386/i386.c

@@ -2983 +2983 @@
       {"bdver3", PROCESSOR_BDVER3, CPU_BDVER3,
         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
-        | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
+        | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
         | PTA_FMA | PTA_PRFCHW | PTA_FXSR | PTA_XSAVE 
         | PTA_XSAVEOPT},
@@ -7235 +7235 @@
   switch (regno)
     {
     case AX_REG:
+    case DX_REG:
       return true;
-
-    case FIRST_FLOAT_REG:
+    case DI_REG:
+    case SI_REG:
+      return TARGET_64BIT && ix86_abi != MS_ABI;
+
+      /* Complex values are returned in %st(0)/%st(1) pair.  */
+    case ST0_REG:
+    case ST1_REG:
       /* TODO: The function should depend on current function ABI but
        builtins.c would need updating then. Therefore we use the
        default ABI.  */
@@ -7245 +7251 @@
         return false;
       return TARGET_FLOAT_RETURNS_IN_80387;
 
-    case FIRST_SSE_REG:
+      /* Complex values are returned in %xmm0/%xmm1 pair.  */
+    case XMM0_REG:
+    case XMM1_REG:
       return TARGET_SSE;
 
-    case FIRST_MMX_REG:
+    case MM0_REG:
       if (TARGET_MACHO || TARGET_64BIT)
         return false;
       return TARGET_MMX;
@@ -13817 +13825 @@
          Those same assemblers have the same but opposite lossage on cmov.  */
       if (mode == CCmode)
         suffix = fp ? "nbe" : "a";
-      else if (mode == CCCmode)
-        suffix = "b";
       else
         gcc_unreachable ();
       break;
@@ -13840 +13846 @@
         }
       break;
     case LTU:
-      gcc_assert (mode == CCmode || mode == CCCmode);
-      suffix = "b";
+      if (mode == CCmode)
+        suffix = "b";
+      else if (mode == CCCmode)
+        suffix = "c";
+      else
+        gcc_unreachable ();
       break;
     case GE:
       switch (mode)
@@ -13861 +13871 @@
         }
       break;
     case GEU:
-      /* ??? As above.  */
-      gcc_assert (mode == CCmode || mode == CCCmode);
-      suffix = fp ? "nb" : "ae";
+      if (mode == CCmode)
+        suffix = fp ? "nb" : "ae";
+      else if (mode == CCCmode)
+        suffix = "nc";
+      else
+        gcc_unreachable ();
       break;
     case LE:
       gcc_assert (mode == CCmode || mode == CCGCmode || mode == CCNOmode);
       suffix = "le";
       break;
     case LEU:
-      /* ??? As above.  */
       if (mode == CCmode)
         suffix = "be";
-      else if (mode == CCCmode)
-        suffix = fp ? "nb" : "ae";
       else
         gcc_unreachable ();
       break;
@@ -18486 +18496 @@
         return CCmode;
     case GTU:                   /* CF=0 & ZF=0 */
     case LEU:                   /* CF=1 | ZF=1 */
-      /* Detect overflow checks.  They need just the carry flag.  */
-      if (GET_CODE (op0) == MINUS
-          && rtx_equal_p (op1, XEXP (op0, 0)))
-        return CCCmode;
-      else
-        return CCmode;
+      return CCmode;
       /* Codes possibly doable only with sign flag when
          comparing against zero.  */
     case GE:                    /* SF=OF   or   SF=0 */

gcc/config/i386/i386.md

@@ -6589 +6589 @@
    (set_attr "use_carry" "1")
    (set_attr "mode" "<MODE>")])
 
 
-;; Overflow setting add and subtract instructions
+;; Overflow setting add instructions
 
 (define_insn "*add<mode>3_cconly_overflow"

gcc/config/rs6000/rs6000.md

@@ -2412 +2412 @@
                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
                     (const_int 0)))
    (clobber (match_scratch:SI 3 "=r,r"))]
-  ""
+  "TARGET_32BIT"
   "@
    mullw. %3,%1,%2
    #"
@@ -2425 +2425 @@
                              (match_operand:SI 2 "gpc_reg_operand" ""))
                     (const_int 0)))
    (clobber (match_scratch:SI 3 ""))]
-  "reload_completed"
+  "TARGET_32BIT && reload_completed"
   [(set (match_dup 3)
         (mult:SI (match_dup 1) (match_dup 2)))
    (set (match_dup 0)
@@ -2440 +2440 @@
                     (const_int 0)))
    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
         (mult:SI (match_dup 1) (match_dup 2)))]
-  ""
+  "TARGET_32BIT"
   "@
    mullw. %0,%1,%2
    #"
@@ -2454 +2454 @@
                     (const_int 0)))
    (set (match_operand:SI 0 "gpc_reg_operand" "")
         (mult:SI (match_dup 1) (match_dup 2)))]
-  "reload_completed"
+  "TARGET_32BIT && reload_completed"
   [(set (match_dup 0)
         (mult:SI (match_dup 1) (match_dup 2)))
    (set (match_dup 3)

gcc/config/sh/sh.opt

@@ -21 +21 @@
 ;; Used for various architecture options.
 Mask(SH_E)
 
-;; Set if the default precision of th FPU is single.
+;; Set if the default precision of the FPU is single.
 Mask(FPU_SINGLE)
 
 ;; Set if the a double-precision FPU is present but is restricted to

gcc/cp/decl2.c

@@ -3960 +3960 @@
   expand_or_defer_fn (finish_function (0));
 }
 
+/* The entire file is now complete.  If requested, dump everything
+   to a file.  */
+
+static void
+dump_tu (void)
+{
+  int flags;
+  FILE *stream = dump_begin (TDI_tu, &flags);
+
+  if (stream)
+    {
+      dump_node (global_namespace, flags & ~TDF_SLIM, stream);
+      dump_end (TDI_tu, stream);
+    }
+}
+
 /* This routine is called at the end of compilation.
    Its job is to create all the code needed to initialize and
    destroy the global aggregates.  We do the destruction
@@ -3990 +4006 @@
   if (pch_file)
     {
       c_common_write_pch ();
+      dump_tu ();
       return;
     }
 
@@ -4359 +4376 @@
 
   /* The entire file is now complete.  If requested, dump everything
      to a file.  */
-  {
-    int flags;
-    FILE *stream = dump_begin (TDI_tu, &flags);
-
-    if (stream)
-      {
-        dump_node (global_namespace, flags & ~TDF_SLIM, stream);
-        dump_end (TDI_tu, stream);
-      }
-  }
+  dump_tu ();
 
   if (flag_detailed_statistics)
     {

gcc/cp/except.c

@@ -380 +380 @@
 {
   tree type = body ? TREE_TYPE (body) : void_type_node;
 
+  if (!flag_exceptions)
+    return body;
+
   if (cond && !value_dependent_expression_p (cond))
     {
       cond = cxx_constant_value (cond);

gcc/cp/parser.c

@@ -6421 +6421 @@
   /* Look for the `~'.  */
   cp_parser_require (parser, CPP_COMPL, RT_COMPL);
 
-  /* Once we see the ~, this has to be a pseudo-destructor.  */
-  if (!processing_template_decl && !cp_parser_error_occurred (parser))
-    cp_parser_commit_to_tentative_parse (parser);
-
   /* Look for the type-name again.  We are not responsible for
      checking that it matches the first type-name.  */
   *type = cp_parser_nonclass_name (parser);

gcc/cp/semantics.c

@@ -9481 +9481 @@
   /* In unevaluated context this isn't an odr-use, so just return the
      nearest 'this'.  */
   if (cp_unevaluated_operand)
-    return lookup_name (this_identifier);
+    {
+      /* In an NSDMI the fake 'this' pointer that we're using for
+         parsing is in scope_chain.  */
+      if (LAMBDA_EXPR_EXTRA_SCOPE (lambda)
+          && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (lambda)) == FIELD_DECL)
+        return scope_chain->x_current_class_ptr;
+      return lookup_name (this_identifier);
+    }
 
   /* Try to default capture 'this' if we can.  */
   if (!this_capture

gcc/gimple-fold.c

@@ -178 +178 @@
           /* Make sure we create a cgraph node for functions we'll reference.
              They can be non-existent if the reference comes from an entry
              of an external vtable for example.  */
-          cgraph_get_create_node (base);
+          cgraph_get_create_real_symbol_node (base);
         }
       /* Fixup types in global initializers.  */
       if (TREE_TYPE (TREE_TYPE (cval)) != TREE_TYPE (TREE_OPERAND (cval, 0)))

gcc/go/go-gcc.cc

@@ -232 +232 @@
   Bexpression*
   convert_expression(Btype* type, Bexpression* expr, Location);
 
+  Bexpression*
+  function_code_expression(Bfunction*, Location);
+
   // Statements.
 
   Bstatement*
@@ -334 +337 @@
   Bexpression*
   label_address(Blabel*, Location);
 
+  // Functions.
+
+  Bfunction*
+  error_function()
+  { return this->make_function(error_mark_node); }
+
+  Bfunction*
+  function(Btype* fntype, const std::string& name, const std::string& asm_name,
+           bool is_visible, bool is_declaration, bool is_inlinable,
+           bool disable_split_stack, bool in_unique_section, Location);
+
  private:
   // Make a Bexpression from a tree.
   Bexpression*
@@ -350 +364 @@
   make_type(tree t)
   { return new Btype(t); }
 
+  Bfunction*
+  make_function(tree t)
+  { return new Bfunction(t); }
+
   Btype*
   fill_in_struct(Btype*, const std::vector<Btyped_identifier>&);
 
@@ -966 +984 @@
   return tree_to_expr(ret);
 }
 
+// Get the address of a function.
+
+Bexpression*
+Gcc_backend::function_code_expression(Bfunction* bfunc, Location location)
+{
+  tree func = bfunc->get_tree();
+  if (func == error_mark_node)
+    return this->error_expression();
+
+  tree ret = build_fold_addr_expr_loc(location.gcc_location(), func);
+  return this->make_expression(ret);
+}
+
 // An expression as a statement.
 
 Bstatement*
@@ -1724 +1755 @@
   return this->make_expression(ret);
 }
 
+// Declare or define a new function.
+
+Bfunction*
+Gcc_backend::function(Btype* fntype, const std::string& name,
+                      const std::string& asm_name, bool is_visible,
+                      bool is_declaration, bool is_inlinable,
+                      bool disable_split_stack, bool in_unique_section,
+                      Location location)
+{
+  tree functype = fntype->get_tree();
+  if (functype != error_mark_node)
+    {
+      gcc_assert(FUNCTION_POINTER_TYPE_P(functype));
+      functype = TREE_TYPE(functype);
+    }
+  tree id = get_identifier_from_string(name);
+  if (functype == error_mark_node || id == error_mark_node)
+    return this->error_function();
+
+  tree decl = build_decl(location.gcc_location(), FUNCTION_DECL, id, functype);
+  if (!asm_name.empty())
+    SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
+  if (is_visible)
+    TREE_PUBLIC(decl) = 1;
+  if (is_declaration)
+    DECL_EXTERNAL(decl) = 1;
+  else
+    {
+      tree restype = TREE_TYPE(functype);
+      tree resdecl =
+          build_decl(location.gcc_location(), RESULT_DECL, NULL_TREE, restype);
+      DECL_ARTIFICIAL(resdecl) = 1;
+      DECL_IGNORED_P(resdecl) = 1;
+      DECL_CONTEXT(resdecl) = decl;
+      DECL_RESULT(decl) = resdecl;
+    }
+  if (!is_inlinable)
+    DECL_UNINLINABLE(decl) = 1;
+  if (disable_split_stack)
+    {
+      tree attr = get_identifier("__no_split_stack__");
+      DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
+    }
+  if (in_unique_section)
+    resolve_unique_section(decl, 0, 1);
+
+  go_preserve_from_gc(decl);
+  return new Bfunction(decl);
+}
+
 // The single backend.
 
 static Gcc_backend gcc_backend;
@@ -1799 +1880 @@
 {
   return bv->get_tree();
 }
+
+tree
+function_to_tree(Bfunction* bf)
+{
+  return bf->get_tree();
+}

gcc/go/gofrontend/backend.h

@@ -23 +23 @@
 // The backend representation of a statement.
 class Bstatement;
 
-// The backend representation of a function definition.
+// The backend representation of a function definition or declaration.
 class Bfunction;
 
 // The backend representation of a block.
@@ -266 +266 @@
   virtual Bexpression*
   convert_expression(Btype* type, Bexpression* expr, Location) = 0;
 
+  // Create an expression for the address of a function.  This is used to
+  // get the address of the code for a function.
+  virtual Bexpression*
+  function_code_expression(Bfunction*, Location) = 0;
+
   // Statements.
 
   // Create an error statement.  This is used for cases which should
@@ -498 +503 @@
   // recover.
   virtual Bexpression*
   label_address(Blabel*, Location) = 0;
+
+  // Functions.
+
+  // Create an error function.  This is used for cases which should
+  // not occur in a correct program, in order to keep the compilation
+  // going without crashing.
+  virtual Bfunction*
+  error_function() = 0;
+
+  // Declare or define a function of FNTYPE.
+  // NAME is the Go name of the function. ASM_NAME, if not the empty string, is
+  // the name that should be used in the symbol table; this will be non-empty if
+  // a magic extern comment is used.
+  // IS_VISIBLE is true if this function should be visible outside of the
+  // current compilation unit. IS_DECLARATION is true if this is a function
+  // declaration rather than a definition; the function definition will be in
+  // another compilation unit.
+  // IS_INLINABLE is true if the function can be inlined.
+  // DISABLE_SPLIT_STACK is true if this function may not split the stack; this
+  // is used for the implementation of recover.
+  // IN_UNIQUE_SECTION is true if this function should be put into a unique
+  // location if possible; this is used for field tracking.
+  virtual Bfunction*
+  function(Btype* fntype, const std::string& name, const std::string& asm_name,
+           bool is_visible, bool is_declaration, bool is_inlinable,
+           bool disable_split_stack, bool in_unique_section, Location) = 0;
 };
 
 // The backend interface has to define this function.
@@ -517 +548 @@
 extern tree stat_to_tree(Bstatement*);
 extern tree block_to_tree(Bblock*);
 extern tree var_to_tree(Bvariable*);
+extern tree function_to_tree(Bfunction*);
 
 #endif // !defined(GO_BACKEND_H)

gcc/go/gofrontend/expressions.cc

@@ -1219 +1219 @@
 
 // Get the tree for the code of a function expression.
 
-tree
+Bexpression*
 Func_expression::get_code_pointer(Gogo* gogo, Named_object* no, Location loc)
 {
   Function_type* fntype;
@@ -1237 +1237 @@
       error_at(loc,
                "invalid use of special builtin function %qs; must be called",
                no->message_name().c_str());
-      return error_mark_node;
+      return gogo->backend()->error_expression();
     }
 
-  tree id = no->get_id(gogo);
-  if (id == error_mark_node)
-    return error_mark_node;
-
-  tree fndecl;
+  Bfunction* fndecl;
   if (no->is_function())
-    fndecl = no->func_value()->get_or_make_decl(gogo, no, id);
+    fndecl = no->func_value()->get_or_make_decl(gogo, no);
   else if (no->is_function_declaration())
-    fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
+    fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no);
   else
     go_unreachable();
 
-  if (fndecl == error_mark_node)
-    return error_mark_node;
-
-  return build_fold_addr_expr_loc(loc.gcc_location(), fndecl);
+  return gogo->backend()->function_code_expression(fndecl, loc);
 }
 
 // Get the tree for a function expression.  This is used when we take
@@ -1492 +1485 @@
 tree
 Func_code_reference_expression::do_get_tree(Translate_context* context)
 {
-  return Func_expression::get_code_pointer(context->gogo(), this->function_,
-                                           this->location());
+  Bexpression* ret =
+      Func_expression::get_code_pointer(context->gogo(), this->function_,
+                                        this->location());
+  return expr_to_tree(ret);
 }
 
 // Make a reference to the code of a function.
@@ -3055 +3050 @@
   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
 
   bool
-  do_is_constant() const
-  { return this->expr_->is_constant(); }
+  do_is_constant() const;
 
   bool
   do_numeric_constant_value(Numeric_constant*) const;
@@ -3198 +3192 @@
   return this;
 }
 
+// Return whether a type conversion is a constant.
+
+bool
+Type_conversion_expression::do_is_constant() const
+{
+  if (!this->expr_->is_constant())
+    return false;
+
+  // A conversion to a type that may not be used as a constant is not
+  // a constant.  For example, []byte(nil).
+  Type* type = this->type_;
+  if (type->integer_type() == NULL
+      && type->float_type() == NULL
+      && type->complex_type() == NULL
+      && !type->is_boolean_type()
+      && !type->is_string_type())
+    return false;
+
+  return true;
+}
+
 // Return the constant numeric value if there is one.
 
 bool
@@ -5586 +5601 @@
       subcontext.type = NULL;
     }
 
+  if (this->op_ == OPERATOR_ANDAND || this->op_ == OPERATOR_OROR)
+    {
+      // For a logical operation, the context does not determine the
+      // types of the operands.  The operands must be some boolean
+      // type but if the context has a boolean type they do not
+      // inherit it.  See http://golang.org/issue/3924.
+      subcontext.type = NULL;
+    }
+
   // Set the context for the left hand operand.
   if (is_shift_op)
     {
@@ -5967 +5991 @@
                                 right);
     }
 
+  // For complex division Go wants slightly different results than the
+  // GCC library provides, so we have our own runtime routine.
+  if (this->op_ == OPERATOR_DIV && this->left_->type()->complex_type() != NULL)
+    {
+      const char *name;
+      tree *pdecl;
+      Type* ctype;
+      static tree complex64_div_decl;
+      static tree complex128_div_decl;
+      switch (this->left_->type()->complex_type()->bits())
+        {
+        case 64:
+          name = "__go_complex64_div";
+          pdecl = &complex64_div_decl;
+          ctype = Type::lookup_complex_type("complex64");
+          break;
+        case 128:
+          name = "__go_complex128_div";
+          pdecl = &complex128_div_decl;
+          ctype = Type::lookup_complex_type("complex128");
+          break;
+        default:
+          go_unreachable();
+        }
+      Btype* cbtype = ctype->get_backend(gogo);
+      tree ctype_tree = type_to_tree(cbtype);
+      return Gogo::call_builtin(pdecl,
+                                this->location(),
+                                name,
+                                2,
+                                ctype_tree,
+                                ctype_tree,
+                                fold_convert_loc(gccloc, ctype_tree, left),
+                                type,
+                                fold_convert_loc(gccloc, ctype_tree, right));
+    }
+
   tree compute_type = excess_precision_type(type);
   if (compute_type != NULL_TREE)
     {
@@ -7191 +7252 @@
   if (this->code_ == BUILTIN_OFFSETOF)
     {
       Expression* arg = this->one_arg();
+
+      if (arg->bound_method_expression() != NULL
+          || arg->interface_field_reference_expression() != NULL)
+        {
+          this->report_error(_("invalid use of method value as argument "
+                               "of Offsetof"));
+          return this;
+        }
+
       Field_reference_expression* farg = arg->field_reference_expression();
       while (farg != NULL)
         {
@@ -7200 +7270 @@
           // it must not be reached through pointer indirections.
           if (farg->expr()->deref() != farg->expr())
             {
-              this->report_error(_("argument of Offsetof implies indirection of an embedded field"));
+              this->report_error(_("argument of Offsetof implies "
+                                   "indirection of an embedded field"));
               return this;
             }
           // Go up until we reach the original base.
@@ -7476 +7547 @@
       switch (nc.to_unsigned_long(&v))
         {
         case Numeric_constant::NC_UL_VALID:
-          return true;
+          break;
         case Numeric_constant::NC_UL_NOTINT:
           error_at(e->location(), "non-integer %s argument to make",
                    is_length ? "len" : "cap");
@@ -7488 +7559 @@
         case Numeric_constant::NC_UL_BIG:
           // We don't want to give a compile-time error for a 64-bit
           // value on a 32-bit target.
-          return true;
+          break;
         }
+
+      mpz_t val;
+      if (!nc.to_int(&val))
+        go_unreachable();
+      int bits = mpz_sizeinbase(val, 2);
+      mpz_clear(val);
+      Type* int_type = Type::lookup_integer_type("int");
+      if (bits >= int_type->integer_type()->bits())
+        {
+          error_at(e->location(), "%s argument too large for make",
+                   is_length ? "len" : "cap");
+          return false;
+        }
+
+      return true;
     }
 
   if (e->type()->integer_type() != NULL)
@@ -7595 +7681 @@
 bool
 Builtin_call_expression::do_is_constant() const
 {
+  if (this->is_error_expression())
+    return true;
   switch (this->code_)
     {
     case BUILTIN_LEN:
@@ -9744 +9832 @@
     }
 
   tree fntype_tree = type_to_tree(fntype->get_backend(gogo));
-  if (fntype_tree == error_mark_node)
-    return error_mark_node;
-  go_assert(POINTER_TYPE_P(fntype_tree));
-  if (TREE_TYPE(fntype_tree) == error_mark_node)
-    return error_mark_node;
-  go_assert(TREE_CODE(TREE_TYPE(fntype_tree)) == RECORD_TYPE);
-  tree fnfield_type = TREE_TYPE(TYPE_FIELDS(TREE_TYPE(fntype_tree)));
-  if (fnfield_type == error_mark_node)
+  tree fnfield_type = type_to_tree(fntype->get_backend_fntype(gogo));
+  if (fntype_tree == error_mark_node || fnfield_type == error_mark_node)
     return error_mark_node;
   go_assert(FUNCTION_POINTER_TYPE_P(fnfield_type));
   tree rettype = TREE_TYPE(TREE_TYPE(fnfield_type));
@@ -9763 +9845 @@
   if (func != NULL)
     {
       Named_object* no = func->named_object();
-      fn = Func_expression::get_code_pointer(gogo, no, location);
+      fn = expr_to_tree(Func_expression::get_code_pointer(gogo, no, location));
       if (!has_closure)
         closure_tree = NULL_TREE;
       else
@@ -10817 +10899 @@
 void
 String_index_expression::do_check_types(Gogo*)
 {
-  if (this->start_->type()->integer_type() == NULL)
+  Numeric_constant nc;
+  unsigned long v;
+  if (this->start_->type()->integer_type() == NULL
+      && !this->start_->type()->is_error()
+      && (!this->start_->numeric_constant_value(&nc)
+          || nc.to_unsigned_long(&v) == Numeric_constant::NC_UL_NOTINT))
     this->report_error(_("index must be integer"));
   if (this->end_ != NULL
       && this->end_->type()->integer_type() == NULL
-      && !this->end_->is_nil_expression())
+      && !this->end_->type()->is_error()
+      && !this->end_->is_nil_expression()
+      && !this->end_->is_error_expression()
+      && (!this->end_->numeric_constant_value(&nc)
+          || nc.to_unsigned_long(&v) == Numeric_constant::NC_UL_NOTINT))
     this->report_error(_("slice end must be integer"));
 
   std::string sval;

gcc/go/gofrontend/expressions.h

@@ -1514 +1514 @@
   closure()
   { return this->closure_; }
 
-  // Return a tree for the code for a function.
-  static tree
+  // Return a backend expression for the code of a function.
+  static Bexpression*
   get_code_pointer(Gogo*, Named_object* function, Location loc);
 
  protected:

gcc/go/gofrontend/gogo-tree.cc

@@ -985 +985 @@
   delete[] vec;
 }
 
-// Get a tree for the identifier for a named object.
-
-tree
-Named_object::get_id(Gogo* gogo)
-{
-  go_assert(!this->is_variable() && !this->is_result_variable());
-  std::string decl_name;
-  if (this->is_function_declaration()
-      && !this->func_declaration_value()->asm_name().empty())
-    decl_name = this->func_declaration_value()->asm_name();
-  else if (this->is_type()
-           && Linemap::is_predeclared_location(this->type_value()->location()))
-    {
-      // We don't need the package name for builtin types.
-      decl_name = Gogo::unpack_hidden_name(this->name_);
-    }
-  else
-    {
-      std::string package_name;
-      if (this->package_ == NULL)
-        package_name = gogo->package_name();
-      else
-        package_name = this->package_->package_name();
-
-      // Note that this will be misleading if this is an unexported
-      // method generated for an embedded imported type.  In that case
-      // the unexported method should have the package name of the
-      // package from which it is imported, but we are going to give
-      // it our package name.  Fixing this would require knowing the
-      // package name, but we only know the package path.  It might be
-      // better to use package paths here anyhow.  This doesn't affect
-      // the assembler code, because we always set that name in
-      // Function::get_or_make_decl anyhow.  FIXME.
-
-      decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
-
-      Function_type* fntype;
-      if (this->is_function())
-        fntype = this->func_value()->type();
-      else if (this->is_function_declaration())
-        fntype = this->func_declaration_value()->type();
-      else
-        fntype = NULL;
-      if (fntype != NULL && fntype->is_method())
-        {
-          decl_name.push_back('.');
-          decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
-        }
-    }
-  if (this->is_type())
-    {
-      unsigned int index;
-      const Named_object* in_function = this->type_value()->in_function(&index);
-      if (in_function != NULL)
-        {
-          decl_name += '$' + Gogo::unpack_hidden_name(in_function->name());
-          if (index > 0)
-            {
-              char buf[30];
-              snprintf(buf, sizeof buf, "%u", index);
-              decl_name += '$';
-              decl_name += buf;
-            }
-        }
-    }
-  return get_identifier_from_string(decl_name);
-}
-
 // Get a tree for a named object.
 
 tree
@@ -1067 +999 @@
       return error_mark_node;
     }
 
-  tree name;
-  if (this->classification_ == NAMED_OBJECT_TYPE)
-    name = NULL_TREE;
-  else
-    name = this->get_id(gogo);
   tree decl;
   switch (this->classification_)
     {
@@ -1099 +1026 @@
               decl = error_mark_node;
             else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
               {
+                tree name = get_identifier_from_string(this->get_id(gogo));
                 decl = build_decl(named_constant->location().gcc_location(),
                                   CONST_DECL, name, TREE_TYPE(expr_tree));
                 DECL_INITIAL(decl) = expr_tree;
@@ -1161 +1089 @@
     case NAMED_OBJECT_FUNC:
       {
         Function* func = this->u_.func_value;
-        decl = func->get_or_make_decl(gogo, this, name);
+        decl = function_to_tree(func->get_or_make_decl(gogo, this));
         if (decl != error_mark_node)
           {
             if (func->block() != NULL)
@@ -1286 +1214 @@
   return block_tree;
 }
 
-// Get a tree for a function decl.
+// Get the backend representation.
 
-tree
-Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+Bfunction*
+Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no)
 {
-  if (this->fndecl_ == NULL_TREE)
-    {
-      tree functype = type_to_tree(this->type_->get_backend(gogo));
-
-      if (functype != error_mark_node)
-        {
-          // The type of a function comes back as a pointer to a
-          // struct whose first field is the function, but we want the
-          // real function type for a function declaration.
-          go_assert(POINTER_TYPE_P(functype)
-                    && TREE_CODE(TREE_TYPE(functype)) == RECORD_TYPE);
-          functype = TREE_TYPE(TYPE_FIELDS(TREE_TYPE(functype)));
-          go_assert(FUNCTION_POINTER_TYPE_P(functype));
-          functype = TREE_TYPE(functype);
-        }
-
-      if (functype == error_mark_node)
-        this->fndecl_ = error_mark_node;
-      else
-        {
-          tree decl = build_decl(this->location().gcc_location(), FUNCTION_DECL,
-                                 id, functype);
-
-          this->fndecl_ = decl;
-
-          if (no->package() != NULL)
-            ;
-          else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
-            ;
-          else if (Gogo::unpack_hidden_name(no->name()) == "init"
-                   && !this->type_->is_method())
-            ;
-          else if (Gogo::unpack_hidden_name(no->name()) == "main"
-                   && gogo->is_main_package())
-            TREE_PUBLIC(decl) = 1;
-          // Methods have to be public even if they are hidden because
-          // they can be pulled into type descriptors when using
-          // anonymous fields.
-          else if (!Gogo::is_hidden_name(no->name())
-                   || this->type_->is_method())
-            {
-              TREE_PUBLIC(decl) = 1;
-              std::string pkgpath = gogo->pkgpath_symbol();
-              if (this->type_->is_method()
-                  && Gogo::is_hidden_name(no->name())
-                  && Gogo::hidden_name_pkgpath(no->name()) != gogo->pkgpath())
-                {
-                  // This is a method we created for an unexported
-                  // method of an imported embedded type.  We need to
-                  // use the pkgpath of the imported package to avoid
-                  // a possible name collision.  See bug478 for a test
-                  // case.
-                  pkgpath = Gogo::hidden_name_pkgpath(no->name());
-                  pkgpath = Gogo::pkgpath_for_symbol(pkgpath);
-                }
-
-              std::string asm_name = pkgpath;
-              asm_name.append(1, '.');
-              asm_name.append(Gogo::unpack_hidden_name(no->name()));
-              if (this->type_->is_method())
-                {
-                  asm_name.append(1, '.');
-                  Type* rtype = this->type_->receiver()->type();
-                  asm_name.append(rtype->mangled_name(gogo));
-                }
-              SET_DECL_ASSEMBLER_NAME(decl,
-                                      get_identifier_from_string(asm_name));
-            }
-
-          // Why do we have to do this in the frontend?
-          tree restype = TREE_TYPE(functype);
-          tree resdecl =
-            build_decl(this->location().gcc_location(), RESULT_DECL, NULL_TREE,
-                       restype);
-          DECL_ARTIFICIAL(resdecl) = 1;
-          DECL_IGNORED_P(resdecl) = 1;
-          DECL_CONTEXT(resdecl) = decl;
-          DECL_RESULT(decl) = resdecl;
-
-          // If a function calls the predeclared recover function, we
-          // can't inline it, because recover behaves differently in a
-          // function passed directly to defer.  If this is a recover
-          // thunk that we built to test whether a function can be
-          // recovered, we can't inline it, because that will mess up
-          // our return address comparison.
-          if (this->calls_recover_ || this->is_recover_thunk_)
-            DECL_UNINLINABLE(decl) = 1;
-
-          // If this is a thunk created to call a function which calls
-          // the predeclared recover function, we need to disable
-          // stack splitting for the thunk.
-          if (this->is_recover_thunk_)
-            {
-              tree attr = get_identifier("__no_split_stack__");
-              DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
-            }
-
-          if (this->in_unique_section_)
-            resolve_unique_section (decl, 0, 1);
-
-          go_preserve_from_gc(decl);
-        }
-    }
-  return this->fndecl_;
-}
-
-// Get a tree for a function declaration.
-
-tree
-Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
-{
-  if (this->fndecl_ == NULL_TREE)
+  if (this->fndecl_ == NULL)
     {
       // Let Go code use an asm declaration to pick up a builtin
       // function.
@@ -1412 +1229 @@
             builtin_functions.find(this->asm_name_);
           if (p != builtin_functions.end())
             {
-              this->fndecl_ = p->second;
+              this->fndecl_ = tree_to_function(p->second);
               return this->fndecl_;
             }
         }
 
-      tree functype = type_to_tree(this->fntype_->get_backend(gogo));
+      std::string asm_name;
+      if (this->asm_name_.empty())
+        {
+          asm_name = (no->package() == NULL
+                                  ? gogo->pkgpath_symbol()
+                                  : no->package()->pkgpath_symbol());
+          asm_name.append(1, '.');
+          asm_name.append(Gogo::unpack_hidden_name(no->name()));
+          if (this->fntype_->is_method())
+            {
+              asm_name.append(1, '.');
+              Type* rtype = this->fntype_->receiver()->type();
+              asm_name.append(rtype->mangled_name(gogo));
+            }
+        }
+
+      Btype* functype = this->fntype_->get_backend_fntype(gogo);
+      this->fndecl_ =
+          gogo->backend()->function(functype, no->get_id(gogo), asm_name,
+                                    true, true, true, false, false,
+                                    this->location());
+    }
 
-      if (functype != error_mark_node)
-        {
-          // The type of a function comes back as a pointer to a
-          // struct whose first field is the function, but we want the
-          // real function type for a function declaration.
-          go_assert(POINTER_TYPE_P(functype)
-                    && TREE_CODE(TREE_TYPE(functype)) == RECORD_TYPE);
-          functype = TREE_TYPE(TYPE_FIELDS(TREE_TYPE(functype)));
-          go_assert(FUNCTION_POINTER_TYPE_P(functype));
-          functype = TREE_TYPE(functype);
-        }
+  return this->fndecl_;
+}
 
-      tree decl;
-      if (functype == error_mark_node)
-        decl = error_mark_node;
-      else
-        {
-          decl = build_decl(this->location().gcc_location(), FUNCTION_DECL, id,
-                            functype);
-          TREE_PUBLIC(decl) = 1;
-          DECL_EXTERNAL(decl) = 1;
+// Return the function's decl after it has been built.
 
-          if (this->asm_name_.empty())
-            {
-              std::string asm_name = (no->package() == NULL
-                                      ? gogo->pkgpath_symbol()
-                                      : no->package()->pkgpath_symbol());
-              asm_name.append(1, '.');
-              asm_name.append(Gogo::unpack_hidden_name(no->name()));
-              if (this->fntype_->is_method())
-                {
-                  asm_name.append(1, '.');
-                  Type* rtype = this->fntype_->receiver()->type();
-                  asm_name.append(rtype->mangled_name(gogo));
-                }
-              SET_DECL_ASSEMBLER_NAME(decl,
-                                      get_identifier_from_string(asm_name));
-            }
-        }
-      this->fndecl_ = decl;
-      go_preserve_from_gc(decl);
-    }
-  return this->fndecl_;
+tree
+Function::get_decl() const
+{
+  go_assert(this->fndecl_ != NULL);
+  return function_to_tree(this->fndecl_);
 }
 
 // We always pass the receiver to a method as a pointer.  If the
@@ -1558 +1363 @@
 void
 Function::build_tree(Gogo* gogo, Named_object* named_function)
 {
-  tree fndecl = this->fndecl_;
+  tree fndecl = this->get_decl();
   go_assert(fndecl != NULL_TREE);
 
   tree params = NULL_TREE;
@@ -1796 +1601 @@
     set = NULL_TREE;
   else
     set = fold_build2_loc(end_loc.gcc_location(), MODIFY_EXPR, void_type_node,
-                          DECL_RESULT(this->fndecl_), retval);
+                          DECL_RESULT(this->get_decl()), retval);
   tree ret_stmt = fold_build1_loc(end_loc.gcc_location(), RETURN_EXPR,
                                   void_type_node, set);
   append_to_statement_list(ret_stmt, &stmt_list);
@@ -1851 +1656 @@
       retval = this->return_value(gogo, named_function, end_loc,
                                   &stmt_list);
       set = fold_build2_loc(end_loc.gcc_location(), MODIFY_EXPR, void_type_node,
-                            DECL_RESULT(this->fndecl_), retval);
+                            DECL_RESULT(this->get_decl()), retval);
       ret_stmt = fold_build1_loc(end_loc.gcc_location(), RETURN_EXPR,
                                  void_type_node, set);
 
@@ -1869 +1674 @@
   *fini = stmt_list;
 }
 
-// Return the value to assign to DECL_RESULT(this->fndecl_).  This may
+// Return the value to assign to DECL_RESULT(this->get_decl()).  This may
 // also add statements to STMT_LIST, which need to be executed before
 // the assignment.  This is used for a return statement with no
 // explicit values.
@@ -1902 +1707 @@
     }
   else
     {
-      tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
+      tree rettype = TREE_TYPE(DECL_RESULT(this->get_decl()));
       retval = create_tmp_var(rettype, "RESULT");
       tree field = TYPE_FIELDS(rettype);
       int index = 0;
@@ -2323 +2128 @@
       go_assert(m != NULL);
 
       Named_object* no = m->named_object();
-
-      tree fnid = no->get_id(this);
-
-      tree fndecl;
+      Bfunction* bf;
       if (no->is_function())
-        fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
+        bf = no->func_value()->get_or_make_decl(this, no);
       else if (no->is_function_declaration())
-        fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
-                                                                fnid);
+        bf = no->func_declaration_value()->get_or_make_decl(this, no);
       else
         go_unreachable();
-      fndecl = build_fold_addr_expr(fndecl);
+      tree fndecl = build_fold_addr_expr(function_to_tree(bf));
 
       elt = pointers->quick_push(empty);
       elt->index = size_int(i);
@@ -2353 +2154 @@
   TREE_CONSTANT(decl) = 1;
   DECL_INITIAL(decl) = constructor;
 
-  // If the interface type has hidden methods, then this is the only
-  // definition of the table.  Otherwise it is a comdat table which
-  // may be defined in multiple packages.
-  if (has_hidden_methods)
+  // If the interface type has hidden methods, and the table is for a
+  // named type, then this is the only definition of the table.
+  // Otherwise it is a comdat table which may be defined in multiple
+  // packages.
+  if (has_hidden_methods && type->named_type() != NULL)
     TREE_PUBLIC(decl) = 1;
   else
     {

gcc/go/gofrontend/gogo.cc

@@ -3320 +3320 @@
     closure_var_(NULL), block_(block), location_(location), labels_(),
     local_type_count_(0), descriptor_(NULL), fndecl_(NULL), defer_stack_(NULL),
     is_sink_(false), results_are_named_(false), nointerface_(false),
-    calls_recover_(false), is_recover_thunk_(false), has_recover_thunk_(false),
+    is_unnamed_type_stub_method_(false), calls_recover_(false),
+    is_recover_thunk_(false), has_recover_thunk_(false),
     in_unique_section_(false)
 {
 }
@@ -3819 +3820 @@
   *presults = results;
 }
 
+// Get the backend representation.
+
+Bfunction*
+Function::get_or_make_decl(Gogo* gogo, Named_object* no)
+{
+  if (this->fndecl_ == NULL)
+    {
+      std::string asm_name;
+      bool is_visible = false;
+      if (no->package() != NULL)
+        ;
+      else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
+        ;
+      else if (Gogo::unpack_hidden_name(no->name()) == "init"
+               && !this->type_->is_method())
+        ;
+      else if (Gogo::unpack_hidden_name(no->name()) == "main"
+               && gogo->is_main_package())
+        is_visible = true;
+      // Methods have to be public even if they are hidden because
+      // they can be pulled into type descriptors when using
+      // anonymous fields.
+      else if (!Gogo::is_hidden_name(no->name())
+               || this->type_->is_method())
+        {
+          if (!this->is_unnamed_type_stub_method_)
+            is_visible = true;
+          std::string pkgpath = gogo->pkgpath_symbol();
+          if (this->type_->is_method()
+              && Gogo::is_hidden_name(no->name())
+              && Gogo::hidden_name_pkgpath(no->name()) != gogo->pkgpath())
+            {
+              // This is a method we created for an unexported
+              // method of an imported embedded type.  We need to
+              // use the pkgpath of the imported package to avoid
+              // a possible name collision.  See bug478 for a test
+              // case.
+              pkgpath = Gogo::hidden_name_pkgpath(no->name());
+              pkgpath = Gogo::pkgpath_for_symbol(pkgpath);
+            }
+
+          asm_name = pkgpath;
+          asm_name.append(1, '.');
+          asm_name.append(Gogo::unpack_hidden_name(no->name()));
+          if (this->type_->is_method())
+            {
+              asm_name.append(1, '.');
+              Type* rtype = this->type_->receiver()->type();
+              asm_name.append(rtype->mangled_name(gogo));
+            }
+        }
+
+      // If a function calls the predeclared recover function, we
+      // can't inline it, because recover behaves differently in a
+      // function passed directly to defer.  If this is a recover
+      // thunk that we built to test whether a function can be
+      // recovered, we can't inline it, because that will mess up
+      // our return address comparison.
+      bool is_inlinable = !(this->calls_recover_ || this->is_recover_thunk_);
+
+      // If this is a thunk created to call a function which calls
+      // the predeclared recover function, we need to disable
+      // stack splitting for the thunk.
+      bool disable_split_stack = this->is_recover_thunk_;
+
+      Btype* functype = this->type_->get_backend_fntype(gogo);
+      this->fndecl_ =
+          gogo->backend()->function(functype, no->get_id(gogo), asm_name,
+                                    is_visible, false, is_inlinable,
+                                    disable_split_stack,
+                                    this->in_unique_section_, this->location());
+    }
+  return this->fndecl_;
+}
+
 // Class Block.
 
 Block::Block(Block* enclosing, Location location)
@@ -5110 +5186 @@
     go_unreachable();
 }
 
+
+// Return the external identifier for this object.
+
+std::string
+Named_object::get_id(Gogo* gogo)
+{
+  go_assert(!this->is_variable() && !this->is_result_variable());
+  std::string decl_name;
+  if (this->is_function_declaration()
+      && !this->func_declaration_value()->asm_name().empty())
+    decl_name = this->func_declaration_value()->asm_name();
+  else if (this->is_type()
+           && Linemap::is_predeclared_location(this->type_value()->location()))
+    {
+      // We don't need the package name for builtin types.
+      decl_name = Gogo::unpack_hidden_name(this->name_);
+    }
+  else
+    {
+      std::string package_name;
+      if (this->package_ == NULL)
+        package_name = gogo->package_name();
+      else
+        package_name = this->package_->package_name();
+
+      // Note that this will be misleading if this is an unexported
+      // method generated for an embedded imported type.  In that case
+      // the unexported method should have the package name of the
+      // package from which it is imported, but we are going to give
+      // it our package name.  Fixing this would require knowing the
+      // package name, but we only know the package path.  It might be
+      // better to use package paths here anyhow.  This doesn't affect
+      // the assembler code, because we always set that name in
+      // Function::get_or_make_decl anyhow.  FIXME.
+
+      decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
+
+      Function_type* fntype;
+      if (this->is_function())
+        fntype = this->func_value()->type();
+      else if (this->is_function_declaration())
+        fntype = this->func_declaration_value()->type();
+      else
+        fntype = NULL;
+      if (fntype != NULL && fntype->is_method())
+        {
+          decl_name.push_back('.');
+          decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
+        }
+    }
+  if (this->is_type())
+    {
+      unsigned int index;
+      const Named_object* in_function = this->type_value()->in_function(&index);
+      if (in_function != NULL)
+        {
+          decl_name += '$' + Gogo::unpack_hidden_name(in_function->name());
+          if (index > 0)
+            {
+              char buf[30];
+              snprintf(buf, sizeof buf, "%u", index);
+              decl_name += '$';
+              decl_name += buf;
+            }
+        }
+    }
+  return decl_name;
+}
+
 // Class Bindings.
 
 Bindings::Bindings(Bindings* enclosing)

gcc/go/gofrontend/gogo.h

@@ -48 +48 @@
 class Bblock;
 class Bvariable;
 class Blabel;
+class Bfunction;
 
 // This file declares the basic classes used to hold the internal
 // representation of Go which is built by the parser.
@@ -952 +953 @@
     this->nointerface_ = true;
   }
 
+  // Record that this function is a stub method created for an unnamed
+  // type.
+  void
+  set_is_unnamed_type_stub_method()
+  {
+    go_assert(this->is_method());
+    this->is_unnamed_type_stub_method_ = true;
+  }
+
   // Add a new field to the closure variable.
   void
   add_closure_field(Named_object* var, Location loc)
@@ -1089 +1099 @@
     this->descriptor_ = descriptor;
   }
 
-  // Return the function's decl given an identifier.
-  tree
-  get_or_make_decl(Gogo*, Named_object*, tree id);
+  // Return the backend representation.
+  Bfunction*
+  get_or_make_decl(Gogo*, Named_object*);
 
   // Return the function's decl after it has been built.
   tree
-  get_decl() const
-  {
-    go_assert(this->fndecl_ != NULL);
-    return this->fndecl_;
-  }
+  get_decl() const;
 
   // Set the function decl to hold a tree of the function code.
   void
@@ -1170 +1176 @@
   // The function descriptor, if any.
   Expression* descriptor_;
   // The function decl.
-  tree fndecl_;
+  Bfunction* fndecl_;
   // The defer stack variable.  A pointer to this variable is used to
   // distinguish the defer stack for one function from another.  This
   // is NULL unless we actually need a defer stack.
@@ -1181 +1187 @@
   bool results_are_named_ : 1;
   // True if this method should not be included in the type descriptor.
   bool nointerface_ : 1;
+  // True if this function is a stub method created for an unnamed
+  // type.
+  bool is_unnamed_type_stub_method_ : 1;
   // True if this function calls the predeclared recover function.
   bool calls_recover_ : 1;
   // True if this a thunk built for a function which calls recover.
@@ -1265 +1274 @@
   has_descriptor() const
   { return this->descriptor_ != NULL; }
 
-  // Return a decl for the function given an identifier.
-  tree
-  get_or_make_decl(Gogo*, Named_object*, tree id);
+  // Return a backend representation.
+  Bfunction*
+  get_or_make_decl(Gogo*, Named_object*);
 
   // If there is a descriptor, build it into the backend
   // representation.
@@ -1290 +1299 @@
   // The function descriptor, if any.
   Expression* descriptor_;
   // The function decl if needed.
-  tree fndecl_;
+  Bfunction* fndecl_;
 };
 
 // A variable.
@@ -2181 +2190 @@
   Bvariable*
   get_backend_variable(Gogo*, Named_object* function);
 
-  // Return a tree for the external identifier for this object.
-  tree
+  // Return the external identifier for this object.
+  std::string
   get_id(Gogo*);
 
   // Return a tree representing this object.

gcc/go/gofrontend/import.h

@@ -149 +149 @@
   location() const
   { return this->location_; }
 
+  // Return the package we are importing.
+  Package*
+  package() const
+  { return this->package_; }
+
   // Return the next character.
   int
   peek_char()

gcc/go/gofrontend/lex.cc

@@ -873 +873 @@
               && (cc < 'a' || cc > 'z')
               && cc != '_'
               && (cc < '0' || cc > '9'))
-            break;
+            {
+              // Check for an invalid character here, as we get better
+              // error behaviour if we swallow them as part of the
+              // identifier we are building.
+              if ((cc >= ' ' && cc < 0x7f)
+                  || cc == '\t'
+                  || cc == '\r'
+                  || cc == '\n')
+                break;
+
+              this->lineoff_ = p - this->linebuf_;
+              error_at(this->location(),
+                       "invalid character 0x%x in identifier",
+                       cc);
+              if (!has_non_ascii_char)
+                {
+                  buf.assign(pstart, p - pstart);
+                  has_non_ascii_char = true;
+                }
+              if (!Lex::is_invalid_identifier(buf))
+                buf.append("$INVALID$");
+            }
           ++p;
           if (is_first)
             {

gcc/go/gofrontend/parse.cc

@@ -744 +744 @@
     return NULL;
 
   Parse::Names names;
+  if (receiver != NULL)
+    names[receiver->name()] = receiver;
   if (params != NULL)
     this->check_signature_names(params, &names);
   if (results != NULL)

gcc/go/gofrontend/runtime.cc

@@ -42 +42 @@
   RFT_RUNE,
   // Go type float64, C type double.
   RFT_FLOAT64,
+  // Go type complex64, C type __complex float.
+  RFT_COMPLEX64,
   // Go type complex128, C type __complex double.
   RFT_COMPLEX128,
   // Go type string, C type struct __go_string.
@@ -126 +128 @@
           t = Type::lookup_float_type("float64");
           break;
 
+        case RFT_COMPLEX64:
+          t = Type::lookup_complex_type("complex64");
+          break;
+
         case RFT_COMPLEX128:
           t = Type::lookup_complex_type("complex128");
           break;
@@ -216 +222 @@
     case RFT_UINTPTR:
     case RFT_RUNE:
     case RFT_FLOAT64:
+    case RFT_COMPLEX64:
     case RFT_COMPLEX128:
     case RFT_STRING:
     case RFT_POINTER:

gcc/go/gofrontend/runtime.def

@@ -68 +68 @@
                P1(STRING), R1(SLICE))
 
 
+// Complex division.
+DEF_GO_RUNTIME(COMPLEX64_DIV, "__go_complex64_div",
+               P2(COMPLEX64, COMPLEX64), R1(COMPLEX64))
+DEF_GO_RUNTIME(COMPLEX128_DIV, "__go_complex128_div",
+               P2(COMPLEX128, COMPLEX128), R1(COMPLEX128))
+
 // Make a slice.
 DEF_GO_RUNTIME(MAKESLICE1, "__go_make_slice1", P2(TYPE, UINTPTR), R1(SLICE))
 DEF_GO_RUNTIME(MAKESLICE2, "__go_make_slice2", P3(TYPE, UINTPTR, UINTPTR),

gcc/go/gofrontend/types.cc

@@ -3383 +3383 @@
 // Get the backend representation for a function type.
 
 Btype*
+Function_type::get_backend_fntype(Gogo* gogo)
+{
+  if (this->fnbtype_ == NULL)
+    {
+      Backend::Btyped_identifier breceiver;
+      if (this->receiver_ != NULL)
+        {
+          breceiver.name = Gogo::unpack_hidden_name(this->receiver_->name());
+
+          // We always pass the address of the receiver parameter, in
+          // order to make interface calls work with unknown types.
+          Type* rtype = this->receiver_->type();
+          if (rtype->points_to() == NULL)
+            rtype = Type::make_pointer_type(rtype);
+          breceiver.btype = rtype->get_backend(gogo);
+          breceiver.location = this->receiver_->location();
+        }
+
+      std::vector<Backend::Btyped_identifier> bparameters;
+      if (this->parameters_ != NULL)
+        {
+          bparameters.resize(this->parameters_->size());
+          size_t i = 0;
+          for (Typed_identifier_list::const_iterator p =
+                   this->parameters_->begin(); p != this->parameters_->end();
+               ++p, ++i)
+            {
+              bparameters[i].name = Gogo::unpack_hidden_name(p->name());
+              bparameters[i].btype = p->type()->get_backend(gogo);
+              bparameters[i].location = p->location();
+            }
+          go_assert(i == bparameters.size());
+        }
+
+      std::vector<Backend::Btyped_identifier> bresults;
+      if (this->results_ != NULL)
+        {
+          bresults.resize(this->results_->size());
+          size_t i = 0;
+          for (Typed_identifier_list::const_iterator p =
+                   this->results_->begin(); p != this->results_->end();
+               ++p, ++i)
+            {
+              bresults[i].name = Gogo::unpack_hidden_name(p->name());
+              bresults[i].btype = p->type()->get_backend(gogo);
+              bresults[i].location = p->location();
+            }
+          go_assert(i == bresults.size());
+        }
+
+      this->fnbtype_ = gogo->backend()->function_type(breceiver, bparameters,
+                                                      bresults,
+                                                      this->location());
+
+    }
+
+  return this->fnbtype_;
+}
+
+// Get the backend representation for a Go function type.
+
+Btype*
 Function_type::do_get_backend(Gogo* gogo)
 {
   // When we do anything with a function value other than call it, it
@@ -3395 +3457 @@
     gogo->backend()->placeholder_struct_type("__go_descriptor", loc);
   Btype* ptr_struct_type = gogo->backend()->pointer_type(struct_type);
 
-  Backend::Btyped_identifier breceiver;
-  if (this->receiver_ != NULL)
-    {
-      breceiver.name = Gogo::unpack_hidden_name(this->receiver_->name());
-
-      // We always pass the address of the receiver parameter, in
-      // order to make interface calls work with unknown types.
-      Type* rtype = this->receiver_->type();
-      if (rtype->points_to() == NULL)
-        rtype = Type::make_pointer_type(rtype);
-      breceiver.btype = rtype->get_backend(gogo);
-      breceiver.location = this->receiver_->location();
-    }
-
-  std::vector<Backend::Btyped_identifier> bparameters;
-  if (this->parameters_ != NULL)
-    {
-      bparameters.resize(this->parameters_->size());
-      size_t i = 0;
-      for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
-           p != this->parameters_->end();
-           ++p, ++i)
-        {
-          bparameters[i].name = Gogo::unpack_hidden_name(p->name());
-          bparameters[i].btype = p->type()->get_backend(gogo);
-          bparameters[i].location = p->location();
-        }
-      go_assert(i == bparameters.size());
-    }
-
-  std::vector<Backend::Btyped_identifier> bresults;
-  if (this->results_ != NULL)
-    {
-      bresults.resize(this->results_->size());
-      size_t i = 0;
-      for (Typed_identifier_list::const_iterator p = this->results_->begin();
-           p != this->results_->end();
-           ++p, ++i)
-        {
-          bresults[i].name = Gogo::unpack_hidden_name(p->name());
-          bresults[i].btype = p->type()->get_backend(gogo);
-          bresults[i].location = p->location();
-        }
-      go_assert(i == bresults.size());
-    }
-
-  Btype* fntype = gogo->backend()->function_type(breceiver, bparameters,
-                                                 bresults, loc);
   std::vector<Backend::Btyped_identifier> fields(1);
   fields[0].name = "code";
-  fields[0].btype = fntype;
+  fields[0].btype = this->get_backend_fntype(gogo);
   fields[0].location = loc;
   if (!gogo->backend()->set_placeholder_struct_type(struct_type, fields))
     return gogo->backend()->error_type();
@@ -4195 +4209 @@
 
       // This is a horrible hack caused by the fact that we don't pack
       // the names of builtin types.  FIXME.
-      if (nt != NULL
+      if (!this->is_imported_
+          && nt != NULL
           && nt->is_builtin()
           && nt->name() == Gogo::unpack_hidden_name(name))
         return true;
@@ -4204 +4219 @@
     }
 }
 
+// Return whether this field is an unexported field named NAME.
+
+bool
+Struct_field::is_unexported_field_name(Gogo* gogo,
+                                       const std::string& name) const
+{
+  const std::string& field_name(this->field_name());
+  if (Gogo::is_hidden_name(field_name)
+      && name == Gogo::unpack_hidden_name(field_name)
+      && gogo->pack_hidden_name(name, false) != field_name)
+    return true;
+
+  // Check for the name of a builtin type.  This is like the test in
+  // is_field_name, only there we return false if this->is_imported_,
+  // and here we return true.
+  if (this->is_imported_ && this->is_anonymous())
+    {
+      Type* t = this->typed_identifier_.type();
+      if (t->points_to() != NULL)
+        t = t->points_to();
+      Named_type* nt = t->named_type();
+      if (nt != NULL
+          && nt->is_builtin()
+          && nt->name() == Gogo::unpack_hidden_name(name))
+        return true;
+    }
+
+  return false;
+}
+
 // Return whether this field is an embedded built-in type.
 
 bool
@@ -4264 +4309 @@
        ++p)
     {
       Type* t = p->type();
-      if (t->is_undefined())
-        {
-          error_at(p->location(), "struct field type is incomplete");
-          p->set_type(Type::make_error_type());
-        }
-      else if (p->is_anonymous())
+      if (p->is_anonymous())
         {
           if (t->named_type() != NULL && t->points_to() != NULL)
             {
@@ -4641 +4681 @@
       for (Struct_field_list::const_iterator pf = fields->begin();
            pf != fields->end();
            ++pf)
-        {
-          const std::string& field_name(pf->field_name());
-          if (Gogo::is_hidden_name(field_name)
-              && name == Gogo::unpack_hidden_name(field_name)
-              && gogo->pack_hidden_name(name, false) != field_name)
-            return true;
-        }
+        if (pf->is_unexported_field_name(gogo, name))
+          return true;
     }
   return false;
 }
@@ -5250 +5285 @@
           Type* ftype = imp->read_type();
 
           Struct_field sf(Typed_identifier(name, ftype, imp->location()));
+          sf.set_is_imported();
 
           if (imp->peek_char() == ' ')
             {
@@ -9022 +9058 @@
                                       fntype->is_varargs(), location);
           gogo->finish_function(fntype->location());
 
+          if (type->named_type() == NULL && stub->is_function())
+            stub->func_value()->set_is_unnamed_type_stub_method();
           if (m->nointerface() && stub->is_function())
             stub->func_value()->set_nointerface();
         }
@@ -9289 +9327 @@
       else
         {
           bool is_unexported;
-          if (!Gogo::is_hidden_name(name))
+          // The test for 'a' and 'z' is to handle builtin names,
+          // which are not hidden.
+          if (!Gogo::is_hidden_name(name) && (name[0] < 'a' || name[0] > 'z'))
             is_unexported = false;
           else
             {

gcc/go/gofrontend/types.h

@@ -1717 +1717 @@
                 Typed_identifier_list* results, Location location)
     : Type(TYPE_FUNCTION),
       receiver_(receiver), parameters_(parameters), results_(results),
-      location_(location), is_varargs_(false), is_builtin_(false)
+      location_(location), is_varargs_(false), is_builtin_(false),
+      fnbtype_(NULL)
   { }
 
   // Get the receiver.
@@ -1798 +1799 @@
   static Type*
   make_function_type_descriptor_type();
 
+  // Return the backend representation of this function type. This is used
+  // as the real type of a backend function declaration or defintion.
+  Btype*
+  get_backend_fntype(Gogo*);
+
  protected:
   int
   do_traverse(Traverse*);
@@ -1851 +1857 @@
   // Whether this is a special builtin function which can not simply
   // be called.  This is used for len, cap, etc.
   bool is_builtin_;
+  // The backend representation of this type for backend function
+  // declarations and definitions.
+  Btype* fnbtype_;
 };
 
 // The type of a pointer.
@@ -1915 +1924 @@
 {
  public:
   explicit Struct_field(const Typed_identifier& typed_identifier)
-    : typed_identifier_(typed_identifier), tag_(NULL)
+    : typed_identifier_(typed_identifier), tag_(NULL), is_imported_(false)
   { }
 
   // The field name.
@@ -1926 +1935 @@
   bool
   is_field_name(const std::string& name) const;
 
+  // Return whether this struct field is an unexported field named NAME.
+  bool
+  is_unexported_field_name(Gogo*, const std::string& name) const;
+
   // Return whether this struct field is an embedded built-in type.
   bool
   is_embedded_builtin(Gogo*) const;
@@ -1963 +1976 @@
   set_tag(const std::string& tag)
   { this->tag_ = new std::string(tag); }
 
+  // Record that this field is defined in an imported struct.
+  void
+  set_is_imported()
+  { this->is_imported_ = true; }
+
   // Set the type.  This is only used in error cases.
   void
   set_type(Type* type)
@@ -1973 +1991 @@
   Typed_identifier typed_identifier_;
   // The field tag.  This is NULL if the field has no tag.
   std::string* tag_;
+  // Whether this field is defined in an imported struct.
+  bool is_imported_;
 };
 
 // A list of struct fields.

gcc/graphite-clast-to-gimple.c

@@ -1170 +1170 @@
   redirect_edge_succ_nodup (next_e, after);
   set_immediate_dominator (CDI_DOMINATORS, next_e->dest, next_e->src);
 
+  isl_set *domain = isl_set_from_cloog_domain (stmt->domain);
+  int scheduling_dim = isl_set_n_dim (domain);
+
   if (flag_loop_parallelize_all
-      && loop_is_parallel_p (loop, bb_pbb_mapping, level))
+      && loop_is_parallel_p (loop, bb_pbb_mapping, scheduling_dim))
     loop->can_be_parallel = true;
 
   return last_e;

gcc/graphite-dependences.c

@@ -297 +297 @@
               int depth)
 {
   bool res;
-  int idx, i;
+  int i;
   isl_space *space;
   isl_map *lex, *x;
   isl_constraint *ineq;
@@ -312 +312 @@
   space = isl_map_get_space (x);
   ineq = isl_inequality_alloc (isl_local_space_from_space (space));
 
-  idx = 2 * depth + 1;
-  for (i = 0; i < idx; i++)
+  for (i = 0; i < depth - 1; i++)
     lex = isl_map_equate (lex, isl_dim_in, i, isl_dim_out, i);
 
   /* in + 1 <= out  */
-  ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_out, idx, 1);
-  ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_in, idx, -1);
+  ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_out, depth - 1, 1);
+  ineq = isl_constraint_set_coefficient_si (ineq, isl_dim_in, depth - 1, -1);
   ineq = isl_constraint_set_constant_si (ineq, -1);
   lex = isl_map_add_constraint (lex, ineq);
   x = isl_map_intersect (x, lex);

gcc/ipa-prop.c

@@ -2126 +2126 @@
      we may create the first reference to the object in the unit.  */
   if (!callee || callee->global.inlined_to)
     {
-      struct cgraph_node *first_clone = callee;
 
       /* We are better to ensure we can refer to it.
          In the case of static functions we are out of luck, since we already   
@@ -2142 +2141 @@
                      xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid);
           return NULL;
         }
-
-      /* Create symbol table node.  Even if inline clone exists, we can not take
-         it as a target of non-inlined call.  */
-      callee = cgraph_create_node (target);
-
-      /* OK, we previously inlined the function, then removed the offline copy and
-         now we want it back for external call.  This can happen when devirtualizing
-         while inlining function called once that happens after extern inlined and
-         virtuals are already removed.  In this case introduce the external node
-         and make it available for call.  */
-      if (first_clone)
-        {
-          first_clone->clone_of = callee;
-          callee->clones = first_clone;
-          symtab_prevail_in_asm_name_hash ((symtab_node)callee);
-          symtab_insert_node_to_hashtable ((symtab_node)callee);
-          if (dump_file)
-            fprintf (dump_file, "ipa-prop: Introduced new external node "
-                     "(%s/%i) and turned into root of the clone tree.\n",
-                     xstrdup (cgraph_node_name (callee)), callee->uid);
-        }
-      else if (dump_file)
-        fprintf (dump_file, "ipa-prop: Introduced new external node "
-                 "(%s/%i).\n",
-                 xstrdup (cgraph_node_name (callee)), callee->uid);
+      callee = cgraph_get_create_real_symbol_node (target);
     }
   ipa_check_create_node_params ();
 

gcc/optabs.c

@@ -7035 +7035 @@
 
       create_output_operand (&ops[0], target, mode);
       create_fixed_operand (&ops[1], mem);
-      /* VAL may have been promoted to a wider mode.  Shrink it if so.  */
-      create_convert_operand_to (&ops[2], val, mode, true);
+      create_input_operand (&ops[2], val, mode);
       create_integer_operand (&ops[3], model);
       if (maybe_expand_insn (icode, 4, ops))
         return ops[0].value;
@@ -7075 +7074 @@
       struct expand_operand ops[3];
       create_output_operand (&ops[0], target, mode);
       create_fixed_operand (&ops[1], mem);
-      /* VAL may have been promoted to a wider mode.  Shrink it if so.  */
-      create_convert_operand_to (&ops[2], val, mode, true);
+      create_input_operand (&ops[2], val, mode);
       if (maybe_expand_insn (icode, 3, ops))
         return ops[0].value;
     }
@@ -7118 +7116 @@
     {
       if (!target || !register_operand (target, mode))
         target = gen_reg_rtx (mode);
-      if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
-        val = convert_modes (mode, GET_MODE (val), val, 1);
       if (expand_compare_and_swap_loop (mem, target, val, NULL_RTX))
         return target;
     }
@@ -7331 +7327 @@
       create_output_operand (&ops[0], target_bool, bool_mode);
       create_output_operand (&ops[1], target_oval, mode);
       create_fixed_operand (&ops[2], mem);
-      create_convert_operand_to (&ops[3], expected, mode, true);
-      create_convert_operand_to (&ops[4], desired, mode, true);
+      create_input_operand (&ops[3], expected, mode);
+      create_input_operand (&ops[4], desired, mode);
       create_integer_operand (&ops[5], is_weak);
       create_integer_operand (&ops[6], succ_model);
       create_integer_operand (&ops[7], fail_model);
@@ -7353 +7349 @@
 
       create_output_operand (&ops[0], target_oval, mode);
       create_fixed_operand (&ops[1], mem);
-      create_convert_operand_to (&ops[2], expected, mode, true);
-      create_convert_operand_to (&ops[3], desired, mode, true);
+      create_input_operand (&ops[2], expected, mode);
+      create_input_operand (&ops[3], desired, mode);
       if (!maybe_expand_insn (icode, 4, ops))
         return false;
 

gcc/recog.c

@@ -3061 +3061 @@
   return 1;
 }
 
+/* Regno offset to be used in the register search.  */
+static int search_ofs;
+
 /* Try to find a hard register of mode MODE, matching the register class in
    CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
    remains available until the end of LAST_INSN.  LAST_INSN may be NULL_RTX,
@@ -3076 +3079 @@
 peep2_find_free_register (int from, int to, const char *class_str,
                           enum machine_mode mode, HARD_REG_SET *reg_set)
 {
-  static int search_ofs;
   enum reg_class cl;
   HARD_REG_SET live;
   df_ref *def_rec;
@@ -3541 +3543 @@
   /* Initialize the regsets we're going to use.  */
   for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
     peep2_insn_data[i].live_before = BITMAP_ALLOC (&reg_obstack);
+  search_ofs = 0;
   live = BITMAP_ALLOC (&reg_obstack);
 
   FOR_EACH_BB_REVERSE (bb)

gcc/testsuite/g++.dg/cpp0x/decltype57.C

@@ +1 @@
+// PR c++/58633
+// { dg-do compile { target c++11 } }
+
+void foo(int i)
+{
+  typedef int I;
+  decltype(i.I::~I())* p;
+}

gcc/testsuite/g++.dg/cpp0x/enum18.C

@@ -4 +4 @@
 int main(void) {
   enum e {};
   e ev;
-  ev.e::~e_u(); // { dg-error "e_u. has not been declared" }
+  ev.e::~e_u(); // { dg-error "" }
 }

gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi5.C

@@ +1 @@
+// PR c++/58596
+// { dg-do compile { target c++11 } }
+
+struct A
+{
+  int i = [] { return decltype(i)(); }();
+};

gcc/testsuite/g++.dg/tm/noexcept-6.C

@@ +1 @@
+// { dg-do compile }
+// { dg-options "-fno-exceptions -fgnu-tm -O -std=c++0x -fdump-tree-tmlower" }
+
+struct TrueFalse
+{
+  static constexpr bool v() { return true; }
+};
+
+int global;
+
+template<typename T> int foo()
+{
+  return __transaction_atomic noexcept(T::v()) (global + 1);
+}
+
+int f1()
+{
+  return foo<TrueFalse>();
+}
+
+/* { dg-final { scan-tree-dump-times "eh_must_not_throw" 0 "tmlower" } } */
+/* { dg-final { scan-tree-dump-times "__transaction_atomic" 1 "tmlower" } } */
+/* { dg-final { cleanup-tree-dump "tmlower" } } */

gcc/testsuite/gcc.c-torture/execute/pr58831.c

@@ +1 @@
+#include <assert.h>
+
+int a, *b, c, d, f, **i, p, q, *r;
+short o, j;
+
+static int __attribute__((noinline, noclone))
+fn1 (int *p1, int **p2)
+{
+  int **e = &b;
+  for (; p; p++)
+    *p1 = 1;
+  *e = *p2 = &d;
+
+  assert (r);
+
+  return c;
+}
+
+static int ** __attribute__((noinline, noclone))
+fn2 (void)
+{
+  for (f = 0; f != 42; f++)
+    {
+      int *g[3] = {0, 0, 0};
+      for (o = 0; o; o--)
+        for (; a > 1;)
+          {
+            int **h[1] = { &g[2] };
+          }
+    }
+  return &r;
+}
+
+int
+main (void)
+{
+  i = fn2 ();
+  fn1 (b, i);
+  return 0;
+}

gcc/testsuite/gcc.dg/atomic-store-6.c

@@ +1 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_int_128_runtime } */
+/* { dg-options "-mcx16" { target { i?86-*-* x86_64-*-* } } } */
+
+__int128_t i;
+
+int main()
+{
+  __atomic_store_16(&i, -1, 0);
+  if (i != -1)
+    __builtin_abort();
+  return 0;
+}

gcc/testsuite/gcc.dg/graphite/pr54094.c

@@ +1 @@
+/* { dg-options "-O2 -floop-parallelize-all -floop-nest-optimize" } */
+void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas)
+{
+  int i;
+  for (i=0; i<sn; i++)
+    b[i]=a[2*i+cas];
+  for (i=0; i<dn; i++)
+    b[sn+i]=a[(2*i+1-cas)];
+}
+

gcc/testsuite/gcc.dg/pr58805.c

@@ +1 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-tail-merge -fdump-tree-pre" } */
+
+/* Type that matches the 'p' constraint.  */
+#define TYPE void *
+
+static inline
+void bar (TYPE *r)
+{
+  TYPE t;
+  __asm__ ("" : "=&p" (t), "=p" (*r));
+}
+
+void
+foo (int n, TYPE *x, TYPE *y)
+{
+  if (n == 0)
+    bar (x);
+  else
+    bar (y);
+}
+
+/* { dg-final { scan-tree-dump-times "__asm__" 2 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */

gcc/testsuite/gcc.dg/torture/pr57488.c

@@ +1 @@
+/* { dg-do run } */
+
+extern void abort (void);
+
+int i, j, *pj = &j, **ppj = &pj;
+int x, *px = &x;
+
+short s, *ps = &s, k;
+
+unsigned short u, *pu = &u, **ppu = &pu;
+
+char c, *pc = &c;
+
+unsigned char v = 48;
+
+static int
+bar (int p)
+{
+  p = k;
+  *px = **ppu = i;
+  *ppj = &p;
+  if (**ppj)
+    *pj = p;
+  return p;
+}
+
+void __attribute__((noinline))
+foo ()
+{
+  for (; i <= 3; i++)
+    for (; j; j--);
+
+  u ^= bar (*pj);
+
+  for (k = 1; k >= 0; k--)
+    {
+      int l;
+      bar (0);
+      for (l = 1; l < 5; l++)
+        {
+          int m;
+          for (m = 6; m; m--)
+            {
+              v--;
+              *ps = *pc;
+            }
+        }
+    }
+}
+
+int
+main ()
+{
+  foo ();
+  if (v != 0)
+    abort ();
+  return 0;
+}

gcc/testsuite/gcc.dg/torture/pr58079.c

@@ +1 @@
+/* { dg-options "-mlong-calls" { target mips*-*-* } } */
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int __kernel_size_t;
+typedef __kernel_size_t size_t;
+struct list_head {
+ struct list_head *next;
+};
+
+struct dmx_ts_feed {
+ int is_filtering;
+};
+struct dmx_section_feed {
+ u16 secbufp;
+ u16 seclen;
+ u16 tsfeedp;
+};
+
+typedef int (*dmx_ts_cb) (
+        const u8 * buffer1,
+      size_t buffer1_length,
+      const u8 * buffer2,
+      size_t buffer2_length
+);
+
+struct dvb_demux_feed {
+ union {
+  struct dmx_ts_feed ts;
+  struct dmx_section_feed sec;
+ } feed;
+ union {
+  dmx_ts_cb ts;
+ } cb;
+ int type;
+ u16 pid;
+ int ts_type;
+ struct list_head list_head;
+};
+
+struct dvb_demux {
+ int (*stop_feed)(struct dvb_demux_feed *feed);
+ struct list_head feed_list;
+};
+
+
+static
+inline
+__attribute__((always_inline))
+u8
+payload(const u8 *tsp)
+{
+ if (tsp[3] & 0x20) {
+   return 184 - 1 - tsp[4];
+ }
+ return 184;
+}
+
+static
+inline
+__attribute__((always_inline))
+int
+dvb_dmx_swfilter_payload(struct dvb_demux_feed *feed, const u8 *buf)
+{
+ int count = payload(buf);
+ int p;
+ if (count == 0)
+  return -1;
+ return feed->cb.ts(&buf[p], count, ((void *)0), 0);
+}
+
+static
+inline
+__attribute__((always_inline))
+void
+dvb_dmx_swfilter_packet_type(struct dvb_demux_feed *feed, const u8 *buf)
+{
+ switch (feed->type) {
+ case 0:
+  if (feed->ts_type & 1) {
+    dvb_dmx_swfilter_payload(feed, buf);
+  }
+  if (dvb_dmx_swfilter_section_packet(feed, buf) < 0)
+   feed->feed.sec.seclen = feed->feed.sec.secbufp = 0;
+ }
+}
+
+static
+void
+dvb_dmx_swfilter_packet(struct dvb_demux *demux, const u8 *buf)
+{
+ struct dvb_demux_feed *feed;
+ int dvr_done = 0;
+
+ for (feed = ({ const typeof( ((typeof(*feed) *)0)->list_head ) *__mptr = ((&demux->feed_list)->next); (typeof(*feed) *)( (char *)__mptr - __builtin_offsetof(typeof(*feed),list_head) );}); __builtin_prefetch(feed->list_head.next), &feed->list_head != (&demux->feed_list); feed = ({ const typeof( ((typeof(*feed) *)0)->list_head ) *__mptr = (feed->list_head.next); (typeof(*feed) *)( (char *)__mptr - __builtin_offsetof(typeof(*feed),list_head) );})) {
+  if (((((feed)->type == 0) && ((feed)->feed.ts.is_filtering) && (((feed)->ts_type & (1 | 8)) == 1))) && (dvr_done++))
+   dvb_dmx_swfilter_packet_type(feed, buf);
+  else if (feed->pid == 0x2000)
+   feed->cb.ts(buf, 188, ((void *)0), 0);
+ }
+}
+void dvb_dmx_swfilter_packets(struct dvb_demux *demux, const u8 *buf, size_t count)
+{
+ while (count--) {
+   dvb_dmx_swfilter_packet(demux, buf);
+ }
+}

gcc/testsuite/gcc.dg/torture/pr58779.c

@@ +1 @@
+/* { dg-do run } */
+
+int a, c;
+
+int main ()
+{
+  int e = -1;
+  short d = (c <= 0) ^ e;
+  if ((unsigned int) a - (a || d) <= (unsigned int) a)
+    __builtin_abort ();
+  return 0;
+}

gcc/testsuite/gcc.dg/torture/pr58830.c

@@ +1 @@
+/* { dg-do run } */
+/* { dg-additional-options "-ftree-pre -ftree-partial-pre" } */
+
+extern void abort (void);
+
+int b, c, d, f, g, h, i, j[6], *l = &b, *m, n, *o, r; 
+char k;
+
+static int
+foo ()
+{
+  char *p = &k;
+
+  for (; d; d++)
+    if (i)
+      h = 0;
+    else
+      h = c || (r = 0);
+
+  for (f = 0; f < 2; f++)
+    {
+      unsigned int q;
+      *l = 0;
+      if (n)
+        *m = g;
+      if (g)
+        o = 0;
+      for (q = -8; q >= 5; q++)
+        (*p)--;
+    }
+
+  return 0;
+}
+
+int
+main ()
+{
+  foo ();
+  if (j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[j[0]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ^ (k & 15)] != 0)
+    abort ();
+  return 0;
+}

gcc/testsuite/gcc.target/arm/require-pic-register-loc.c

@@ +1 @@
+/* { dg-do compile } */
+/* { dg-options "-g -fPIC" } */
+
+void *v;
+void a (void *x) { }
+void b (void) { }
+                       /* line 7.  */
+int                    /* line 8.  */
+main (int argc)        /* line 9.  */
+{                      /* line 10.  */
+  if (argc == 12345)   /* line 11.  */
+    {
+      a (v);
+      return 1;
+    }
+  b ();
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-not "\.loc 1 7 0" } } */
+/* { dg-final { scan-assembler-not "\.loc 1 8 0" } } */
+/* { dg-final { scan-assembler-not "\.loc 1 9 0" } } */
+
+/* The loc at the start of the prologue.  */
+/* { dg-final { scan-assembler-times "\.loc 1 10 0" 1 } } */
+
+/* The loc at the end of the prologue, with the first user line.  */
+/* { dg-final { scan-assembler-times "\.loc 1 11 0" 1 } } */

gcc/testsuite/gcc.target/i386/pr30315.c

@@ -1 +1 @@
 /* { dg-do compile } */
 /* { dg-options "-O2" } */
-/* { dg-final { scan-assembler-times "cmp" 4 } } */
+/* { dg-final { scan-assembler-not "cmp" } } */
 
 extern void abort (void);
 int c;
@@ -34 +34 @@
 }
 #define PLUSCCONLY(T, t) PLUSCCONLY1(T, t, a) PLUSCCONLY1(T, t, b)
 
-#define MINUSCC(T, t)   \
-T minuscc##t (T a, T b) \
-{       \
-  T difference = a - b; \
-  if (difference > a)   \
-    abort ();           \
-  return difference;    \
-}
-
-#define DECCC(T, t)     \
-T deccc##t (T a, T b)   \
-{       \
-  T difference = a - b; \
-  if (difference > a)   \
-    c --;               \
-  return difference;    \
-}
-
-#define MINUSCCONLY(T, t)       \
-void minuscconly##t (T a, T b)  \
-{       \
-  T difference = a - b; \
-  if (difference > a)   \
-    abort ();           \
-}
-
 #define TEST(T, t)      \
   PLUSCC(T, t)          \
   PLUSCCONLY(T, t)      \
-  INCCC(T, t)           \
-  MINUSCC(T, t)         \
-  MINUSCCONLY(T, t)     \
-  DECCC(T, t)
+  INCCC(T, t)
 
 TEST (unsigned long,  l)
 TEST (unsigned int,   i)
@@ -84 +55 @@
 
 PLUSCCZEXT(a)
 PLUSCCZEXT(b)
-
-#define MINUSCCZEXT     \
-unsigned long minuscczext (unsigned int a, unsigned int b)      \
-{       \
-  unsigned int difference = a - b;      \
-  if (difference > a)           \
-    abort ();                   \
-  return difference;            \
-}
-
-MINUSCCZEXT

gcc/testsuite/gcc.target/sh/pr54089-3.c

@@ -5 +5 @@
 /* { dg-options "-O1" } */
 /* { dg-skip-if "" { "sh*-*-*" } { "*" } { "-m1*" "-m2" "-m2e*" } } */
 /* { dg-final { scan-assembler-not "and" } } */
-/* { dg-final { scan-assembler-not "31" } } */
+/* { dg-final { scan-assembler-not "#31" } } */
 
 int
 test00 (unsigned int a, int* b, int c, int* d, unsigned int e)

gcc/tree-ssa-pre.c

@@ -3664 +3664 @@
       if (dump_file && dump_flags & TDF_DETAILS)
         fprintf (dump_file, "Starting insert iteration %d\n", num_iterations);
       new_stuff = insert_aux (ENTRY_BLOCK_PTR);
+
+      /* Clear the NEW sets before the next iteration.  We have already
+         fully propagated its contents.  */
+      if (new_stuff)
+        FOR_ALL_BB (bb)
+          bitmap_set_free (NEW_SETS (bb));
     }
   statistics_histogram_event (cfun, "insert iterations", num_iterations);
 }

gcc/tree-ssa-tail-merge.c

@@ -297 +297 @@
   tree val;
   def_operand_p def_p;
 
-  if (gimple_has_side_effects (stmt))
+  if (gimple_has_side_effects (stmt)
+      || gimple_vdef (stmt) != NULL_TREE)
     return false;
 
   def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);

gcc/version.c

@@ -32 +32 @@
    Makefile.  */
 
 const char version_string[] = BASEVER DATESTAMP DEVPHASE REVISION;
-const char pkgversion_string[] = PKGVERSION;
+const char pkgversion_string[] = "(GCC for Cross-LFS 4.8.2.20131101) ";

libffi/doc/libffi.info

@@ -1 @@
-This is libffi.info, produced by makeinfo version 5.1 from libffi.texi.
-
-This manual is for Libffi, a portable foreign-function interface
-library.
-
-   Copyright (C) 2008, 2010, 2011 Red Hat, Inc.
-
-     Permission is granted to copy, distribute and/or modify this
-     document under the terms of the GNU General Public License as
-     published by the Free Software Foundation; either version 2, or (at
-     your option) any later version.  A copy of the license is included
-     in the section entitled "GNU General Public License".
-
-INFO-DIR-SECTION Development
-START-INFO-DIR-ENTRY
-* libffi: (libffi).             Portable foreign-function interface library.
-END-INFO-DIR-ENTRY
-
-
-File: libffi.info,  Node: Top,  Next: Introduction,  Up: (dir)
-
-libffi
-******
-
-This manual is for Libffi, a portable foreign-function interface
-library.
-
-   Copyright (C) 2008, 2010, 2011 Red Hat, Inc.
-
-     Permission is granted to copy, distribute and/or modify this
-     document under the terms of the GNU General Public License as
-     published by the Free Software Foundation; either version 2, or (at
-     your option) any later version.  A copy of the license is included
-     in the section entitled "GNU General Public License".
-
-* Menu:
-
-* Introduction::                What is libffi?
-* Using libffi::                How to use libffi.
-* Missing Features::            Things libffi can't do.
-* Index::                       Index.
-
-
-File: libffi.info,  Node: Introduction,  Next: Using libffi,  Prev: Top,  Up: Top
-
-1 What is libffi?
-*****************
-
-Compilers for high level languages generate code that follow certain
-conventions.  These conventions are necessary, in part, for separate
-compilation to work.  One such convention is the "calling convention".
-The calling convention is a set of assumptions made by the compiler
-about where function arguments will be found on entry to a function.  A
-calling convention also specifies where the return value for a function
-is found.  The calling convention is also sometimes called the "ABI" or
-"Application Binary Interface".
-
-   Some programs may not know at the time of compilation what arguments
-are to be passed to a function.  For instance, an interpreter may be
-told at run-time about the number and types of arguments used to call a
-given function.  'Libffi' can be used in such programs to provide a
-bridge from the interpreter program to compiled code.
-
-   The 'libffi' library provides a portable, high level programming
-interface to various calling conventions.  This allows a programmer to
-call any function specified by a call interface description at run time.
-
-   FFI stands for Foreign Function Interface.  A foreign function
-interface is the popular name for the interface that allows code written
-in one language to call code written in another language.  The 'libffi'
-library really only provides the lowest, machine dependent layer of a
-fully featured foreign function interface.  A layer must exist above
-'libffi' that handles type conversions for values passed between the two
-languages.
-
-
-File: libffi.info,  Node: Using libffi,  Next: Missing Features,  Prev: Introduction,  Up: Top
-
-2 Using libffi
-**************
-
-* Menu:
-
-* The Basics::                  The basic libffi API.
-* Simple Example::              A simple example.
-* Types::                       libffi type descriptions.
-* Multiple ABIs::               Different passing styles on one platform.
-* The Closure API::             Writing a generic function.
-* Closure Example::             A closure example.
-
-
-File: libffi.info,  Node: The Basics,  Next: Simple Example,  Up: Using libffi
-
-2.1 The Basics
-==============
-
-'Libffi' assumes that you have a pointer to the function you wish to
-call and that you know the number and types of arguments to pass it, as
-well as the return type of the function.
-
-   The first thing you must do is create an 'ffi_cif' object that
-matches the signature of the function you wish to call.  This is a
-separate step because it is common to make multiple calls using a single
-'ffi_cif'.  The "cif" in 'ffi_cif' stands for Call InterFace.  To
-prepare a call interface object, use the function 'ffi_prep_cif'.
-
- -- Function: ffi_status ffi_prep_cif (ffi_cif *CIF, ffi_abi ABI,
-          unsigned int NARGS, ffi_type *RTYPE, ffi_type **ARGTYPES)
-     This initializes CIF according to the given parameters.
-
-     ABI is the ABI to use; normally 'FFI_DEFAULT_ABI' is what you want.
-     *note Multiple ABIs:: for more information.
-
-     NARGS is the number of arguments that this function accepts.
-
-     RTYPE is a pointer to an 'ffi_type' structure that describes the
-     return type of the function.  *Note Types::.
-
-     ARGTYPES is a vector of 'ffi_type' pointers.  ARGTYPES must have
-     NARGS elements.  If NARGS is 0, this argument is ignored.
-
-     'ffi_prep_cif' returns a 'libffi' status code, of type
-     'ffi_status'.  This will be either 'FFI_OK' if everything worked
-     properly; 'FFI_BAD_TYPEDEF' if one of the 'ffi_type' objects is
-     incorrect; or 'FFI_BAD_ABI' if the ABI parameter is invalid.
-
-   If the function being called is variadic (varargs) then
-'ffi_prep_cif_var' must be used instead of 'ffi_prep_cif'.
-
- -- Function: ffi_status ffi_prep_cif_var (ffi_cif *CIF, ffi_abi varabi,
-          unsigned int NFIXEDARGS, unsigned int varntotalargs, ffi_type
-          *RTYPE, ffi_type **ARGTYPES)
-     This initializes CIF according to the given parameters for a call
-     to a variadic function.  In general it's operation is the same as
-     for 'ffi_prep_cif' except that:
-
-     NFIXEDARGS is the number of fixed arguments, prior to any variadic
-     arguments.  It must be greater than zero.
-
-     NTOTALARGS the total number of arguments, including variadic and
-     fixed arguments.
-
-     Note that, different cif's must be prepped for calls to the same
-     function when different numbers of arguments are passed.
-
-     Also note that a call to 'ffi_prep_cif_var' with
-     NFIXEDARGS=NOTOTALARGS is NOT equivalent to a call to
-     'ffi_prep_cif'.
-
-   To call a function using an initialized 'ffi_cif', use the 'ffi_call'
-function:
-
- -- Function: void ffi_call (ffi_cif *CIF, void *FN, void *RVALUE, void
-          **AVALUES)
-     This calls the function FN according to the description given in
-     CIF.  CIF must have already been prepared using 'ffi_prep_cif'.
-
-     RVALUE is a pointer to a chunk of memory that will hold the result
-     of the function call.  This must be large enough to hold the result
-     and must be suitably aligned; it is the caller's responsibility to
-     ensure this.  If CIF declares that the function returns 'void'
-     (using 'ffi_type_void'), then RVALUE is ignored.  If RVALUE is
-     'NULL', then the return value is discarded.
-
-     AVALUES is a vector of 'void *' pointers that point to the memory
-     locations holding the argument values for a call.  If CIF declares
-     that the function has no arguments (i.e., NARGS was 0), then
-     AVALUES is ignored.  Note that argument values may be modified by
-     the callee (for instance, structs passed by value); the burden of
-     copying pass-by-value arguments is placed on the caller.
-
-
-File: libffi.info,  Node: Simple Example,  Next: Types,  Prev: The Basics,  Up: Using libffi
-
-2.2 Simple Example
-==================
-
-Here is a trivial example that calls 'puts' a few times.
-
-     #include <stdio.h>
-     #include <ffi.h>
-
-     int main()
-     {
-       ffi_cif cif;
-       ffi_type *args[1];
-       void *values[1];
-       char *s;
-       int rc;
-
-       /* Initialize the argument info vectors */
-       args[0] = &ffi_type_pointer;
-       values[0] = &s;
-
-       /* Initialize the cif */
-       if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
-                       &ffi_type_uint, args) == FFI_OK)
-         {
-           s = "Hello World!";
-           ffi_call(&cif, puts, &rc, values);
-           /* rc now holds the result of the call to puts */
-
-           /* values holds a pointer to the function's arg, so to
-              call puts() again all we need to do is change the
-              value of s */
-           s = "This is cool!";
-           ffi_call(&cif, puts, &rc, values);
-         }
-
-       return 0;
-     }
-
-
-File: libffi.info,  Node: Types,  Next: Multiple ABIs,  Prev: Simple Example,  Up: Using libffi
-
-2.3 Types
-=========
-
-* Menu:
-
-* Primitive Types::             Built-in types.
-* Structures::                  Structure types.
-* Type Example::                Structure type example.
-
-
-File: libffi.info,  Node: Primitive Types,  Next: Structures,  Up: Types
-
-2.3.1 Primitive Types
----------------------
-
-'Libffi' provides a number of built-in type descriptors that can be used
-to describe argument and return types:
-
-'ffi_type_void'
-     The type 'void'.  This cannot be used for argument types, only for
-     return values.
-
-'ffi_type_uint8'
-     An unsigned, 8-bit integer type.
-
-'ffi_type_sint8'
-     A signed, 8-bit integer type.
-
-'ffi_type_uint16'
-     An unsigned, 16-bit integer type.
-
-'ffi_type_sint16'
-     A signed, 16-bit integer type.
-
-'ffi_type_uint32'
-     An unsigned, 32-bit integer type.
-
-'ffi_type_sint32'
-     A signed, 32-bit integer type.
-
-'ffi_type_uint64'
-     An unsigned, 64-bit integer type.
-
-'ffi_type_sint64'
-     A signed, 64-bit integer type.
-
-'ffi_type_float'
-     The C 'float' type.
-
-'ffi_type_double'
-     The C 'double' type.
-
-'ffi_type_uchar'
-     The C 'unsigned char' type.
-
-'ffi_type_schar'
-     The C 'signed char' type.  (Note that there is not an exact
-     equivalent to the C 'char' type in 'libffi'; ordinarily you should
-     either use 'ffi_type_schar' or 'ffi_type_uchar' depending on
-     whether 'char' is signed.)
-
-'ffi_type_ushort'
-     The C 'unsigned short' type.
-
-'ffi_type_sshort'
-     The C 'short' type.
-
-'ffi_type_uint'
-     The C 'unsigned int' type.
-
-'ffi_type_sint'
-     The C 'int' type.
-
-'ffi_type_ulong'
-     The C 'unsigned long' type.
-
-'ffi_type_slong'
-     The C 'long' type.
-
-'ffi_type_longdouble'
-     On platforms that have a C 'long double' type, this is defined.  On
-     other platforms, it is not.
-
-'ffi_type_pointer'
-     A generic 'void *' pointer.  You should use this for all pointers,
-     regardless of their real type.
-
-   Each of these is of type 'ffi_type', so you must take the address
-when passing to 'ffi_prep_cif'.
-
-
-File: libffi.info,  Node: Structures,  Next: Type Example,  Prev: Primitive Types,  Up: Types
-
-2.3.2 Structures
-----------------
-
-Although 'libffi' has no special support for unions or bit-fields, it is
-perfectly happy passing structures back and forth.  You must first
-describe the structure to 'libffi' by creating a new 'ffi_type' object
-for it.
-
- -- ffi_type:
-     The 'ffi_type' has the following members:
-     'size_t size'
-          This is set by 'libffi'; you should initialize it to zero.
-
-     'unsigned short alignment'
-          This is set by 'libffi'; you should initialize it to zero.
-
-     'unsigned short type'
-          For a structure, this should be set to 'FFI_TYPE_STRUCT'.
-
-     'ffi_type **elements'
-          This is a 'NULL'-terminated array of pointers to 'ffi_type'
-          objects.  There is one element per field of the struct.
-
-
-File: libffi.info,  Node: Type Example,  Prev: Structures,  Up: Types
-
-2.3.3 Type Example
-------------------
-
-The following example initializes a 'ffi_type' object representing the
-'tm' struct from Linux's 'time.h'.
-
-   Here is how the struct is defined:
-
-     struct tm {
-         int tm_sec;
-         int tm_min;
-         int tm_hour;
-         int tm_mday;
-         int tm_mon;
-         int tm_year;
-         int tm_wday;
-         int tm_yday;
-         int tm_isdst;
-         /* Those are for future use. */
-         long int __tm_gmtoff__;
-         __const char *__tm_zone__;
-     };
-
-   Here is the corresponding code to describe this struct to 'libffi':
-
-         {
-           ffi_type tm_type;
-           ffi_type *tm_type_elements[12];
-           int i;
-
-           tm_type.size = tm_type.alignment = 0;
-           tm_type.elements = &tm_type_elements;
-
-           for (i = 0; i < 9; i++)
-               tm_type_elements[i] = &ffi_type_sint;
-
-           tm_type_elements[9] = &ffi_type_slong;
-           tm_type_elements[10] = &ffi_type_pointer;
-           tm_type_elements[11] = NULL;
-
-           /* tm_type can now be used to represent tm argument types and
-         return types for ffi_prep_cif() */
-         }
-
-
-File: libffi.info,  Node: Multiple ABIs,  Next: The Closure API,  Prev: Types,  Up: Using libffi
-
-2.4 Multiple ABIs
-=================
-
-A given platform may provide multiple different ABIs at once.  For
-instance, the x86 platform has both 'stdcall' and 'fastcall' functions.
-
-   'libffi' provides some support for this.  However, this is
-necessarily platform-specific.
-
-
-File: libffi.info,  Node: The Closure API,  Next: Closure Example,  Prev: Multiple ABIs,  Up: Using libffi
-
-2.5 The Closure API
-===================
-
-'libffi' also provides a way to write a generic function - a function
-that can accept and decode any combination of arguments.  This can be
-useful when writing an interpreter, or to provide wrappers for arbitrary
-functions.
-
-   This facility is called the "closure API". Closures are not supported
-on all platforms; you can check the 'FFI_CLOSURES' define to determine
-whether they are supported on the current platform.
-
-   Because closures work by assembling a tiny function at runtime, they
-require special allocation on platforms that have a non-executable heap.
-Memory management for closures is handled by a pair of functions:
-
- -- Function: void *ffi_closure_alloc (size_t SIZE, void **CODE)
-     Allocate a chunk of memory holding SIZE bytes.  This returns a
-     pointer to the writable address, and sets *CODE to the
-     corresponding executable address.
-
-     SIZE should be sufficient to hold a 'ffi_closure' object.
-
- -- Function: void ffi_closure_free (void *WRITABLE)
-     Free memory allocated using 'ffi_closure_alloc'.  The argument is
-     the writable address that was returned.
-
-   Once you have allocated the memory for a closure, you must construct
-a 'ffi_cif' describing the function call.  Finally you can prepare the
-closure function:
-
- -- Function: ffi_status ffi_prep_closure_loc (ffi_closure *CLOSURE,
-          ffi_cif *CIF, void (*FUN) (ffi_cif *CIF, void *RET, void
-          **ARGS, void *USER_DATA), void *USER_DATA, void *CODELOC)
-     Prepare a closure function.
-
-     CLOSURE is the address of a 'ffi_closure' object; this is the
-     writable address returned by 'ffi_closure_alloc'.
-
-     CIF is the 'ffi_cif' describing the function parameters.
-
-     USER_DATA is an arbitrary datum that is passed, uninterpreted, to
-     your closure function.
-
-     CODELOC is the executable address returned by 'ffi_closure_alloc'.
-
-     FUN is the function which will be called when the closure is
-     invoked.  It is called with the arguments:
-     CIF
-          The 'ffi_cif' passed to 'ffi_prep_closure_loc'.
-
-     RET
-          A pointer to the memory used for the function's return value.
-          FUN must fill this, unless the function is declared as
-          returning 'void'.
-
-     ARGS
-          A vector of pointers to memory holding the arguments to the
-          function.
-
-     USER_DATA
-          The same USER_DATA that was passed to 'ffi_prep_closure_loc'.
-
-     'ffi_prep_closure_loc' will return 'FFI_OK' if everything went ok,
-     and something else on error.
-
-     After calling 'ffi_prep_closure_loc', you can cast CODELOC to the
-     appropriate pointer-to-function type.
-
-   You may see old code referring to 'ffi_prep_closure'.  This function
-is deprecated, as it cannot handle the need for separate writable and
-executable addresses.
-
-
-File: libffi.info,  Node: Closure Example,  Prev: The Closure API,  Up: Using libffi
-
-2.6 Closure Example
-===================
-
-A trivial example that creates a new 'puts' by binding 'fputs' with
-'stdin'.
-
-     #include <stdio.h>
-     #include <ffi.h>
-
-     /* Acts like puts with the file given at time of enclosure. */
-     void puts_binding(ffi_cif *cif, unsigned int *ret, void* args[],
-                       FILE *stream)
-     {
-       *ret = fputs(*(char **)args[0], stream);
-     }
-
-     int main()
-     {
-       ffi_cif cif;
-       ffi_type *args[1];
-       ffi_closure *closure;
-
-       int (*bound_puts)(char *);
-       int rc;
-
-       /* Allocate closure and bound_puts */
-       closure = ffi_closure_alloc(sizeof(ffi_closure), &bound_puts);
-
-       if (closure)
-         {
-           /* Initialize the argument info vectors */
-           args[0] = &ffi_type_pointer;
-
-           /* Initialize the cif */
-           if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
-                            &ffi_type_uint, args) == FFI_OK)
-             {
-               /* Initialize the closure, setting stream to stdout */
-               if (ffi_prep_closure_loc(closure, &cif, puts_binding,
-                                        stdout, bound_puts) == FFI_OK)
-                 {
-                   rc = bound_puts("Hello World!");
-                   /* rc now holds the result of the call to fputs */
-                 }
-             }
-         }
-
-       /* Deallocate both closure, and bound_puts */
-       ffi_closure_free(closure);
-
-       return 0;
-     }
-
-
-File: libffi.info,  Node: Missing Features,  Next: Index,  Prev: Using libffi,  Up: Top
-
-3 Missing Features
-******************
-
-'libffi' is missing a few features.  We welcome patches to add support
-for these.
-
-   * Variadic closures.
-
-   * There is no support for bit fields in structures.
-
-   * The closure API is
-
-   * The "raw" API is undocumented.
-
-   Note that variadic support is very new and tested on a relatively
-small number of platforms.
-
-
-File: libffi.info,  Node: Index,  Prev: Missing Features,  Up: Top
-
-Index
-*****
-
-[index]
-* Menu:
-
-* ABI:                                   Introduction.         (line 13)
-* Application Binary Interface:          Introduction.         (line 13)
-* calling convention:                    Introduction.         (line 13)
-* cif:                                   The Basics.           (line 14)
-* closure API:                           The Closure API.      (line 13)
-* closures:                              The Closure API.      (line 13)
-* FFI:                                   Introduction.         (line 31)
-* ffi_call:                              The Basics.           (line 62)
-* FFI_CLOSURES:                          The Closure API.      (line 13)
-* ffi_closure_alloc:                     The Closure API.      (line 19)
-* ffi_closure_free:                      The Closure API.      (line 26)
-* ffi_prep_cif:                          The Basics.           (line 16)
-* ffi_prep_cif_var:                      The Basics.           (line 39)
-* ffi_prep_closure_loc:                  The Closure API.      (line 34)
-* ffi_status:                            The Basics.           (line 16)
-* ffi_status <1>:                        The Basics.           (line 39)
-* ffi_status <2>:                        The Closure API.      (line 34)
-* ffi_type:                              Structures.           (line 11)
-* ffi_type_double:                       Primitive Types.      (line 41)
-* ffi_type_float:                        Primitive Types.      (line 38)
-* ffi_type_longdouble:                   Primitive Types.      (line 71)
-* ffi_type_pointer:                      Primitive Types.      (line 75)
-* ffi_type_schar:                        Primitive Types.      (line 47)
-* ffi_type_sint:                         Primitive Types.      (line 62)
-* ffi_type_sint16:                       Primitive Types.      (line 23)
-* ffi_type_sint32:                       Primitive Types.      (line 29)
-* ffi_type_sint64:                       Primitive Types.      (line 35)
-* ffi_type_sint8:                        Primitive Types.      (line 17)
-* ffi_type_slong:                        Primitive Types.      (line 68)
-* ffi_type_sshort:                       Primitive Types.      (line 56)
-* ffi_type_uchar:                        Primitive Types.      (line 44)
-* ffi_type_uint:                         Primitive Types.      (line 59)
-* ffi_type_uint16:                       Primitive Types.      (line 20)
-* ffi_type_uint32:                       Primitive Types.      (line 26)
-* ffi_type_uint64:                       Primitive Types.      (line 32)
-* ffi_type_uint8:                        Primitive Types.      (line 14)
-* ffi_type_ulong:                        Primitive Types.      (line 65)
-* ffi_type_ushort:                       Primitive Types.      (line 53)
-* ffi_type_void:                         Primitive Types.      (line 10)
-* Foreign Function Interface:            Introduction.         (line 31)
-* void:                                  The Basics.           (line 62)
-* void <1>:                              The Closure API.      (line 19)
-* void <2>:                              The Closure API.      (line 26)
-
-
-
-Tag Table:
-Node: Top682
-Node: Introduction1429
-Node: Using libffi3061
-Node: The Basics3547
-Node: Simple Example7187
-Node: Types8214
-Node: Primitive Types8497
-Node: Structures10318
-Node: Type Example11182
-Node: Multiple ABIs12405
-Node: The Closure API12776
-Node: Closure Example15720
-Node: Missing Features17279
-Node: Index17732
-
-End Tag Table

libgo/Makefile.am

@@ -424 +424 @@
         runtime/go-caller.c \
         runtime/go-callers.c \
         runtime/go-can-convert-interface.c \
+        runtime/go-cdiv.c \
         runtime/go-cgo.c \
         runtime/go-check-interface.c \
         runtime/go-construct-map.c \

libgo/Makefile.in

@@ -195 +195 @@
 @LIBGO_IS_LINUX_TRUE@am__objects_5 = getncpu-linux.lo
 am__objects_6 = go-append.lo go-assert.lo go-assert-interface.lo \
         go-byte-array-to-string.lo go-breakpoint.lo go-caller.lo \
-        go-callers.lo go-can-convert-interface.lo go-cgo.lo \
+        go-callers.lo go-can-convert-interface.lo go-cdiv.lo go-cgo.lo \
         go-check-interface.lo go-construct-map.lo \
         go-convert-interface.lo go-copy.lo go-defer.lo \
         go-deferred-recover.lo go-eface-compare.lo \
@@ -757 +757 @@
         runtime/go-caller.c \
         runtime/go-callers.c \
         runtime/go-can-convert-interface.c \
+        runtime/go-cdiv.c \
         runtime/go-cgo.c \
         runtime/go-check-interface.c \
         runtime/go-construct-map.c \
@@ -2368 +2369 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-caller.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-callers.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-can-convert-interface.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-cdiv.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-cgo.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-check-interface.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/go-construct-map.Plo@am__quote@
@@ -2554 +2556 @@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o go-can-convert-interface.lo `test -f 'runtime/go-can-convert-interface.c' || echo '$(srcdir)/'`runtime/go-can-convert-interface.c
 
+go-cdiv.lo: runtime/go-cdiv.c
+@am__fastdepCC_TRUE@    $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT go-cdiv.lo -MD -MP -MF $(DEPDIR)/go-cdiv.Tpo -c -o go-cdiv.lo `test -f 'runtime/go-cdiv.c' || echo '$(srcdir)/'`runtime/go-cdiv.c
+@am__fastdepCC_TRUE@    $(am__mv) $(DEPDIR)/go-cdiv.Tpo $(DEPDIR)/go-cdiv.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='runtime/go-cdiv.c' object='go-cdiv.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o go-cdiv.lo `test -f 'runtime/go-cdiv.c' || echo '$(srcdir)/'`runtime/go-cdiv.c
+
 go-cgo.lo: runtime/go-cgo.c
 @am__fastdepCC_TRUE@    $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT go-cgo.lo -MD -MP -MF $(DEPDIR)/go-cgo.Tpo -c -o go-cgo.lo `test -f 'runtime/go-cgo.c' || echo '$(srcdir)/'`runtime/go-cgo.c
 @am__fastdepCC_TRUE@    $(am__mv) $(DEPDIR)/go-cgo.Tpo $(DEPDIR)/go-cgo.Plo

libgo/config.h.in

@@ -39 +39 @@
 /* Define to 1 if you have the `dl_iterate_phdr' function. */
 #undef HAVE_DL_ITERATE_PHDR
 
+/* Define to 1 if you have the `dup3' function. */
+#undef HAVE_DUP3
+
 /* Define to 1 if you have the `epoll_create1' function. */
 #undef HAVE_EPOLL_CREATE1
 
@@ -66 +69 @@
 /* Define if _Unwind_GetIPInfo is available. */
 #undef HAVE_GETIPINFO
 
+/* Define to 1 if you have the `getxattr' function. */
+#undef HAVE_GETXATTR
+
 /* Define to 1 if you have the `inotify_add_watch' function. */
 #undef HAVE_INOTIFY_ADD_WATCH
 
@@ -111 +117 @@
 /* Define to 1 if you have the <linux/rtnetlink.h> header file. */
 #undef HAVE_LINUX_RTNETLINK_H
 
+/* Define to 1 if you have the `listxattr' function. */
+#undef HAVE_LISTXATTR
+
 /* Define to 1 if the system has the type `loff_t'. */
 #undef HAVE_LOFF_T
 
@@ -171 +180 @@
 /* Define to 1 if you have the `pipe2' function. */
 #undef HAVE_PIPE2
 
+/* Define to 1 if you have the `removexattr' function. */
+#undef HAVE_REMOVEXATTR
+
 /* Define to 1 if you have the `renameat' function. */
 #undef HAVE_RENAMEAT
 
@@ -180 +192 @@
 /* Define to 1 if you have the `setenv' function. */
 #undef HAVE_SETENV
 
+/* Define to 1 if you have the `setxattr' function. */
+#undef HAVE_SETXATTR
+
 /* Define to 1 if you have the `sinl' function. */
 #undef HAVE_SINL
 

libgo/configure

@@ -14700 +14700 @@
 fi
 
 
-for ac_func in accept4 epoll_create1 faccessat fallocate fchmodat fchownat futimesat inotify_add_watch inotify_init inotify_init1 inotify_rm_watch mkdirat mknodat openat pipe2 renameat sync_file_range splice tee unlinkat unshare utimensat
+for ac_func in accept4 dup3 epoll_create1 faccessat fallocate fchmodat fchownat futimesat getxattr inotify_add_watch inotify_init inotify_init1 inotify_rm_watch listxattr mkdirat mknodat openat pipe2 removexattr renameat setxattr sync_file_range splice tee unlinkat unshare utimensat
 do :
   as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"

libgo/configure.ac

@@ -503 +503 @@
 AM_CONDITIONAL(HAVE_STRERROR_R, test "$ac_cv_func_strerror_r" = yes)
 AM_CONDITIONAL(HAVE_WAIT4, test "$ac_cv_func_wait4" = yes)
 
-AC_CHECK_FUNCS(accept4 epoll_create1 faccessat fallocate fchmodat fchownat futimesat inotify_add_watch inotify_init inotify_init1 inotify_rm_watch mkdirat mknodat openat pipe2 renameat sync_file_range splice tee unlinkat unshare utimensat)
+AC_CHECK_FUNCS(accept4 dup3 epoll_create1 faccessat fallocate fchmodat fchownat futimesat getxattr inotify_add_watch inotify_init inotify_init1 inotify_rm_watch listxattr mkdirat mknodat openat pipe2 removexattr renameat setxattr sync_file_range splice tee unlinkat unshare utimensat)
 AC_TYPE_OFF_T
 AC_CHECK_TYPES([loff_t])
 

libgo/go/syscall/libcall_linux.go

@@ -190 +190 @@
 //sys   Adjtimex(buf *Timex) (state int, err error)
 //adjtimex(buf *Timex) _C_int
 
+//sysnb Dup3(oldfd int, newfd int, flags int) (err error)
+//dup3(oldfd _C_int, newfd _C_int, flags _C_int) _C_int
+
 //sys   Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 //faccessat(dirfd _C_int, pathname *byte, mode _C_int, flags _C_int) _C_int
 
@@ -268 +271 @@
         return origlen - len(buf), count, names
 }
 
+//sys   Getxattr(path string, attr string, dest []byte) (sz int, err error)
+//getxattr(path *byte, attr *byte, buf *byte, count Size_t) Ssize_t
+
 //sys   InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error)
 //inotify_add_watch(fd _C_int, pathname *byte, mask uint32) _C_int
 
@@ -283 +289 @@
 //sys   Klogctl(typ int, buf []byte) (n int, err error)
 //klogctl(typ _C_int, bufp *byte, len _C_int) _C_int
 
+//sys   Listxattr(path string, dest []byte) (sz int, err error)
+//listxattr(path *byte, list *byte, size Size_t) Ssize_t
+
 //sys   Mkdirat(dirfd int, path string, mode uint32) (err error)
 //mkdirat(dirfd _C_int, path *byte, mode Mode_t) _C_int
 
@@ -305 +314 @@
 //sys   PivotRoot(newroot string, putold string) (err error)
 //pivot_root(newroot *byte, putold *byte) _C_int
 
+//sys   Removexattr(path string, attr string) (err error)
+//removexattr(path *byte, name *byte) _C_int
+
 //sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
 //renameat(olddirfd _C_int, oldpath *byte, newdirfd _C_int, newpath *byte) _C_int
 
@@ -338 +350 @@
 //sysnb Setresuid(ruid int, eguid int, suid int) (err error)
 //setresuid(ruid Uid_t, euid Uid_t, suid Uid_t) _C_int
 
+//sys   Setxattr(path string, attr string, data []byte, flags int) (err error)
+//setxattr(path *byte, name *byte, value *byte, size Size_t, flags _C_int) _C_int
+
 //sys   splice(rfd int, roff *_loff_t, wfd int, woff *_loff_t, len int, flags int) (n int64, err error)
 //splice(rfd _C_int, roff *_loff_t, wfd _C_int, woff *_loff_t, len Size_t, flags _C_uint) Ssize_t
 func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) {

libgo/go/syscall/libcall_posix.go

@@ -238 +238 @@
 //sysnb Getppid() (ppid int)
 //getppid() Pid_t
 
+//sys Getpriority(which int, who int) (prio int, err error)
+//getpriority(which _C_int, who _C_int) _C_int
+
 //sysnb Getrlimit(resource int, rlim *Rlimit) (err error)
 //getrlimit(resource _C_int, rlim *Rlimit) _C_int
 
@@ -307 +310 @@
 //sysnb Setpgid(pid int, pgid int) (err error)
 //setpgid(pid Pid_t, pgid Pid_t) _C_int
 
+//sys Setpriority(which int, who int, prio int) (err error)
+//setpriority(which _C_int, who _C_int, prio _C_int) _C_int
+
 //sysnb Setreuid(ruid int, euid int) (err error)
 //setreuid(ruid Uid_t, euid Uid_t) _C_int
 

libgo/mksysinfo.sh

@@ -1035 +1035 @@
 grep '^const _LOCK_' gen-sysinfo.go |
     sed -e 's/^\(const \)_\(LOCK_[^= ]*\)\(.*\)$/\1\2 = _\2/' >> ${OUT}
 
+# The PRIO constants.
+grep '^const _PRIO_' gen-sysinfo.go | \
+  sed -e 's/^\(const \)_\(PRIO_[^= ]*\)\(.*\)$/\1\2 = _\2/' >> ${OUT}
+
 # The GNU/Linux LINUX_REBOOT flags.
 grep '^const _LINUX_REBOOT_' gen-sysinfo.go |
     sed -e 's/^\(const \)_\(LINUX_REBOOT_[^= ]*\)\(.*\)$/\1\2 = _\2/' >> ${OUT}

libgo/runtime/go-cdiv.c

@@ +1 @@
+/* go-cdiv.c -- complex division routines
+
+   Copyright 2013 The Go Authors. All rights reserved.
+   Use of this source code is governed by a BSD-style
+   license that can be found in the LICENSE file.  */
+
+/* Calls to these functions are generated by the Go frontend for
+   division of complex64 or complex128.  We use these because Go's
+   complex division expects slightly different results from the GCC
+   default.  When dividing NaN+1.0i / 0+0i, Go expects NaN+NaNi but
+   GCC generates NaN+Infi.  NaN+Infi seems wrong seems the rules of
+   C99 Annex G specify that if either side of a complex number is Inf,
+   the the whole number is Inf, but an operation involving NaN ought
+   to result in NaN, not Inf.  */
+
+__complex float
+__go_complex64_div (__complex float a, __complex float b)
+{
+  if (__builtin_expect (b == 0+0i, 0))
+    {
+      if (!__builtin_isinff (__real__ a)
+          && !__builtin_isinff (__imag__ a)
+          && (__builtin_isnanf (__real__ a) || __builtin_isnanf (__imag__ a)))
+        {
+          /* Pass "1" to nanf to match math/bits.go.  */
+          return __builtin_nanf("1") + __builtin_nanf("1")*1i;
+        }
+    }
+  return a / b;
+}
+
+__complex double
+__go_complex128_div (__complex double a, __complex double b)
+{
+  if (__builtin_expect (b == 0+0i, 0))
+    {
+      if (!__builtin_isinf (__real__ a)
+          && !__builtin_isinf (__imag__ a)
+          && (__builtin_isnan (__real__ a) || __builtin_isnan (__imag__ a)))
+        {
+          /* Pass "1" to nan to match math/bits.go.  */
+          return __builtin_nan("1") + __builtin_nan("1")*1i;
+        }
+    }
+  return a / b;
+}

libgo/runtime/go-make-slice.c

@@ -34 +34 @@
   std = (const struct __go_slice_type *) td;
 
   ilen = (intgo) len;
-  if (ilen < 0 || (uintptr_t) ilen != len)
+  if (ilen < 0
+      || (uintptr_t) ilen != len
+      || (std->__element_type->__size > 0
+          && len > MaxMem / std->__element_type->__size))
     runtime_panicstring ("makeslice: len out of range");
 
   icap = (intgo) cap;

libgo/runtime/go-nosys.c

@@ -43 +43 @@
 }
 #endif
 
+#ifndef HAVE_DUP3
+int
+dup3 (int oldfd __attribute__ ((unused)),
+      int newfd __attribute__ ((unused)),
+      int flags __attribute__ ((unused)))
+{
+  errno = ENOSYS;
+  return -1;
+}
+#endif
+
 #ifndef HAVE_EPOLL_CREATE1
 int
 epoll_create1 (int flags __attribute__ ((unused)))
@@ -112 +123 @@
 }
 #endif
 
+#ifndef HAVE_GETXATTR
+ssize_t
+getxattr (const char *path __attribute__ ((unused)),
+          const char *name __attribute__ ((unused)),
+          void *value __attribute__ ((unused)),
+          size_t size __attribute__ ((unused)))
+{
+  errno = ENOSYS;
+  return -1;
+}
+#endif
+
 #ifndef HAVE_INOTIFY_ADD_WATCH
 int
 inotify_add_watch (int fd __attribute__ ((unused)),
@@ -151 +174 @@
 }
 #endif
 
+#ifndef HAVE_LISTXATTR
+ssize_t
+listxattr (const char *path __attribute__ ((unused)),
+           char *list __attribute__ ((unused)),
+           size_t size __attribute__ ((unused)))
+{
+  errno = ENOSYS;
+  return -1;
+}
+#endif
+
 #ifndef HAVE_MKDIRAT
 int
 mkdirat (int dirfd __attribute__ ((unused)),
@@ -196 +230 @@
 }
 #endif
 
+#ifndef HAVE_REMOVEXATTR
+int
+removexattr (const char *path __attribute__ ((unused)),
+             const char *name __attribute__ ((unused)))
+{
+  errno = ENOSYS;
+  return -1;
+}
+#endif
+
 #ifndef HAVE_RENAMEAT
 int
 renameat (int olddirfd __attribute__ ((unused)),
@@ -205 +249 @@
 {
   errno = ENOSYS;
   return -1;
+}
+#endif
+
+#ifndef HAVE_SETXATTR
+int
+setxattr (const char *path __attribute__ ((unused)),
+          const char *name __attribute__ ((unused)),
+          const void *value __attribute__ ((unused)),
+          size_t size __attribute__ ((unused)),
+          int flags __attribute__ ((unused)))
+{
+  errno = ENOSYS;
+  return -1;
 }
 #endif
 

libgo/runtime/go-signal.c

@@ -399 +399 @@
 {
   G *gp;
   M *mp;
+#ifdef USING_SPLIT_STACK
+  void *stack_context[10];
+#endif
 
   /* We are now running on the stack registered via sigaltstack.
      (Actually there is a small span of time between runtime_siginit
@@ -409 +412 @@
   if (gp != NULL)
     {
 #ifdef USING_SPLIT_STACK
-      __splitstack_getcontext (&gp->stack_context[0]);
+      __splitstack_getcontext (&stack_context[0]);
 #endif
     }
 
@@ -432 +435 @@
   if (gp != NULL)
     {
 #ifdef USING_SPLIT_STACK
-      __splitstack_setcontext (&gp->stack_context[0]);
+      __splitstack_setcontext (&stack_context[0]);
 #endif
     }
 }

libitm/libitm.info

@@ -1 @@
-This is libitm.info, produced by makeinfo version 5.1 from libitm.texi.
-
-Copyright (C) 2011-2013 Free Software Foundation, Inc.
-
-   Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A
-copy of the license is included in the section entitled "GNU Free
-Documentation License".
-INFO-DIR-SECTION GNU Libraries
-START-INFO-DIR-ENTRY
-* libitm: (libitm).                    GNU Transactional Memory Library
-END-INFO-DIR-ENTRY
-
-   This manual documents the GNU Transactional Memory Library.
-
-   Copyright (C) 2011-2013 Free Software Foundation, Inc.
-
-   Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A
-copy of the license is included in the section entitled "GNU Free
-Documentation License".
-
-
-File: libitm.info,  Node: Top,  Next: Enabling libitm,  Up: (dir)
-
-Introduction
-************
-
-This manual documents the usage and internals of libitm, the GNU
-Transactional Memory Library.  It provides transaction support for
-accesses to a process' memory, enabling easy-to-use synchronization of
-accesses to shared memory by several threads.
-
-* Menu:
-
-* Enabling libitm::            How to enable libitm for your applications.
-* C/C++ Language Constructs for TM::
-                               Notes on the language-level interface supported
-                               by gcc.
-* The libitm ABI::             Notes on the external ABI provided by libitm.
-* Internals::                  Notes on libitm's internal synchronization.
-* GNU Free Documentation License::
-                               How you can copy and share this manual.
-* Index::                      Index of this documentation.
-
-
-File: libitm.info,  Node: Enabling libitm,  Next: C/C++ Language Constructs for TM,  Prev: Top,  Up: Top
-
-1 Enabling libitm
-*****************
-
-To activate support for TM in C/C++, the compile-time flag '-fgnu-tm'
-must be specified.  This enables TM language-level constructs such as
-transaction statements (e.g., '__transaction_atomic', *note C/C++
-Language Constructs for TM:: for details).
-
-
-File: libitm.info,  Node: C/C++ Language Constructs for TM,  Next: The libitm ABI,  Prev: Enabling libitm,  Up: Top
-
-2 C/C++ Language Constructs for TM
-**********************************
-
-Transactions are supported in C++ and C in the form of transaction
-statements, transaction expressions, and function transactions.  In the
-following example, both 'a' and 'b' will be read and the difference will
-be written to 'c', all atomically and isolated from other transactions:
-
-     __transaction_atomic { c = a - b; }
-
-   Therefore, another thread can use the following code to concurrently
-update 'b' without ever causing 'c' to hold a negative value (and
-without having to use other synchronization constructs such as locks or
-C++11 atomics):
-
-     __transaction_atomic { if (a > b) b++; }
-
-   GCC follows the Draft Specification of Transactional Language
-Constructs for C++ (v1.1)
-(https://sites.google.com/site/tmforcplusplus/) in its implementation of
-transactions.
-
-   The precise semantics of transactions are defined in terms of the
-C++11/C11 memory model (see the specification).  Roughly, transactions
-provide synchronization guarantees that are similar to what would be
-guaranteed when using a single global lock as a guard for all
-transactions.  Note that like other synchronization constructs in C/C++,
-transactions rely on a data-race-free program (e.g., a nontransactional
-write that is concurrent with a transactional read to the same memory
-location is a data race).
-
-
-File: libitm.info,  Node: The libitm ABI,  Next: Internals,  Prev: C/C++ Language Constructs for TM,  Up: Top
-
-3 The libitm ABI
-****************
-
-The ABI provided by libitm is basically equal to the Linux variant of
-Intel's current TM ABI specification document (Revision 1.1, May 6 2009)
-but with the differences listed in this chapter.  It would be good if
-these changes would eventually be merged into a future version of this
-specification.  To ease look-up, the following subsections mirror the
-structure of this specification.
-
-3.1 [No changes] Objectives
-===========================
-
-3.2 [No changes] Non-objectives
-===============================
-
-3.3 Library design principles
-=============================
-
-3.3.1 [No changes] Calling conventions
---------------------------------------
-
-3.3.2 [No changes] TM library algorithms
-----------------------------------------
-
-3.3.3 [No changes] Optimized load and store routines
-----------------------------------------------------
-
-3.3.4 [No changes] Aligned load and store routines
---------------------------------------------------
-
-3.3.5 Data logging functions
-----------------------------
-
-The memory locations accessed with transactional loads and stores and
-the memory locations whose values are logged must not overlap.  This
-required separation only extends to the scope of the execution of one
-transaction including all the executions of all nested transactions.
-
-   The compiler must be consistent (within the scope of a single
-transaction) about which memory locations are shared and which are not
-shared with other threads (i.e., data must be accessed either
-transactionally or nontransactionally).  Otherwise, non-write-through TM
-algorithms would not work.
-
-   For memory locations on the stack, this requirement extends to only
-the lifetime of the stack frame that the memory location belongs to (or
-the lifetime of the transaction, whichever is shorter).  Thus, memory
-that is reused for several stack frames could be target of both data
-logging and transactional accesses; however, this is harmless because
-these stack frames' lifetimes will end before the transaction finishes.
-
-3.3.6 [No changes] Scatter/gather calls
----------------------------------------
-
-3.3.7 [No changes] Serial and irrevocable mode
-----------------------------------------------
-
-3.3.8 [No changes] Transaction descriptor
------------------------------------------
-
-3.3.9 Store allocation
-----------------------
-
-There is no 'getTransaction' function.
-
-3.3.10 [No changes] Naming conventions
---------------------------------------
-
-3.3.11 Function pointer encryption
-----------------------------------
-
-Currently, this is not implemented.
-
-3.4 Types and macros list
-=========================
-
-'_ITM_codeProperties' has changed, *note Starting a transaction:
-txn-code-properties.  '_ITM_srcLocation' is not used.
-
-3.5 Function list
-=================
-
-3.5.1 Initialization and finalization functions
------------------------------------------------
-
-These functions are not part of the ABI.
-
-3.5.2 [No changes] Version checking
------------------------------------
-
-3.5.3 [No changes] Error reporting
-----------------------------------
-
-3.5.4 [No changes] inTransaction call
--------------------------------------
-
-3.5.5 State manipulation functions
-----------------------------------
-
-There is no 'getTransaction' function.  Transaction identifiers for
-nested transactions will be ordered but not necessarily sequential
-(i.e., for a nested transaction's identifier IN and its enclosing
-transaction's identifier IE, it is guaranteed that IN >= IE).
-
-3.5.6 [No changes] Source locations
------------------------------------
-
-3.5.7 Starting a transaction
-----------------------------
-
-3.5.7.1 Transaction code properties
-...................................
-
-The bit 'hasNoXMMUpdate' is instead called 'hasNoVectorUpdate'.  Iff it
-is set, vector register save/restore is not necessary for any target
-machine.
-
-   The 'hasNoFloatUpdate' bit ('0x0010') is new.  Iff it is set,
-floating point register save/restore is not necessary for any target
-machine.
-
-   'undoLogCode' is not supported and a fatal runtime error will be
-raised if this bit is set.  It is not properly defined in the ABI why
-barriers other than undo logging are not present; Are they not necessary
-(e.g., a transaction operating purely on thread-local data) or have they
-been omitted by the compiler because it thinks that some kind of global
-synchronization (e.g., serial mode) might perform better?  The
-specification suggests that the latter might be the case, but the former
-seems to be more useful.
-
-   The 'readOnly' bit ('0x4000') is new.  *TODO* Lexical or dynamic
-scope?
-
-   'hasNoRetry' is not supported.  If this bit is not set, but
-'hasNoAbort' is set, the library can assume that transaction rollback
-will not be requested.
-
-   It would be useful if the absence of externally-triggered rollbacks
-would be reported for the dynamic scope as well, not just for the
-lexical scope ('hasNoAbort').  Without this, a library cannot exploit
-this together with flat nesting.
-
-   'exceptionBlock' is not supported because exception blocks are not
-used.
-
-3.5.7.2 [No changes] Windows exception state
-............................................
-
-3.5.7.3 [No changes] Other machine state
-........................................
-
-3.5.7.4 [No changes] Results from beginTransaction
-..................................................
-
-3.5.8 Aborting a transaction
-----------------------------
-
-'_ITM_rollbackTransaction' is not supported.  '_ITM_abortTransaction' is
-supported but the abort reasons 'exceptionBlockAbort', 'TMConflict', and
-'userRetry' are not supported.  There are no exception blocks in
-general, so the related cases also do not have to be considered.  To
-encode '__transaction_cancel [[outer]]', compilers must set the new
-'outerAbort' bit ('0x10') additionally to the 'userAbort' bit in the
-abort reason.
-
-3.5.9 Committing a transaction
-------------------------------
-
-The exception handling (EH) scheme is different.  The Intel ABI requires
-the '_ITM_tryCommitTransaction' function that will return even when the
-commit failed and will have to be matched with calls to either
-'_ITM_abortTransaction' or '_ITM_commitTransaction'.  In contrast, gcc
-relies on transactional wrappers for the functions of the Exception
-Handling ABI and on one additional commit function (shown below).  This
-allows the TM to keep track of EH internally and thus it does not have
-to embed the cleanup of EH state into the existing EH code in the
-program.  '_ITM_tryCommitTransaction' is not supported.
-'_ITM_commitTransactionToId' is also not supported because the
-propagation of thrown exceptions will not bypass commits of nested
-transactions.
-
-     void _ITM_commitTransactionEH(void *exc_ptr) ITM_REGPARM;
-     void *_ITM_cxa_allocate_exception (size_t);
-     void _ITM_cxa_throw (void *obj, void *tinfo, void *dest);
-     void *_ITM_cxa_begin_catch (void *exc_ptr);
-     void _ITM_cxa_end_catch (void);
-
-   '_ITM_commitTransactionEH' must be called to commit a transaction if
-an exception could be in flight at this position in the code.  'exc_ptr'
-is the current exception or zero if there is no current exception.  The
-'_ITM_cxa...' functions are transactional wrappers for the respective
-'__cxa...' functions and must be called instead of these in
-transactional code.
-
-   To support this EH scheme, libstdc++ needs to provide one additional
-function ('_cxa_tm_cleanup'), which is used by the TM to clean up the
-exception handling state while rolling back a transaction:
-
-     void __cxa_tm_cleanup (void *unthrown_obj, void *cleanup_exc,
-                            unsigned int caught_count);
-
-   'unthrown_obj' is non-null if the program called
-'__cxa_allocate_exception' for this exception but did not yet called
-'__cxa_throw' for it.  'cleanup_exc' is non-null if the program is
-currently processing a cleanup along an exception path but has not
-caught this exception yet.  'caught_count' is the nesting depth of
-'__cxa_begin_catch' within the transaction (which can be counted by the
-TM using '_ITM_cxa_begin_catch' and '_ITM_cxa_end_catch');
-'__cxa_tm_cleanup' then performs rollback by essentially performing
-'__cxa_end_catch' that many times.
-
-3.5.10 Exception handling support
----------------------------------
-
-Currently, there is no support for functionality like
-'__transaction_cancel throw' as described in the C++ TM specification.
-Supporting this should be possible with the EH scheme explained
-previously because via the transactional wrappers for the EH ABI, the TM
-is able to observe and intercept EH.
-
-3.5.11 [No changes] Transition to serial-irrevocable mode
----------------------------------------------------------
-
-3.5.12 [No changes] Data transfer functions
--------------------------------------------
-
-3.5.13 [No changes] Transactional memory copies
------------------------------------------------
-
-3.5.14 Transactional versions of memmove
-----------------------------------------
-
-If either the source or destination memory region is to be accessed
-nontransactionally, then source and destination regions must not be
-overlapping.  The respective '_ITM_memmove' functions are still
-available but a fatal runtime error will be raised if such regions do
-overlap.  To support this functionality, the ABI would have to specify
-how the intersection of the regions has to be accessed (i.e.,
-transactionally or nontransactionally).
-
-3.5.15 [No changes] Transactional versions of memset
-----------------------------------------------------
-
-3.5.16 [No changes] Logging functions
--------------------------------------
-
-3.5.17 User-registered commit and undo actions
-----------------------------------------------
-
-Commit actions will get executed in the same order in which the
-respective calls to '_ITM_addUserCommitAction' happened.  Only
-'_ITM_noTransactionId' is allowed as value for the
-'resumingTransactionId' argument.  Commit actions get executed after
-privatization safety has been ensured.
-
-   Undo actions will get executed in reverse order compared to the order
-in which the respective calls to '_ITM_addUserUndoAction' happened.  The
-ordering of undo actions w.r.t.  the roll-back of other actions (e.g.,
-data transfers or memory allocations) is undefined.
-
-   '_ITM_getThreadnum' is not supported currently because its only
-purpose is to provide a thread ID that matches some assumed performance
-tuning output, but this output is not part of the ABI nor further
-defined by it.
-
-   '_ITM_dropReferences' is not supported currently because its
-semantics and the intention behind it is not entirely clear.  The
-specification suggests that this function is necessary because of
-certain orderings of data transfer undos and the releasing of memory
-regions (i.e., privatization).  However, this ordering is never defined,
-nor is the ordering of dropping references w.r.t.  other events.
-
-3.5.18 [New] Transactional indirect calls
------------------------------------------
-
-Indirect calls (i.e., calls through a function pointer) within
-transactions should execute the transactional clone of the original
-function (i.e., a clone of the original that has been fully instrumented
-to use the TM runtime), if such a clone is available.  The runtime
-provides two functions to register/deregister clone tables:
-
-     struct clone_entry
-     {
-       void *orig, *clone;
-     };
-
-     void _ITM_registerTMCloneTable (clone_entry *table, size_t entries);
-     void _ITM_deregisterTMCloneTable (clone_entry *table);
-
-   Registered tables must be writable by the TM runtime, and must be
-live throughout the life-time of the TM runtime.
-
-   *TODO* The intention was always to drop the registration functions
-entirely, and create a new ELF Phdr describing the linker-sorted table.
-Much like what currently happens for 'PT_GNU_EH_FRAME'.  This work kept
-getting bogged down in how to represent the N different code generation
-variants.  We clearly needed at least two--SW and HW transactional
-clones--but there was always a suggestion of more variants for different
-TM assumptions/invariants.
-
-   The compiler can then use two TM runtime functions to perform
-indirect calls in transactions:
-     void *_ITM_getTMCloneOrIrrevocable (void *function) ITM_REGPARM;
-     void *_ITM_getTMCloneSafe (void *function) ITM_REGPARM;
-
-   If there is a registered clone for supplied function, both will
-return a pointer to the clone.  If not, the first runtime function will
-attempt to switch to serial-irrevocable mode and return the original
-pointer, whereas the second will raise a fatal runtime error.
-
-3.5.19 [New] Transactional dynamic memory management
-----------------------------------------------------
-
-     void *_ITM_malloc (size_t)
-            __attribute__((__malloc__)) ITM_PURE;
-     void *_ITM_calloc (size_t, size_t)
-            __attribute__((__malloc__)) ITM_PURE;
-     void _ITM_free (void *) ITM_PURE;
-
-   These functions are essentially transactional wrappers for 'malloc',
-'calloc', and 'free'.  Within transactions, the compiler should replace
-calls to the original functions with calls to the wrapper functions.
-
-3.6 [No changes] Future Enhancements to the ABI
-===============================================
-
-3.7 Sample code
-===============
-
-The code examples might not be correct w.r.t.  the current version of
-the ABI, especially everything related to exception handling.
-
-3.8 [New] Memory model
-======================
-
-The ABI should define a memory model and the ordering that is guaranteed
-for data transfers and commit/undo actions, or at least refer to another
-memory model that needs to be preserved.  Without that, the compiler
-cannot ensure the memory model specified on the level of the programming
-language (e.g., by the C++ TM specification).
-
-   For example, if a transactional load is ordered before another
-load/store, then the TM runtime must also ensure this ordering when
-accessing shared state.  If not, this might break the kind of
-publication safety used in the C++ TM specification.  Likewise, the TM
-runtime must ensure privatization safety.
-
-
-File: libitm.info,  Node: Internals,  Next: GNU Free Documentation License,  Prev: The libitm ABI,  Up: Top
-
-4 Internals
-***********
-
-4.1 TM methods and method groups
-================================
-
-libitm supports several ways of synchronizing transactions with each
-other.  These TM methods (or TM algorithms) are implemented in the form
-of subclasses of 'abi_dispatch', which provide methods for transactional
-loads and stores as well as callbacks for rollback and commit.  All
-methods that are compatible with each other (i.e., that let concurrently
-running transactions still synchronize correctly even if different
-methods are used) belong to the same TM method group.  Pointers to TM
-methods can be obtained using the factory methods prefixed with
-'dispatch_' in 'libitm_i.h'.  There are two special methods,
-'dispatch_serial' and 'dispatch_serialirr', that are compatible with all
-methods because they run transactions completely in serial mode.
-
-4.1.1 TM method life cycle
---------------------------
-
-The state of TM methods does not change after construction, but they do
-alter the state of transactions that use this method.  However, because
-per-transaction data gets used by several methods, 'gtm_thread' is
-responsible for setting an initial state that is useful for all methods.
-After that, methods are responsible for resetting/clearing this state on
-each rollback or commit (of outermost transactions), so that the
-transaction executed next is not affected by the previous transaction.
-
-   There is also global state associated with each method group, which
-is initialized and shut down ('method_group::init()' and 'fini()') when
-switching between method groups (see 'retry.cc').
-
-4.1.2 Selecting the default method
-----------------------------------
-
-The default method that libitm uses for freshly started transactions
-(but not necessarily for restarted transactions) can be set via an
-environment variable ('ITM_DEFAULT_METHOD'), whose value should be equal
-to the name of one of the factory methods returning abi_dispatch
-subclasses but without the "dispatch_" prefix (e.g., "serialirr" instead
-of 'GTM::dispatch_serialirr()').
-
-   Note that this environment variable is only a hint for libitm and
-might not be supported in the future.
-
-4.2 Nesting: flat vs. closed
-============================
-
-We support two different kinds of nesting of transactions.  In the case
-of _flat nesting_, the nesting structure is flattened and all nested
-transactions are subsumed by the enclosing transaction.  In contrast,
-with _closed nesting_, nested transactions that have not yet committed
-can be rolled back separately from the enclosing transactions; when they
-commit, they are subsumed by the enclosing transaction, and their
-effects will be finally committed when the outermost transaction
-commits.  _Open nesting_ (where nested transactions can commit
-independently of the enclosing transactions) are not supported.
-
-   Flat nesting is the default nesting mode, but closed nesting is
-supported and used when transactions contain user-controlled aborts
-('__transaction_cancel' statements).  We assume that user-controlled
-aborts are rare in typical code and used mostly in exceptional
-situations.  Thus, it makes more sense to use flat nesting by default to
-avoid the performance overhead of the additional checkpoints required
-for closed nesting.  User-controlled aborts will correctly abort the
-innermost enclosing transaction, whereas the whole (i.e., outermost)
-transaction will be restarted otherwise (e.g., when a transaction
-encounters data conflicts during optimistic execution).
-
-4.3 Locking conventions
-=======================
-
-This section documents the locking scheme and rules for all uses of
-locking in libitm.  We have to support serial(-irrevocable) mode, which
-is implemented using a global lock as explained next (called the _serial
-lock_).  To simplify the overall design, we use the same lock as
-catch-all locking mechanism for other infrequent tasks such as
-(de)registering clone tables or threads.  Besides the serial lock, there
-are _per-method-group locks_ that are managed by specific method groups
-(i.e., groups of similar TM concurrency control algorithms), and
-lock-like constructs for quiescence-based operations such as ensuring
-privatization safety.
-
-   Thus, the actions that participate in the libitm-internal locking are
-either _active transactions_ that do not run in serial mode, _serial
-transactions_ (which (are about to) run in serial mode), and management
-tasks that do not execute within a transaction but have acquired the
-serial mode like a serial transaction would do (e.g., to be able to
-register threads with libitm).  Transactions become active as soon as
-they have successfully used the serial lock to announce this globally
-(*note Serial lock implementation: serial-lock-impl.).  Likewise,
-transactions become serial transactions as soon as they have acquired
-the exclusive rights provided by the serial lock (i.e., serial mode,
-which also means that there are no other concurrent active or serial
-transactions).  Note that active transactions can become serial
-transactions when they enter serial mode during the runtime of the
-transaction.
-
-4.3.1 State-to-lock mapping
----------------------------
-
-Application data is protected by the serial lock if there is a serial
-transaction and no concurrently running active transaction (i.e.,
-non-serial).  Otherwise, application data is protected by the currently
-selected method group, which might use per-method-group locks or other
-mechanisms.  Also note that application data that is about to be
-privatized might not be allowed to be accessed by nontransactional code
-until privatization safety has been ensured; the details of this are
-handled by the current method group.
-
-   libitm-internal state is either protected by the serial lock or
-accessed through custom concurrent code.  The latter applies to the
-public/shared part of a transaction object and most typical
-method-group-specific state.
-
-   The former category (protected by the serial lock) includes:
-   * The list of active threads that have used transactions.
-   * The tables that map functions to their transactional clones.
-   * The current selection of which method group to use.
-   * Some method-group-specific data, or invariants of this data.  For
-     example, resetting a method group to its initial state is handled
-     by switching to the same method group, so the serial lock protects
-     such resetting as well.
-   In general, such state is immutable whenever there exists an active
-(non-serial) transaction.  If there is no active transaction, a serial
-transaction (or a thread that is not currently executing a transaction
-but has acquired the serial lock) is allowed to modify this state (but
-must of course be careful to not surprise the current method group's
-implementation with such modifications).
-
-4.3.2 Lock acquisition order
-----------------------------
-
-To prevent deadlocks, locks acquisition must happen in a globally
-agreed-upon order.  Note that this applies to other forms of blocking
-too, but does not necessarily apply to lock acquisitions that do not
-block (e.g., trylock() calls that do not get retried forever).  Note
-that serial transactions are never return back to active transactions
-until the transaction has committed.  Likewise, active transactions stay
-active until they have committed.  Per-method-group locks are typically
-also not released before commit.
-
-   Lock acquisition / blocking rules:
-
-   * Transactions must become active or serial before they are allowed
-     to use method-group-specific locks or blocking (i.e., the serial
-     lock must be acquired before those other locks, either in serial or
-     nonserial mode).
-
-   * Any number of threads that do not currently run active transactions
-     can block while trying to get the serial lock in exclusive mode.
-     Note that active transactions must not block when trying to upgrade
-     to serial mode unless there is no other transaction that is trying
-     that (the latter is ensured by the serial lock implementation.
-
-   * Method groups must prevent deadlocks on their locks.  In
-     particular, they must also be prepared for another active
-     transaction that has acquired method-group-specific locks but is
-     blocked during an attempt to upgrade to being a serial transaction.
-     See below for details.
-
-   * Serial transactions can acquire method-group-specific locks because
-     there will be no other active nor serial transaction.
-
-   There is no single rule for per-method-group blocking because this
-depends on when a TM method might acquire locks.  If no active
-transaction can upgrade to being a serial transaction after it has
-acquired per-method-group locks (e.g., when those locks are only
-acquired during an attempt to commit), then the TM method does not need
-to consider a potential deadlock due to serial mode.
-
-   If there can be upgrades to serial mode after the acquisition of
-per-method-group locks, then TM methods need to avoid those deadlocks:
-   * When upgrading to a serial transaction, after acquiring exclusive
-     rights to the serial lock but before waiting for concurrent active
-     transactions to finish (*note Serial lock implementation:
-     serial-lock-impl. for details), we have to wake up all active
-     transactions waiting on the upgrader's per-method-group locks.
-   * Active transactions blocking on per-method-group locks need to
-     check the serial lock and abort if there is a pending serial
-     transaction.
-   * Lost wake-ups have to be prevented (e.g., by changing a bit in each
-     per-method-group lock before doing the wake-up, and only blocking
-     on this lock using a futex if this bit is not group).
-
-   *TODO*: Can reuse serial lock for gl-*?  And if we can, does it make
-sense to introduce further complexity in the serial lock?  For gl-*, we
-can really only avoid an abort if we do -wb and -vbv.
-
-4.3.3 Serial lock implementation
---------------------------------
-
-The serial lock implementation is optimized towards assuming that serial
-transactions are infrequent and not the common case.  However, the
-performance of entering serial mode can matter because when only few
-transactions are run concurrently or if there are few threads, then it
-can be efficient to run transactions serially.
-
-   The serial lock is similar to a multi-reader-single-writer lock in
-that there can be several active transactions but only one serial
-transaction.  However, we do want to avoid contention (in the lock
-implementation) between active transactions, so we split up the reader
-side of the lock into per-transaction flags that are true iff the
-transaction is active.  The exclusive writer side remains a shared
-single flag, which is acquired using a CAS, for example.  On the
-fast-path, the serial lock then works similar to Dekker's algorithm but
-with several reader flags that a serial transaction would have to check.
-A serial transaction thus requires a list of all threads with
-potentially active transactions; we can use the serial lock itself to
-protect this list (i.e., only threads that have acquired the serial lock
-can modify this list).
-
-   We want starvation-freedom for the serial lock to allow for using it
-to ensure progress for potentially starved transactions (*note Progress
-Guarantees: progress-guarantees. for details).  However, this is
-currently not enforced by the implementation of the serial lock.
-
-   Here is pseudo-code for the read/write fast paths of acquiring the
-serial lock (read-to-write upgrade is similar to write_lock:
-     // read_lock:
-     tx->shared_state |= active;
-     __sync_synchronize(); // or STLD membar, or C++0x seq-cst fence
-     while (!serial_lock.exclusive)
-       if (spinning_for_too_long) goto slowpath;
-
-     // write_lock:
-     if (CAS(&serial_lock.exclusive, 0, this) != 0)
-       goto slowpath; // writer-writer contention
-     // need a membar here, but CAS already has full membar semantics
-     bool need_blocking = false;
-     for (t: all txns)
-       {
-         for (;t->shared_state & active;)
-           if (spinning_for_too_long) { need_blocking = true; break; }
-       }
-     if (need_blocking) goto slowpath;
-
-   Releasing a lock in this spin-lock version then just consists of
-resetting 'tx->shared_state' to inactive or clearing
-'serial_lock.exclusive'.
-
-   However, we can't rely on a pure spinlock because we need to get the
-OS involved at some time (e.g., when there are more threads than CPUs to
-run on).  Therefore, the real implementation falls back to a blocking
-slow path, either based on pthread mutexes or Linux futexes.
-
-4.3.4 Reentrancy
-----------------
-
-libitm has to consider the following cases of reentrancy:
-
-   * Transaction calls unsafe code that starts a new transaction: The
-     outer transaction will become a serial transaction before executing
-     unsafe code.  Therefore, nesting within serial transactions must
-     work, even if the nested transaction is called from within
-     uninstrumented code.
-
-   * Transaction calls either a transactional wrapper or safe code,
-     which in turn starts a new transaction: It is not yet defined in
-     the specification whether this is allowed.  Thus, it is undefined
-     whether libitm supports this.
-
-   * Code that starts new transactions might be called from within any
-     part of libitm: This kind of reentrancy would likely be rather
-     complex and can probably be avoided.  Therefore, it is not
-     supported.
-
-4.3.5 Privatization safety
---------------------------
-
-Privatization safety is ensured by libitm using a quiescence-based
-approach.  Basically, a privatizing transaction waits until all
-concurrent active transactions will either have finished (are not active
-anymore) or operate on a sufficiently recent snapshot to not access the
-privatized data anymore.  This happens after the privatizing transaction
-has stopped being an active transaction, so waiting for quiescence does
-not contribute to deadlocks.
-
-   In method groups that need to ensure publication safety explicitly,
-active transactions maintain a flag or timestamp in the public/shared
-part of the transaction descriptor.  Before blocking, privatizers need
-to let the other transactions know that they should wake up the
-privatizer.
-
-   *TODO* Ho to implement the waiters?  Should those flags be
-per-transaction or at a central place?  We want to avoid one wake/wait
-call per active transactions, so we might want to use either a tree or
-combining to reduce the syscall overhead, or rather spin for a long
-amount of time instead of doing blocking.  Also, it would be good if
-only the last transaction that the privatizer waits for would do the
-wake-up.
-
-4.3.6 Progress guarantees
--------------------------
-
-Transactions that do not make progress when using the current TM method
-will eventually try to execute in serial mode.  Thus, the serial lock's
-progress guarantees determine the progress guarantees of the whole TM.
-Obviously, we at least need deadlock-freedom for the serial lock, but it
-would also be good to provide starvation-freedom (informally, all
-threads will finish executing a transaction eventually iff they get
-enough cycles).
-
-   However, the scheduling of transactions (e.g., thread scheduling by
-the OS) also affects the handling of progress guarantees by the TM.
-First, the TM can only guarantee deadlock-freedom if threads do not get
-stopped.  Likewise, low-priority threads can starve if they do not get
-scheduled when other high-priority threads get those cycles instead.
-
-   If all threads get scheduled eventually, correct lock implementations
-will provide deadlock-freedom, but might not provide starvation-freedom.
-We can either enforce the latter in the TM's lock implementation, or
-assume that the scheduling is sufficiently random to yield a
-probabilistic guarantee that no thread will starve (because eventually,
-a transaction will encounter a scheduling that will allow it to run).
-This can indeed work well in practice but is not necessarily guaranteed
-to work (e.g., simple spin locks can be pretty efficient).
-
-   Because enforcing stronger progress guarantees in the TM has a higher
-runtime overhead, we focus on deadlock-freedom right now and assume that
-the threads will get scheduled eventually by the OS (but don't consider
-threads with different priorities).  We should support
-starvation-freedom for serial transactions in the future.  Everything
-beyond that is highly related to proper contention management across all
-of the TM (including with TM method to choose), and is future work.
-
-   *TODO* Handling thread priorities: We want to avoid priority
-inversion but it's unclear how often that actually matters in practice.
-Workloads that have threads with different priorities will likely also
-require lower latency or higher throughput for high-priority threads.
-Therefore, it probably makes not that much sense (except for eventual
-progress guarantees) to use priority inheritance until the TM has
-priority-aware contention management.
-
-
-File: libitm.info,  Node: GNU Free Documentation License,  Next: Index,  Prev: Internals,  Up: Top
-
-GNU Free Documentation License
-******************************
-
-                     Version 1.3, 3 November 2008
-
-     Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
-     <http://fsf.org/>
-
-     Everyone is permitted to copy and distribute verbatim copies
-     of this license document, but changing it is not allowed.
-
-  0. PREAMBLE
-
-     The purpose of this License is to make a manual, textbook, or other
-     functional and useful document "free" in the sense of freedom: to
-     assure everyone the effective freedom to copy and redistribute it,
-     with or without modifying it, either commercially or
-     noncommercially.  Secondarily, this License preserves for the
-     author and publisher a way to get credit for their work, while not
-     being considered responsible for modifications made by others.
-
-     This License is a kind of "copyleft", which means that derivative
-     works of the document must themselves be free in the same sense.
-     It complements the GNU General Public License, which is a copyleft
-     license designed for free software.
-
-     We have designed this License in order to use it for manuals for
-     free software, because free software needs free documentation: a
-     free program should come with manuals providing the same freedoms
-     that the software does.  But this License is not limited to
-     software manuals; it can be used for any textual work, regardless
-     of subject matter or whether it is published as a printed book.  We
-     recommend this License principally for works whose purpose is
-     instruction or reference.
-
-  1. APPLICABILITY AND DEFINITIONS
-
-     This License applies to any manual or other work, in any medium,
-     that contains a notice placed by the copyright holder saying it can
-     be distributed under the terms of this License.  Such a notice
-     grants a world-wide, royalty-free license, unlimited in duration,
-     to use that work under the conditions stated herein.  The
-     "Document", below, refers to any such manual or work.  Any member
-     of the public is a licensee, and is addressed as "you".  You accept
-     the license if you copy, modify or distribute the work in a way
-     requiring permission under copyright law.
-
-     A "Modified Version" of the Document means any work containing the
-     Document or a portion of it, either copied verbatim, or with
-     modifications and/or translated into another language.
-
-     A "Secondary Section" is a named appendix or a front-matter section
-     of the Document that deals exclusively with the relationship of the
-     publishers or authors of the Document to the Document's overall
-     subject (or to related matters) and contains nothing that could
-     fall directly within that overall subject.  (Thus, if the Document
-     is in part a textbook of mathematics, a Secondary Section may not
-     explain any mathematics.)  The relationship could be a matter of
-     historical connection with the subject or with related matters, or
-     of legal, commercial, philosophical, ethical or political position
-     regarding them.
-
-     The "Invariant Sections" are certain Secondary Sections whose
-     titles are designated, as being those of Invariant Sections, in the
-     notice that says that the Document is released under this License.
-     If a section does not fit the above definition of Secondary then it
-     is not allowed to be designated as Invariant.  The Document may
-     contain zero Invariant Sections.  If the Document does not identify
-     any Invariant Sections then there are none.
-
-     The "Cover Texts" are certain short passages of text that are
-     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
-     that says that the Document is released under this License.  A
-     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
-     be at most 25 words.
-
-     A "Transparent" copy of the Document means a machine-readable copy,
-     represented in a format whose specification is available to the
-     general public, that is suitable for revising the document
-     straightforwardly with generic text editors or (for images composed
-     of pixels) generic paint programs or (for drawings) some widely
-     available drawing editor, and that is suitable for input to text
-     formatters or for automatic translation to a variety of formats
-     suitable for input to text formatters.  A copy made in an otherwise
-     Transparent file format whose markup, or absence of markup, has
-     been arranged to thwart or discourage subsequent modification by
-     readers is not Transparent.  An image format is not Transparent if
-     used for any substantial amount of text.  A copy that is not
-     "Transparent" is called "Opaque".
-
-     Examples of suitable formats for Transparent copies include plain
-     ASCII without markup, Texinfo input format, LaTeX input format,
-     SGML or XML using a publicly available DTD, and standard-conforming
-     simple HTML, PostScript or PDF designed for human modification.
-     Examples of transparent image formats include PNG, XCF and JPG.
-     Opaque formats include proprietary formats that can be read and
-     edited only by proprietary word processors, SGML or XML for which
-     the DTD and/or processing tools are not generally available, and
-     the machine-generated HTML, PostScript or PDF produced by some word
-     processors for output purposes only.
-
-     The "Title Page" means, for a printed book, the title page itself,
-     plus such following pages as are needed to hold, legibly, the
-     material this License requires to appear in the title page.  For
-     works in formats which do not have any title page as such, "Title
-     Page" means the text near the most prominent appearance of the
-     work's title, preceding the beginning of the body of the text.
-
-     The "publisher" means any person or entity that distributes copies
-     of the Document to the public.
-
-     A section "Entitled XYZ" means a named subunit of the Document
-     whose title either is precisely XYZ or contains XYZ in parentheses
-     following text that translates XYZ in another language.  (Here XYZ
-     stands for a specific section name mentioned below, such as
-     "Acknowledgements", "Dedications", "Endorsements", or "History".)
-     To "Preserve the Title" of such a section when you modify the
-     Document means that it remains a section "Entitled XYZ" according
-     to this definition.
-
-     The Document may include Warranty Disclaimers next to the notice
-     which states that this License applies to the Document.  These
-     Warranty Disclaimers are considered to be included by reference in
-     this License, but only as regards disclaiming warranties: any other
-     implication that these Warranty Disclaimers may have is void and
-     has no effect on the meaning of this License.
-
-  2. VERBATIM COPYING
-
-     You may copy and distribute the Document in any medium, either
-     commercially or noncommercially, provided that this License, the
-     copyright notices, and the license notice saying this License
-     applies to the Document are reproduced in all copies, and that you
-     add no other conditions whatsoever to those of this License.  You
-     may not use technical measures to obstruct or control the reading
-     or further copying of the copies you make or distribute.  However,
-     you may accept compensation in exchange for copies.  If you
-     distribute a large enough number of copies you must also follow the
-     conditions in section 3.
-
-     You may also lend copies, under the same conditions stated above,
-     and you may publicly display copies.
-
-  3. COPYING IN QUANTITY
-
-     If you publish printed copies (or copies in media that commonly
-     have printed covers) of the Document, numbering more than 100, and
-     the Document's license notice requires Cover Texts, you must
-     enclose the copies in covers that carry, clearly and legibly, all
-     these Cover Texts: Front-Cover Texts on the front cover, and
-     Back-Cover Texts on the back cover.  Both covers must also clearly
-     and legibly identify you as the publisher of these copies.  The
-     front cover must present the full title with all words of the title
-     equally prominent and visible.  You may add other material on the
-     covers in addition.  Copying with changes limited to the covers, as
-     long as they preserve the title of the Document and satisfy these
-     conditions, can be treated as verbatim copying in other respects.
-
-     If the required texts for either cover are too voluminous to fit
-     legibly, you should put the first ones listed (as many as fit
-     reasonably) on the actual cover, and continue the rest onto
-     adjacent pages.
-
-     If you publish or distribute Opaque copies of the Document
-     numbering more than 100, you must either include a machine-readable
-     Transparent copy along with each Opaque copy, or state in or with
-     each Opaque copy a computer-network location from which the general
-     network-using public has access to download using public-standard
-     network protocols a complete Transparent copy of the Document, free
-     of added material.  If you use the latter option, you must take
-     reasonably prudent steps, when you begin distribution of Opaque
-     copies in quantity, to ensure that this Transparent copy will
-     remain thus accessible at the stated location until at least one
-     year after the last time you distribute an Opaque copy (directly or
-     through your agents or retailers) of that edition to the public.
-
-     It is requested, but not required, that you contact the authors of
-     the Document well before redistributing any large number of copies,
-     to give them a chance to provide you with an updated version of the
-     Document.
-
-  4. MODIFICATIONS
-
-     You may copy and distribute a Modified Version of the Document
-     under the conditions of sections 2 and 3 above, provided that you
-     release the Modified Version under precisely this License, with the
-     Modified Version filling the role of the Document, thus licensing
-     distribution and modification of the Modified Version to whoever
-     possesses a copy of it.  In addition, you must do these things in
-     the Modified Version:
-
-       A. Use in the Title Page (and on the covers, if any) a title
-          distinct from that of the Document, and from those of previous
-          versions (which should, if there were any, be listed in the
-          History section of the Document).  You may use the same title
-          as a previous version if the original publisher of that
-          version gives permission.
-
-       B. List on the Title Page, as authors, one or more persons or
-          entities responsible for authorship of the modifications in
-          the Modified Version, together with at least five of the
-          principal authors of the Document (all of its principal
-          authors, if it has fewer than five), unless they release you
-          from this requirement.
-
-       C. State on the Title page the name of the publisher of the
-          Modified Version, as the publisher.
-
-       D. Preserve all the copyright notices of the Document.
-
-       E. Add an appropriate copyright notice for your modifications
-          adjacent to the other copyright notices.
-
-       F. Include, immediately after the copyright notices, a license
-          notice giving the public permission to use the Modified
-          Version under the terms of this License, in the form shown in
-          the Addendum below.
-
-       G. Preserve in that license notice the full lists of Invariant
-          Sections and required Cover Texts given in the Document's
-          license notice.
-
-       H. Include an unaltered copy of this License.
-
-       I. Preserve the section Entitled "History", Preserve its Title,
-          and add to it an item stating at least the title, year, new
-          authors, and publisher of the Modified Version as given on the
-          Title Page.  If there is no section Entitled "History" in the
-          Document, create one stating the title, year, authors, and
-          publisher of the Document as given on its Title Page, then add
-          an item describing the Modified Version as stated in the
-          previous sentence.
-
-       J. Preserve the network location, if any, given in the Document
-          for public access to a Transparent copy of the Document, and
-          likewise the network locations given in the Document for
-          previous versions it was based on.  These may be placed in the
-          "History" section.  You may omit a network location for a work
-          that was published at least four years before the Document
-          itself, or if the original publisher of the version it refers
-          to gives permission.
-
-       K. For any section Entitled "Acknowledgements" or "Dedications",
-          Preserve the Title of the section, and preserve in the section
-          all the substance and tone of each of the contributor
-          acknowledgements and/or dedications given therein.
-
-       L. Preserve all the Invariant Sections of the Document, unaltered
-          in their text and in their titles.  Section numbers or the
-          equivalent are not considered part of the section titles.
-
-       M. Delete any section Entitled "Endorsements".  Such a section
-          may not be included in the Modified Version.
-
-       N. Do not retitle any existing section to be Entitled
-          "Endorsements" or to conflict in title with any Invariant
-          Section.
-
-       O. Preserve any Warranty Disclaimers.
-
-     If the Modified Version includes new front-matter sections or
-     appendices that qualify as Secondary Sections and contain no
-     material copied from the Document, you may at your option designate
-     some or all of these sections as invariant.  To do this, add their
-     titles to the list of Invariant Sections in the Modified Version's
-     license notice.  These titles must be distinct from any other
-     section titles.
-
-     You may add a section Entitled "Endorsements", provided it contains
-     nothing but endorsements of your Modified Version by various
-     parties--for example, statements of peer review or that the text
-     has been approved by an organization as the authoritative
-     definition of a standard.
-
-     You may add a passage of up to five words as a Front-Cover Text,
-     and a passage of up to 25 words as a Back-Cover Text, to the end of
-     the list of Cover Texts in the Modified Version.  Only one passage
-     of Front-Cover Text and one of Back-Cover Text may be added by (or
-     through arrangements made by) any one entity.  If the Document
-     already includes a cover text for the same cover, previously added
-     by you or by arrangement made by the same entity you are acting on
-     behalf of, you may not add another; but you may replace the old
-     one, on explicit permission from the previous publisher that added
-     the old one.
-
-     The author(s) and publisher(s) of the Document do not by this
-     License give permission to use their names for publicity for or to
-     assert or imply endorsement of any Modified Version.
-
-  5. COMBINING DOCUMENTS
-
-     You may combine the Document with other documents released under
-     this License, under the terms defined in section 4 above for
-     modified versions, provided that you include in the combination all
-     of the Invariant Sections of all of the original documents,
-     unmodified, and list them all as Invariant Sections of your
-     combined work in its license notice, and that you preserve all
-     their Warranty Disclaimers.
-
-     The combined work need only contain one copy of this License, and
-     multiple identical Invariant Sections may be replaced with a single
-     copy.  If there are multiple Invariant Sections with the same name
-     but different contents, make the title of each such section unique
-     by adding at the end of it, in parentheses, the name of the
-     original author or publisher of that section if known, or else a
-     unique number.  Make the same adjustment to the section titles in
-     the list of Invariant Sections in the license notice of the
-     combined work.
-
-     In the combination, you must combine any sections Entitled
-     "History" in the various original documents, forming one section
-     Entitled "History"; likewise combine any sections Entitled
-     "Acknowledgements", and any sections Entitled "Dedications".  You
-     must delete all sections Entitled "Endorsements."
-
-  6. COLLECTIONS OF DOCUMENTS
-
-     You may make a collection consisting of the Document and other
-     documents released under this License, and replace the individual
-     copies of this License in the various documents with a single copy
-     that is included in the collection, provided that you follow the
-     rules of this License for verbatim copying of each of the documents
-     in all other respects.
-
-     You may extract a single document from such a collection, and
-     distribute it individually under this License, provided you insert
-     a copy of this License into the extracted document, and follow this
-     License in all other respects regarding verbatim copying of that
-     document.
-
-  7. AGGREGATION WITH INDEPENDENT WORKS
-
-     A compilation of the Document or its derivatives with other
-     separate and independent documents or works, in or on a volume of a
-     storage or distribution medium, is called an "aggregate" if the
-     copyright resulting from the compilation is not used to limit the
-     legal rights of the compilation's users beyond what the individual
-     works permit.  When the Document is included in an aggregate, this
-     License does not apply to the other works in the aggregate which
-     are not themselves derivative works of the Document.
-
-     If the Cover Text requirement of section 3 is applicable to these
-     copies of the Document, then if the Document is less than one half
-     of the entire aggregate, the Document's Cover Texts may be placed
-     on covers that bracket the Document within the aggregate, or the
-     electronic equivalent of covers if the Document is in electronic
-     form.  Otherwise they must appear on printed covers that bracket
-     the whole aggregate.
-
-  8. TRANSLATION
-
-     Translation is considered a kind of modification, so you may
-     distribute translations of the Document under the terms of section
-     4.  Replacing Invariant Sections with translations requires special
-     permission from their copyright holders, but you may include
-     translations of some or all Invariant Sections in addition to the
-     original versions of these Invariant Sections.  You may include a
-     translation of this License, and all the license notices in the
-     Document, and any Warranty Disclaimers, provided that you also
-     include the original English version of this License and the
-     original versions of those notices and disclaimers.  In case of a
-     disagreement between the translation and the original version of
-     this License or a notice or disclaimer, the original version will
-     prevail.
-
-     If a section in the Document is Entitled "Acknowledgements",
-     "Dedications", or "History", the requirement (section 4) to
-     Preserve its Title (section 1) will typically require changing the
-     actual title.
-
-  9. TERMINATION
-
-     You may not copy, modify, sublicense, or distribute the Document
-     except as expressly provided under this License.  Any attempt
-     otherwise to copy, modify, sublicense, or distribute it is void,
-     and will automatically terminate your rights under this License.
-
-     However, if you cease all violation of this License, then your
-     license from a particular copyright holder is reinstated (a)
-     provisionally, unless and until the copyright holder explicitly and
-     finally terminates your license, and (b) permanently, if the
-     copyright holder fails to notify you of the violation by some
-     reasonable means prior to 60 days after the cessation.
-
-     Moreover, your license from a particular copyright holder is
-     reinstated permanently if the copyright holder notifies you of the
-     violation by some reasonable means, this is the first time you have
-     received notice of violation of this License (for any work) from
-     that copyright holder, and you cure the violation prior to 30 days
-     after your receipt of the notice.
-
-     Termination of your rights under this section does not terminate
-     the licenses of parties who have received copies or rights from you
-     under this License.  If your rights have been terminated and not
-     permanently reinstated, receipt of a copy of some or all of the
-     same material does not give you any rights to use it.
-
-  10. FUTURE REVISIONS OF THIS LICENSE
-
-     The Free Software Foundation may publish new, revised versions of
-     the GNU Free Documentation License from time to time.  Such new
-     versions will be similar in spirit to the present version, but may
-     differ in detail to address new problems or concerns.  See
-     <http://www.gnu.org/copyleft/>.
-
-     Each version of the License is given a distinguishing version
-     number.  If the Document specifies that a particular numbered
-     version of this License "or any later version" applies to it, you
-     have the option of following the terms and conditions either of
-     that specified version or of any later version that has been
-     published (not as a draft) by the Free Software Foundation.  If the
-     Document does not specify a version number of this License, you may
-     choose any version ever published (not as a draft) by the Free
-     Software Foundation.  If the Document specifies that a proxy can
-     decide which future versions of this License can be used, that
-     proxy's public statement of acceptance of a version permanently
-     authorizes you to choose that version for the Document.
-
-  11. RELICENSING
-
-     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
-     World Wide Web server that publishes copyrightable works and also
-     provides prominent facilities for anybody to edit those works.  A
-     public wiki that anybody can edit is an example of such a server.
-     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
-     site means any set of copyrightable works thus published on the MMC
-     site.
-
-     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
-     license published by Creative Commons Corporation, a not-for-profit
-     corporation with a principal place of business in San Francisco,
-     California, as well as future copyleft versions of that license
-     published by that same organization.
-
-     "Incorporate" means to publish or republish a Document, in whole or
-     in part, as part of another Document.
-
-     An MMC is "eligible for relicensing" if it is licensed under this
-     License, and if all works that were first published under this
-     License somewhere other than this MMC, and subsequently
-     incorporated in whole or in part into the MMC, (1) had no cover
-     texts or invariant sections, and (2) were thus incorporated prior
-     to November 1, 2008.
-
-     The operator of an MMC Site may republish an MMC contained in the
-     site under CC-BY-SA on the same site at any time before August 1,
-     2009, provided the MMC is eligible for relicensing.
-
-ADDENDUM: How to use this License for your documents
-====================================================
-
-To use this License in a document you have written, include a copy of
-the License in the document and put the following copyright and license
-notices just after the title page:
-
-       Copyright (C)  YEAR  YOUR NAME.
-       Permission is granted to copy, distribute and/or modify this document
-       under the terms of the GNU Free Documentation License, Version 1.3
-       or any later version published by the Free Software Foundation;
-       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-       Texts.  A copy of the license is included in the section entitled ``GNU
-       Free Documentation License''.
-
-   If you have Invariant Sections, Front-Cover Texts and Back-Cover
-Texts, replace the "with...Texts."  line with this:
-
-         with the Invariant Sections being LIST THEIR TITLES, with
-         the Front-Cover Texts being LIST, and with the Back-Cover Texts
-         being LIST.
-
-   If you have Invariant Sections without Cover Texts, or some other
-combination of the three, merge those two alternatives to suit the
-situation.
-
-   If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of free
-software license, such as the GNU General Public License, to permit
-their use in free software.
-
-
-File: libitm.info,  Node: Index,  Prev: GNU Free Documentation License,  Up: Top
-
-Index
-*****
-
-[index]
-* Menu:
-
-* FDL, GNU Free Documentation License:   GNU Free Documentation License.
-                                                                (line 6)
-* Introduction:                          Top.                   (line 6)
-
-
-
-Tag Table:
-Node: Top1141
-Node: Enabling libitm2045
-Node: C/C++ Language Constructs for TM2440
-Node: The libitm ABI3923
-Ref: txn-code-properties7721
-Node: Internals18026
-Ref: serial-lock-impl28064
-Ref: progress-guarantees32825
-Node: GNU Free Documentation License35103
-Node: Index60224
-
-End Tag Table

libquadmath/libquadmath.info

@@ -1 @@
-This is libquadmath.info, produced by makeinfo version 5.1 from
-libquadmath.texi.
-
-Copyright (C) 2010-2013 Free Software Foundation, Inc.
-
-     Permission is granted to copy, distribute and/or modify this
-     document under the terms of the GNU Free Documentation License,
-     Version 1.2 or any later version published by the Free Software
-     Foundation; with no Invariant Sections, with the Front-Cover Texts
-     being "A GNU Manual," and with the Back-Cover Texts as in (a)
-     below.  A copy of the license is included in the section entitled
-     "GNU Free Documentation License."
-
-     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
-     modify this GNU manual.
-INFO-DIR-SECTION GNU Libraries
-START-INFO-DIR-ENTRY
-* libquadmath: (libquadmath).                  GCC Quad-Precision Math Library
-END-INFO-DIR-ENTRY
-
-   This manual documents the GCC Quad-Precision Math Library API.
-
-   Published by the Free Software Foundation 51 Franklin Street, Fifth
-Floor Boston, MA 02110-1301 USA
-
-   Copyright (C) 2010-2013 Free Software Foundation, Inc.
-
-     Permission is granted to copy, distribute and/or modify this
-     document under the terms of the GNU Free Documentation License,
-     Version 1.2 or any later version published by the Free Software
-     Foundation; with no Invariant Sections, with the Front-Cover Texts
-     being "A GNU Manual," and with the Back-Cover Texts as in (a)
-     below.  A copy of the license is included in the section entitled
-     "GNU Free Documentation License."
-
-     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
-     modify this GNU manual.
-
-
-File: libquadmath.info,  Node: Top,  Next: Typedef and constants,  Up: (dir)
-
-Introduction
-************
-
-This manual documents the usage of libquadmath, the GCC Quad-Precision
-Math Library Application Programming Interface (API).
-
-* Menu:
-
-* Typedef and constants::      Defined data types and constants
-* Math Library Routines::      The Libquadmath math runtime application
-                               programming interface.
-* I/O Library Routines::       The Libquadmath I/O runtime application
-                               programming interface.
-* GNU Free Documentation License::
-                               How you can copy and share this manual.
-* Reporting Bugs::             How to report bugs in GCC Libquadmath.
-
-
-File: libquadmath.info,  Node: Typedef and constants,  Next: Math Library Routines,  Prev: Top,  Up: Top
-
-1 Typedef and constants
-***********************
-
-The following data type has been defined via 'typedef'.
-
-'__complex128': '__float128'-based complex number
-
-   The following macros are defined, which give the numeric limits of
-the '__float128' data type.
-
-'FLT128_MAX': largest finite number
-'FLT128_MIN': smallest positive number with full precision
-'FLT128_EPSILON': difference between 1 and the next larger
-     representable number
-'FLT128_DENORM_MIN': smallest positive denormalized number
-'FLT128_MANT_DIG': number of digits in the mantissa (bit precision)
-'FLT128_MIN_EXP': maximal negative exponent
-'FLT128_MAX_EXP': maximal positive exponent
-'FLT128_DIG': number of decimal digits in the mantissa
-'FLT128_MIN_10_EXP': maximal negative decimal exponent
-'FLT128_MAX_10_EXP': maximal positive decimal exponent
-
-   The following mathematical constants of type '__float128' are
-defined.
-
-'M_Eq': the constant e (Euler's number)
-'M_LOG2Eq': binary logarithm of 2
-'M_LOG10Eq': common, decimal logarithm of 2
-'M_LN2q': natural logarithm of 2
-'M_LN10q': natural logarithm of 10
-'M_PIq': pi
-'M_PI_2q': pi divided by two
-'M_PI_4q': pi divided by four
-'M_1_PIq': one over pi
-'M_2_PIq': one over two pi
-'M_2_SQRTPIq': two over square root of pi
-'M_SQRT2q': square root of 2
-'M_SQRT1_2q': one over square root of 2
-
-
-File: libquadmath.info,  Node: Math Library Routines,  Next: I/O Library Routines,  Prev: Typedef and constants,  Up: Top
-
-2 Math Library Routines
-***********************
-
-The following mathematical functions are available:
-
-'acosq': arc cosine function
-'acoshq': inverse hyperbolic cosine function
-'asinq': arc sine function
-'asinhq': inverse hyperbolic sine function
-'atanq': arc tangent function
-'atanhq': inverse hyperbolic tangent function
-'atan2q': arc tangent function
-'cbrtq': cube root function
-'ceilq': ceiling value function
-'copysignq': copy sign of a number
-'coshq': hyperbolic cosine function
-'cosq': cosine function
-'erfq': error function
-'erfcq': complementary error function
-'expq': exponential function
-'expm1q': exponential minus 1 function
-'fabsq': absolute value function
-'fdimq': positive difference function
-'finiteq': check finiteness of value
-'floorq': floor value function
-'fmaq': fused multiply and add
-'fmaxq': determine maximum of two values
-'fminq': determine minimum of two values
-'fmodq': remainder value function
-'frexpq': extract mantissa and exponent
-'hypotq': Eucledian distance function
-'ilogbq': get exponent of the value
-'isinfq': check for infinity
-'isnanq': check for not a number
-'j0q': Bessel function of the first kind, first order
-'j1q': Bessel function of the first kind, second order
-'jnq': Bessel function of the first kind, N-th order
-'ldexpq': load exponent of the value
-'lgammaq': logarithmic gamma function
-'llrintq': round to nearest integer value
-'llroundq': round to nearest integer value away from zero
-'logq': natural logarithm function
-'log10q': base 10 logarithm function
-'log1pq': compute natural logarithm of the value plus one
-'log2q': base 2 logarithm function
-'lrintq': round to nearest integer value
-'lroundq': round to nearest integer value away from zero
-'modfq': decompose the floating-point number
-'nanq': return quiet NaN
-'nearbyintq': round to nearest integer
-'nextafterq': next representable floating-point number
-'powq': power function
-'remainderq': remainder function
-'remquoq': remainder and part of quotient
-'rintq': round-to-nearest integral value
-'roundq': round-to-nearest integral value, return '__float128'
-'scalblnq': compute exponent using 'FLT_RADIX'
-'scalbnq': compute exponent using 'FLT_RADIX'
-'signbitq': return sign bit
-'sincosq': calculate sine and cosine simulataneously
-'sinhq': hyperbolic sine function
-'sinq': sine function
-'sqrtq': square root function
-'tanq': tangent function
-'tanhq': hyperbolic tangent function
-'tgammaq': true gamma function
-'truncq': round to integer, towards zero
-'y0q': Bessel function of the second kind, first order
-'y1q': Bessel function of the second kind, second order
-'ynq': Bessel function of the second kind, N-th order
-'cabsq' complex absolute value function
-'cargq': calculate the argument
-'cimagq' imaginary part of complex number
-'crealq': real part of complex number
-'cacoshq': complex arc hyperbolic cosine function
-'cacosq': complex arc cosine function
-'casinhq': complex arc hyperbolic sine function
-'casinq': complex arc sine function
-'catanhq': complex arc hyperbolic tangent function
-'catanq': complex arc tangent function
-'ccosq' complex cosine function:
-'ccoshq': complex hyperbolic cosine function
-'cexpq': complex exponential function
-'cexpiq': computes the exponential function of "i" times a
-     real value
-'clogq': complex natural logarithm
-'clog10q': complex base 10 logarithm
-'conjq': complex conjugate function
-'cpowq': complex power function
-'cprojq': project into Riemann Sphere
-'csinq': complex sine function
-'csinhq': complex hyperbolic sine function
-'csqrtq': complex square root
-'ctanq': complex tangent function
-'ctanhq': complex hyperbolic tangent function
-
-
-File: libquadmath.info,  Node: I/O Library Routines,  Next: GNU Free Documentation License,  Prev: Math Library Routines,  Up: Top
-
-3 I/O Library Routines
-**********************
-
-* Menu:
-
-* 'strtoflt128':          strtoflt128,          Convert from string
-* 'quadmath_snprintf':    quadmath_snprintf,    Convert to string
-
-
-File: libquadmath.info,  Node: strtoflt128,  Next: quadmath_snprintf,  Up: I/O Library Routines
-
-3.1 'strtoflt128' -- Convert from string
-========================================
-
-The function 'strtoflt128' converts a string into a '__float128' number.
-
-Syntax
-     '__float128 strtoflt128 (const char *s, char **sp)'
-
-_Arguments_:
-     S           input string
-     SP          the address of the next character in the string
-
-     The argument SP contains, if not 'NULL', the address of the next
-     character following the parts of the string, which have been read.
-
-Example
-          #include <quadmath.h>
-
-          int main ()
-          {
-            __float128 r;
-
-            r = strtoflt128 ("1.2345678", NULL);
-
-            return 0;
-          }
-
-
-File: libquadmath.info,  Node: quadmath_snprintf,  Prev: strtoflt128,  Up: I/O Library Routines
-
-3.2 'quadmath_snprintf' -- Convert to string
-============================================
-
-The function 'quadmath_snprintf' converts a '__float128' floating-point
-number into a string.  It is a specialized alternative to 'snprintf',
-where the format string is restricted to a single conversion specifier
-with 'Q' modifier and conversion specifier 'e', 'E', 'f', 'F', 'g', 'G',
-'a' or 'A', with no extra characters before or after the conversion
-specifier.  The '%m$' or '*m$' style must not be used in the format.
-
-Syntax
-     'int quadmath_snprintf (char *s, size_t size, const char *format,
-     ...)'
-
-_Arguments_:
-     S           output string
-     SIZE        byte size of the string, including tailing NUL
-     FORMAT      conversion specifier string
-
-Note
-     On some targets when supported by the C library hooks are installed
-     for 'printf' family of functions, so that 'printf ("%Qe", 1.2Q);'
-     etc. works too.
-
-Example
-          #include <quadmath.h>
-          #include <stdlib.h>
-          #include <stdio.h>
-
-          int main ()
-          {
-            __float128 r;
-            int prec = 20;
-            int width = 46;
-            char buf[128];
-
-            r = 2.0q;
-            r = sqrtq (r);
-            int n = quadmath_snprintf (buf, sizeof buf, "%+-#*.20Qe", width, r);
-            if ((size_t) n < sizeof buf)
-              printf ("%s\n", buf);
-              /* Prints: +1.41421356237309504880e+00 */
-            quadmath_snprintf (buf, sizeof buf, "%Qa", r);
-            if ((size_t) n < sizeof buf)
-              printf ("%s\n", buf);
-              /* Prints: 0x1.6a09e667f3bcc908b2fb1366ea96p+0 */
-            n = quadmath_snprintf (NULL, 0, "%+-#46.*Qe", prec, r);
-            if (n > -1)
-              {
-                char *str = malloc (n + 1);
-                if (str)
-                  {
-                    quadmath_snprintf (str, n + 1, "%+-#46.*Qe", prec, r);
-                    printf ("%s\n", str);
-                    /* Prints: +1.41421356237309504880e+00 */
-                  }
-                free (str);
-              }
-            return 0;
-          }
-
-
-File: libquadmath.info,  Node: GNU Free Documentation License,  Next: Reporting Bugs,  Prev: I/O Library Routines,  Up: Top
-
-GNU Free Documentation License
-******************************
-
-                     Version 1.3, 3 November 2008
-
-     Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
-     <http://fsf.org/>
-
-     Everyone is permitted to copy and distribute verbatim copies
-     of this license document, but changing it is not allowed.
-
-  0. PREAMBLE
-
-     The purpose of this License is to make a manual, textbook, or other
-     functional and useful document "free" in the sense of freedom: to
-     assure everyone the effective freedom to copy and redistribute it,
-     with or without modifying it, either commercially or
-     noncommercially.  Secondarily, this License preserves for the
-     author and publisher a way to get credit for their work, while not
-     being considered responsible for modifications made by others.
-
-     This License is a kind of "copyleft", which means that derivative
-     works of the document must themselves be free in the same sense.
-     It complements the GNU General Public License, which is a copyleft
-     license designed for free software.
-
-     We have designed this License in order to use it for manuals for
-     free software, because free software needs free documentation: a
-     free program should come with manuals providing the same freedoms
-     that the software does.  But this License is not limited to
-     software manuals; it can be used for any textual work, regardless
-     of subject matter or whether it is published as a printed book.  We
-     recommend this License principally for works whose purpose is
-     instruction or reference.
-
-  1. APPLICABILITY AND DEFINITIONS
-
-     This License applies to any manual or other work, in any medium,
-     that contains a notice placed by the copyright holder saying it can
-     be distributed under the terms of this License.  Such a notice
-     grants a world-wide, royalty-free license, unlimited in duration,
-     to use that work under the conditions stated herein.  The
-     "Document", below, refers to any such manual or work.  Any member
-     of the public is a licensee, and is addressed as "you".  You accept
-     the license if you copy, modify or distribute the work in a way
-     requiring permission under copyright law.
-
-     A "Modified Version" of the Document means any work containing the
-     Document or a portion of it, either copied verbatim, or with
-     modifications and/or translated into another language.
-
-     A "Secondary Section" is a named appendix or a front-matter section
-     of the Document that deals exclusively with the relationship of the
-     publishers or authors of the Document to the Document's overall
-     subject (or to related matters) and contains nothing that could
-     fall directly within that overall subject.  (Thus, if the Document
-     is in part a textbook of mathematics, a Secondary Section may not
-     explain any mathematics.)  The relationship could be a matter of
-     historical connection with the subject or with related matters, or
-     of legal, commercial, philosophical, ethical or political position
-     regarding them.
-
-     The "Invariant Sections" are certain Secondary Sections whose
-     titles are designated, as being those of Invariant Sections, in the
-     notice that says that the Document is released under this License.
-     If a section does not fit the above definition of Secondary then it
-     is not allowed to be designated as Invariant.  The Document may
-     contain zero Invariant Sections.  If the Document does not identify
-     any Invariant Sections then there are none.
-
-     The "Cover Texts" are certain short passages of text that are
-     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
-     that says that the Document is released under this License.  A
-     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
-     be at most 25 words.
-
-     A "Transparent" copy of the Document means a machine-readable copy,
-     represented in a format whose specification is available to the
-     general public, that is suitable for revising the document
-     straightforwardly with generic text editors or (for images composed
-     of pixels) generic paint programs or (for drawings) some widely
-     available drawing editor, and that is suitable for input to text
-     formatters or for automatic translation to a variety of formats
-     suitable for input to text formatters.  A copy made in an otherwise
-     Transparent file format whose markup, or absence of markup, has
-     been arranged to thwart or discourage subsequent modification by
-     readers is not Transparent.  An image format is not Transparent if
-     used for any substantial amount of text.  A copy that is not
-     "Transparent" is called "Opaque".
-
-     Examples of suitable formats for Transparent copies include plain
-     ASCII without markup, Texinfo input format, LaTeX input format,
-     SGML or XML using a publicly available DTD, and standard-conforming
-     simple HTML, PostScript or PDF designed for human modification.
-     Examples of transparent image formats include PNG, XCF and JPG.
-     Opaque formats include proprietary formats that can be read and
-     edited only by proprietary word processors, SGML or XML for which
-     the DTD and/or processing tools are not generally available, and
-     the machine-generated HTML, PostScript or PDF produced by some word
-     processors for output purposes only.
-
-     The "Title Page" means, for a printed book, the title page itself,
-     plus such following pages as are needed to hold, legibly, the
-     material this License requires to appear in the title page.  For
-     works in formats which do not have any title page as such, "Title
-     Page" means the text near the most prominent appearance of the
-     work's title, preceding the beginning of the body of the text.
-
-     The "publisher" means any person or entity that distributes copies
-     of the Document to the public.
-
-     A section "Entitled XYZ" means a named subunit of the Document
-     whose title either is precisely XYZ or contains XYZ in parentheses
-     following text that translates XYZ in another language.  (Here XYZ
-     stands for a specific section name mentioned below, such as
-     "Acknowledgements", "Dedications", "Endorsements", or "History".)
-     To "Preserve the Title" of such a section when you modify the
-     Document means that it remains a section "Entitled XYZ" according
-     to this definition.
-
-     The Document may include Warranty Disclaimers next to the notice
-     which states that this License applies to the Document.  These
-     Warranty Disclaimers are considered to be included by reference in
-     this License, but only as regards disclaiming warranties: any other
-     implication that these Warranty Disclaimers may have is void and
-     has no effect on the meaning of this License.
-
-  2. VERBATIM COPYING
-
-     You may copy and distribute the Document in any medium, either
-     commercially or noncommercially, provided that this License, the
-     copyright notices, and the license notice saying this License
-     applies to the Document are reproduced in all copies, and that you
-     add no other conditions whatsoever to those of this License.  You
-     may not use technical measures to obstruct or control the reading
-     or further copying of the copies you make or distribute.  However,
-     you may accept compensation in exchange for copies.  If you
-     distribute a large enough number of copies you must also follow the
-     conditions in section 3.
-
-     You may also lend copies, under the same conditions stated above,
-     and you may publicly display copies.
-
-  3. COPYING IN QUANTITY
-
-     If you publish printed copies (or copies in media that commonly
-     have printed covers) of the Document, numbering more than 100, and
-     the Document's license notice requires Cover Texts, you must
-     enclose the copies in covers that carry, clearly and legibly, all
-     these Cover Texts: Front-Cover Texts on the front cover, and
-     Back-Cover Texts on the back cover.  Both covers must also clearly
-     and legibly identify you as the publisher of these copies.  The
-     front cover must present the full title with all words of the title
-     equally prominent and visible.  You may add other material on the
-     covers in addition.  Copying with changes limited to the covers, as
-     long as they preserve the title of the Document and satisfy these
-     conditions, can be treated as verbatim copying in other respects.
-
-     If the required texts for either cover are too voluminous to fit
-     legibly, you should put the first ones listed (as many as fit
-     reasonably) on the actual cover, and continue the rest onto
-     adjacent pages.
-
-     If you publish or distribute Opaque copies of the Document
-     numbering more than 100, you must either include a machine-readable
-     Transparent copy along with each Opaque copy, or state in or with
-     each Opaque copy a computer-network location from which the general
-     network-using public has access to download using public-standard
-     network protocols a complete Transparent copy of the Document, free
-     of added material.  If you use the latter option, you must take
-     reasonably prudent steps, when you begin distribution of Opaque
-     copies in quantity, to ensure that this Transparent copy will
-     remain thus accessible at the stated location until at least one
-     year after the last time you distribute an Opaque copy (directly or
-     through your agents or retailers) of that edition to the public.
-
-     It is requested, but not required, that you contact the authors of
-     the Document well before redistributing any large number of copies,
-     to give them a chance to provide you with an updated version of the
-     Document.
-
-  4. MODIFICATIONS
-
-     You may copy and distribute a Modified Version of the Document
-     under the conditions of sections 2 and 3 above, provided that you
-     release the Modified Version under precisely this License, with the
-     Modified Version filling the role of the Document, thus licensing
-     distribution and modification of the Modified Version to whoever
-     possesses a copy of it.  In addition, you must do these things in
-     the Modified Version:
-
-       A. Use in the Title Page (and on the covers, if any) a title
-          distinct from that of the Document, and from those of previous
-          versions (which should, if there were any, be listed in the
-          History section of the Document).  You may use the same title
-          as a previous version if the original publisher of that
-          version gives permission.
-
-       B. List on the Title Page, as authors, one or more persons or
-          entities responsible for authorship of the modifications in
-          the Modified Version, together with at least five of the
-          principal authors of the Document (all of its principal
-          authors, if it has fewer than five), unless they release you
-          from this requirement.
-
-       C. State on the Title page the name of the publisher of the
-          Modified Version, as the publisher.
-
-       D. Preserve all the copyright notices of the Document.
-
-       E. Add an appropriate copyright notice for your modifications
-          adjacent to the other copyright notices.
-
-       F. Include, immediately after the copyright notices, a license
-          notice giving the public permission to use the Modified
-          Version under the terms of this License, in the form shown in
-          the Addendum below.
-
-       G. Preserve in that license notice the full lists of Invariant
-          Sections and required Cover Texts given in the Document's
-          license notice.
-
-       H. Include an unaltered copy of this License.
-
-       I. Preserve the section Entitled "History", Preserve its Title,
-          and add to it an item stating at least the title, year, new
-          authors, and publisher of the Modified Version as given on the
-          Title Page.  If there is no section Entitled "History" in the
-          Document, create one stating the title, year, authors, and
-          publisher of the Document as given on its Title Page, then add
-          an item describing the Modified Version as stated in the
-          previous sentence.
-
-       J. Preserve the network location, if any, given in the Document
-          for public access to a Transparent copy of the Document, and
-          likewise the network locations given in the Document for
-          previous versions it was based on.  These may be placed in the
-          "History" section.  You may omit a network location for a work
-          that was published at least four years before the Document
-          itself, or if the original publisher of the version it refers
-          to gives permission.
-
-       K. For any section Entitled "Acknowledgements" or "Dedications",
-          Preserve the Title of the section, and preserve in the section
-          all the substance and tone of each of the contributor
-          acknowledgements and/or dedications given therein.
-
-       L. Preserve all the Invariant Sections of the Document, unaltered
-          in their text and in their titles.  Section numbers or the
-          equivalent are not considered part of the section titles.
-
-       M. Delete any section Entitled "Endorsements".  Such a section
-          may not be included in the Modified Version.
-
-       N. Do not retitle any existing section to be Entitled
-          "Endorsements" or to conflict in title with any Invariant
-          Section.
-
-       O. Preserve any Warranty Disclaimers.
-
-     If the Modified Version includes new front-matter sections or
-     appendices that qualify as Secondary Sections and contain no
-     material copied from the Document, you may at your option designate
-     some or all of these sections as invariant.  To do this, add their
-     titles to the list of Invariant Sections in the Modified Version's
-     license notice.  These titles must be distinct from any other
-     section titles.
-
-     You may add a section Entitled "Endorsements", provided it contains
-     nothing but endorsements of your Modified Version by various
-     parties--for example, statements of peer review or that the text
-     has been approved by an organization as the authoritative
-     definition of a standard.
-
-     You may add a passage of up to five words as a Front-Cover Text,
-     and a passage of up to 25 words as a Back-Cover Text, to the end of
-     the list of Cover Texts in the Modified Version.  Only one passage
-     of Front-Cover Text and one of Back-Cover Text may be added by (or
-     through arrangements made by) any one entity.  If the Document
-     already includes a cover text for the same cover, previously added
-     by you or by arrangement made by the same entity you are acting on
-     behalf of, you may not add another; but you may replace the old
-     one, on explicit permission from the previous publisher that added
-     the old one.
-
-     The author(s) and publisher(s) of the Document do not by this
-     License give permission to use their names for publicity for or to
-     assert or imply endorsement of any Modified Version.
-
-  5. COMBINING DOCUMENTS
-
-     You may combine the Document with other documents released under
-     this License, under the terms defined in section 4 above for
-     modified versions, provided that you include in the combination all
-     of the Invariant Sections of all of the original documents,
-     unmodified, and list them all as Invariant Sections of your
-     combined work in its license notice, and that you preserve all
-     their Warranty Disclaimers.
-
-     The combined work need only contain one copy of this License, and
-     multiple identical Invariant Sections may be replaced with a single
-     copy.  If there are multiple Invariant Sections with the same name
-     but different contents, make the title of each such section unique
-     by adding at the end of it, in parentheses, the name of the
-     original author or publisher of that section if known, or else a
-     unique number.  Make the same adjustment to the section titles in
-     the list of Invariant Sections in the license notice of the
-     combined work.
-
-     In the combination, you must combine any sections Entitled
-     "History" in the various original documents, forming one section
-     Entitled "History"; likewise combine any sections Entitled
-     "Acknowledgements", and any sections Entitled "Dedications".  You
-     must delete all sections Entitled "Endorsements."
-
-  6. COLLECTIONS OF DOCUMENTS
-
-     You may make a collection consisting of the Document and other
-     documents released under this License, and replace the individual
-     copies of this License in the various documents with a single copy
-     that is included in the collection, provided that you follow the
-     rules of this License for verbatim copying of each of the documents
-     in all other respects.
-
-     You may extract a single document from such a collection, and
-     distribute it individually under this License, provided you insert
-     a copy of this License into the extracted document, and follow this
-     License in all other respects regarding verbatim copying of that
-     document.
-
-  7. AGGREGATION WITH INDEPENDENT WORKS
-
-     A compilation of the Document or its derivatives with other
-     separate and independent documents or works, in or on a volume of a
-     storage or distribution medium, is called an "aggregate" if the
-     copyright resulting from the compilation is not used to limit the
-     legal rights of the compilation's users beyond what the individual
-     works permit.  When the Document is included in an aggregate, this
-     License does not apply to the other works in the aggregate which
-     are not themselves derivative works of the Document.
-
-     If the Cover Text requirement of section 3 is applicable to these
-     copies of the Document, then if the Document is less than one half
-     of the entire aggregate, the Document's Cover Texts may be placed
-     on covers that bracket the Document within the aggregate, or the
-     electronic equivalent of covers if the Document is in electronic
-     form.  Otherwise they must appear on printed covers that bracket
-     the whole aggregate.
-
-  8. TRANSLATION
-
-     Translation is considered a kind of modification, so you may
-     distribute translations of the Document under the terms of section
-     4.  Replacing Invariant Sections with translations requires special
-     permission from their copyright holders, but you may include
-     translations of some or all Invariant Sections in addition to the
-     original versions of these Invariant Sections.  You may include a
-     translation of this License, and all the license notices in the
-     Document, and any Warranty Disclaimers, provided that you also
-     include the original English version of this License and the
-     original versions of those notices and disclaimers.  In case of a
-     disagreement between the translation and the original version of
-     this License or a notice or disclaimer, the original version will
-     prevail.
-
-     If a section in the Document is Entitled "Acknowledgements",
-     "Dedications", or "History", the requirement (section 4) to
-     Preserve its Title (section 1) will typically require changing the
-     actual title.
-
-  9. TERMINATION
-
-     You may not copy, modify, sublicense, or distribute the Document
-     except as expressly provided under this License.  Any attempt
-     otherwise to copy, modify, sublicense, or distribute it is void,
-     and will automatically terminate your rights under this License.
-
-     However, if you cease all violation of this License, then your
-     license from a particular copyright holder is reinstated (a)
-     provisionally, unless and until the copyright holder explicitly and
-     finally terminates your license, and (b) permanently, if the
-     copyright holder fails to notify you of the violation by some
-     reasonable means prior to 60 days after the cessation.
-
-     Moreover, your license from a particular copyright holder is
-     reinstated permanently if the copyright holder notifies you of the
-     violation by some reasonable means, this is the first time you have
-     received notice of violation of this License (for any work) from
-     that copyright holder, and you cure the violation prior to 30 days
-     after your receipt of the notice.
-
-     Termination of your rights under this section does not terminate
-     the licenses of parties who have received copies or rights from you
-     under this License.  If your rights have been terminated and not
-     permanently reinstated, receipt of a copy of some or all of the
-     same material does not give you any rights to use it.
-
-  10. FUTURE REVISIONS OF THIS LICENSE
-
-     The Free Software Foundation may publish new, revised versions of
-     the GNU Free Documentation License from time to time.  Such new
-     versions will be similar in spirit to the present version, but may
-     differ in detail to address new problems or concerns.  See
-     <http://www.gnu.org/copyleft/>.
-
-     Each version of the License is given a distinguishing version
-     number.  If the Document specifies that a particular numbered
-     version of this License "or any later version" applies to it, you
-     have the option of following the terms and conditions either of
-     that specified version or of any later version that has been
-     published (not as a draft) by the Free Software Foundation.  If the
-     Document does not specify a version number of this License, you may
-     choose any version ever published (not as a draft) by the Free
-     Software Foundation.  If the Document specifies that a proxy can
-     decide which future versions of this License can be used, that
-     proxy's public statement of acceptance of a version permanently
-     authorizes you to choose that version for the Document.
-
-  11. RELICENSING
-
-     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
-     World Wide Web server that publishes copyrightable works and also
-     provides prominent facilities for anybody to edit those works.  A
-     public wiki that anybody can edit is an example of such a server.
-     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
-     site means any set of copyrightable works thus published on the MMC
-     site.
-
-     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
-     license published by Creative Commons Corporation, a not-for-profit
-     corporation with a principal place of business in San Francisco,
-     California, as well as future copyleft versions of that license
-     published by that same organization.
-
-     "Incorporate" means to publish or republish a Document, in whole or
-     in part, as part of another Document.
-
-     An MMC is "eligible for relicensing" if it is licensed under this
-     License, and if all works that were first published under this
-     License somewhere other than this MMC, and subsequently
-     incorporated in whole or in part into the MMC, (1) had no cover
-     texts or invariant sections, and (2) were thus incorporated prior
-     to November 1, 2008.
-
-     The operator of an MMC Site may republish an MMC contained in the
-     site under CC-BY-SA on the same site at any time before August 1,
-     2009, provided the MMC is eligible for relicensing.
-
-ADDENDUM: How to use this License for your documents
-====================================================
-
-To use this License in a document you have written, include a copy of
-the License in the document and put the following copyright and license
-notices just after the title page:
-
-       Copyright (C)  YEAR  YOUR NAME.
-       Permission is granted to copy, distribute and/or modify this document
-       under the terms of the GNU Free Documentation License, Version 1.3
-       or any later version published by the Free Software Foundation;
-       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-       Texts.  A copy of the license is included in the section entitled ``GNU
-       Free Documentation License''.
-
-   If you have Invariant Sections, Front-Cover Texts and Back-Cover
-Texts, replace the "with...Texts."  line with this:
-
-         with the Invariant Sections being LIST THEIR TITLES, with
-         the Front-Cover Texts being LIST, and with the Back-Cover Texts
-         being LIST.
-
-   If you have Invariant Sections without Cover Texts, or some other
-combination of the three, merge those two alternatives to suit the
-situation.
-
-   If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of free
-software license, such as the GNU General Public License, to permit
-their use in free software.
-
-
-File: libquadmath.info,  Node: Reporting Bugs,  Prev: GNU Free Documentation License,  Up: Top
-
-4 Reporting Bugs
-****************
-
-Bugs in the GCC Quad-Precision Math Library implementation should be
-reported via <http://gcc.gnu.org/bugs.html>.
-
-
-
-Tag Table:
-Node: Top1633
-Node: Typedef and constants2367
-Node: Math Library Routines3786
-Node: I/O Library Routines7503
-Node: strtoflt1287828
-Node: quadmath_snprintf8588
-Node: GNU Free Documentation License10798
-Node: Reporting Bugs35944
-
-End Tag Table

libstdc++-v3/include/bits/shared_ptr_base.h

@@ -391 +391 @@
     public:
       template<typename... _Args>
         _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
-        : _M_impl(__a), _M_storage()
+        : _M_impl(__a)
         {
           _M_impl._M_ptr = static_cast<_Tp*>(static_cast<void*>(&_M_storage));
           // _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -819 +819 @@
         : _M_ptr(__r.get()), _M_refcount()
         {
           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
-          auto __tmp = std::__addressof(*__r.get());
+          auto __tmp = __r.get();
           _M_refcount = __shared_count<_Lp>(std::move(__r));
           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
         }

libstdc++-v3/include/bits/stl_algo.h

@@ -2279 +2279 @@
                                 _RandomAccessIterator __last)
     {
       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
-      std::__move_median_to_first(__first, __first + 1, __mid, (__last - 2));
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1);
       return std::__unguarded_partition(__first + 1, __last, *__first);
     }
 
@@ -2291 +2291 @@
                                 _RandomAccessIterator __last, _Compare __comp)
     {
       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
-      std::__move_median_to_first(__first, __first + 1, __mid, (__last - 2),
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
                                   __comp);
       return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
     }

libstdc++-v3/include/c_global/cstdio

@@ -69 +69 @@
 #undef ftell
 #undef fwrite
 #undef getc
+#undef getchar
 #undef gets
 #undef perror
 #undef printf

libstdc++-v3/include/debug/functions.h

@@ -345 +345 @@
       return __check_sorted_set_aux(__first, __last, __pred, _SameType());
    }
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 270. Binary search requirements overly strict
+  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp>
     inline bool
-  __check_partitioned_lower_aux(_ForwardIterator __first,
-                                _ForwardIterator __last, const _Tp& __value,
-                                std::forward_iterator_tag)
+    __check_partitioned_lower(_ForwardIterator __first,
+                              _ForwardIterator __last, const _Tp& __value)
     {
       while (__first != __last && *__first < __value)
         ++__first;
@@ -362 +364 @@
       return __first == __last;
     }
 
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence, typename _Tp>
-    inline bool
-    __check_partitioned_lower_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_lower_aux(__first.base(), __last.base(),
-                                           __value, __tag);
-    }
-
-  // _GLIBCXX_RESOLVE_LIB_DEFECTS
-  // 270. Binary search requirements overly strict
-  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp>
     inline bool
-    __check_partitioned_lower(_ForwardIterator __first,
+    __check_partitioned_upper(_ForwardIterator __first,
                               _ForwardIterator __last, const _Tp& __value)
     {
-      return __check_partitioned_lower_aux(__first, __last, __value,
-                                           std::__iterator_category(__first));
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline bool
-    __check_partitioned_upper_aux(_ForwardIterator __first,
-                                  _ForwardIterator __last, const _Tp& __value,
-                                  std::forward_iterator_tag)
-    {
       while (__first != __last && !(__value < *__first))
         ++__first;
       if (__first != __last)
@@ -405 +380 @@
       return __first == __last;
     }
 
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence, typename _Tp>
-    inline bool
-    __check_partitioned_upper_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_upper_aux(__first.base(), __last.base(),
-                                           __value, __tag);
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline bool
-    __check_partitioned_upper(_ForwardIterator __first,
-                              _ForwardIterator __last, const _Tp& __value)
-    {
-      return __check_partitioned_upper_aux(__first, __last, __value,
-                                           std::__iterator_category(__first));
-    }
-
+  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp, typename _Pred>
     inline bool
-    __check_partitioned_lower_aux(_ForwardIterator __first,
-                                  _ForwardIterator __last, const _Tp& __value,
-                                  _Pred __pred,
-                                  std::forward_iterator_tag)
+    __check_partitioned_lower(_ForwardIterator __first,
+                              _ForwardIterator __last, const _Tp& __value,
+                              _Pred __pred)
     {
       while (__first != __last && bool(__pred(*__first, __value)))
         ++__first;
@@ -446 +398 @@
       return __first == __last;
     }
 
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence,
-           typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_lower_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value, _Pred __pred,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_lower_aux(__first.base(), __last.base(),
-                                           __value, __pred, __tag);
-    }
-
-  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp, typename _Pred>
     inline bool
-    __check_partitioned_lower(_ForwardIterator __first,
+    __check_partitioned_upper(_ForwardIterator __first,
                               _ForwardIterator __last, const _Tp& __value,
                               _Pred __pred)
     {
-      return __check_partitioned_lower_aux(__first, __last, __value, __pred,
-                                           std::__iterator_category(__first));
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper_aux(_ForwardIterator __first,
-                                  _ForwardIterator __last, const _Tp& __value,
-                                  _Pred __pred,
-                                  std::forward_iterator_tag)
-    {
       while (__first != __last && !bool(__pred(__value, *__first)))
         ++__first;
       if (__first != __last)
@@ -490 +415 @@
       return __first == __last;
     }
 
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence,
-           typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value, _Pred __pred,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_upper_aux(__first.base(), __last.base(),
-                                           __value, __pred, __tag);
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper(_ForwardIterator __first,
-                              _ForwardIterator __last, const _Tp& __value,
-                              _Pred __pred)
-    {
-      return __check_partitioned_upper_aux(__first, __last, __value, __pred,
-                                           std::__iterator_category(__first));
-    }
-
   // Helper struct to detect random access safe iterators.
   template<typename _Iterator>
     struct __is_safe_random_iterator

libstdc++-v3/include/debug/macros.h

@@ -261 +261 @@
     w.r.t. the value _Value. */
 #define __glibcxx_check_partitioned_lower(_First,_Last,_Value)          \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, \
-                                                            _Value),    \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value),            \
                       _M_message(__gnu_debug::__msg_unpartitioned)      \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
@@ -270 +271 @@
 
 #define __glibcxx_check_partitioned_upper(_First,_Last,_Value)          \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, \
-                                                            _Value),    \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value),            \
                       _M_message(__gnu_debug::__msg_unpartitioned)      \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
@@ -281 +283 @@
     w.r.t. the value _Value and predicate _Pred. */
 #define __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred) \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, \
-                                                         _Value, _Pred), \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value, _Pred),     \
                       _M_message(__gnu_debug::__msg_unpartitioned_pred) \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
@@ -293 +296 @@
     w.r.t. the value _Value and predicate _Pred. */
 #define __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred) \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, \
-                                                         _Value, _Pred), \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value, _Pred),     \
                       _M_message(__gnu_debug::__msg_unpartitioned_pred) \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \

libstdc++-v3/testsuite/20_util/shared_ptr/cons/58839.cc

@@ +1 @@
+// { dg-options "-std=gnu++11" }
+// { dg-do compile }
+
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <memory>
+
+// libstdc++/58839
+
+struct D {
+  void operator()(void*) const noexcept { }
+};
+
+void test01()
+{
+  std::unique_ptr<void, D> y;
+  std::shared_ptr<void> x = std::move(y);
+}

libstdc++-v3/testsuite/25_algorithms/nth_element/58800.cc

@@ +1 @@
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 25.3.2 [lib.alg.nth.element]
+
+// { dg-options "-std=gnu++11" }
+
+#include <algorithm>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_container;
+using __gnu_test::random_access_iterator_wrapper;
+
+typedef test_container<int, random_access_iterator_wrapper> Container;
+
+void test01()
+{
+  std::vector<int> v = {
+    207089,
+    202585,
+    180067,
+    157549,
+    211592,
+    216096,
+    207089
+  };
+
+  Container con(v.data(), v.data() + 7);
+
+  std::nth_element(con.begin(), con.begin() + 3, con.end());
+}
+
+int main()
+{
+  test01();
+  return 0;
+}