Move nested functions in libdw/cfi.c to file scope.

* No nested functions to compile with clang/llvm.

Signed-off-by: Chih-Hung Hsieh <chh@google.com>

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 39c49aa48b86a8bc225be742e1087de0c91b5a2b..4242a7c12a4eba9695b812f7c70ba82c5897f0e5 100644 (file)
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
@@ -1,3 +1,8 @@
+2015-10-14  Chih-Hung Hsieh  <chh@google.com>
+
+       * cfi.c (execute_cfi): Move nested functions 'enough_registers'
+       and 'require_cfa_offset' to file scope.
+
 2015-10-09  Josh Stone  <jistone@redhat.com>
 
        * dwarf_begin.c (dwarf_begin): Replace stat64 and fstat64 with stat

diff --git a/libdw/cfi.c b/libdw/cfi.c
index 5a6f956d432c832001bbf89c8dc1acc686983694..1fd668d79e3da0ab1be729b9ea15b096c16f4896 100644 (file)
--- a/libdw/cfi.c
+++ b/libdw/cfi.c
@@ -56,6 +56,46 @@ duplicate_frame_state (const Dwarf_Frame *original,
   return copy;
 }
 
+static inline bool
+enough_registers (Dwarf_Word reg, Dwarf_Frame **pfs, int *result)
+{
+  /* Don't allow insanely large register numbers.  268435456 registers
+     should be enough for anybody.  And very large values might overflow
+     the array size and offsetof calculations below.  */
+  if (unlikely (reg >= INT32_MAX / sizeof ((*pfs)->regs[0])))
+    {
+      *result = DWARF_E_INVALID_CFI;
+      return false;
+    }
+
+  if ((*pfs)->nregs <= reg)
+    {
+       size_t size = offsetof (Dwarf_Frame, regs[reg + 1]);
+       Dwarf_Frame *bigger = realloc (*pfs, size);
+       if (unlikely (bigger == NULL))
+         {
+           *result = DWARF_E_NOMEM;
+           return false;
+         }
+       else
+         {
+           eu_static_assert (reg_unspecified == 0);
+           memset (bigger->regs + bigger->nregs, 0,
+                   (reg + 1 - bigger->nregs) * sizeof bigger->regs[0]);
+           bigger->nregs = reg + 1;
+           *pfs = bigger;
+         }
+     }
+  return true;
+}
+
+static inline void
+require_cfa_offset (Dwarf_Frame *fs)
+{
+  if (unlikely (fs->cfa_rule != cfa_offset))
+    fs->cfa_rule = cfa_invalid;
+}
+
 /* Returns a DWARF_E_* error code, usually NOERROR or INVALID_CFI.
    Frees *STATE on failure.  */
 static int
@@ -77,46 +117,9 @@ execute_cfi (Dwarf_CFI *cache,
   } while (0)
 
   Dwarf_Frame *fs = *state;
-  inline bool enough_registers (Dwarf_Word reg)
-    {
-      /* Don't allow insanely large register numbers.  268435456 registers
-        should be enough for anybody.  And very large values might overflow
-        the array size and offsetof calculations below.  */
-      if (unlikely (reg >= INT32_MAX / sizeof (fs->regs[0])))
-       {
-         result = DWARF_E_INVALID_CFI;
-         return false;
-       }
-
-      if (fs->nregs <= reg)
-       {
-         size_t size = offsetof (Dwarf_Frame, regs[reg + 1]);
-         Dwarf_Frame *bigger = realloc (fs, size);
-         if (unlikely (bigger == NULL))
-           {
-             result = DWARF_E_NOMEM;
-             return false;
-           }
-         else
-           {
-             eu_static_assert (reg_unspecified == 0);
-             memset (bigger->regs + bigger->nregs, 0,
-                     (reg + 1 - bigger->nregs) * sizeof bigger->regs[0]);
-             bigger->nregs = reg + 1;
-             fs = bigger;
-           }
-       }
-      return true;
-    }
-
-  inline void require_cfa_offset (void)
-  {
-    if (unlikely (fs->cfa_rule != cfa_offset))
-      fs->cfa_rule = cfa_invalid;
-  }
 
 #define register_rule(regno, r_rule, r_value) do {     \
-    if (unlikely (! enough_registers (regno)))         \
+    if (unlikely (! enough_registers (regno, &fs, &result)))   \
       goto out;                                                \
     fs->regs[regno].rule = reg_##r_rule;               \
     fs->regs[regno].value = (r_value);                 \
@@ -179,7 +182,7 @@ execute_cfi (Dwarf_CFI *cache,
 
        case DW_CFA_def_cfa_register:
          get_uleb128 (regno, program, end);
-         require_cfa_offset ();
+         require_cfa_offset (fs);
          fs->cfa_val_reg = regno;
          continue;
 
@@ -193,7 +196,7 @@ execute_cfi (Dwarf_CFI *cache,
        case DW_CFA_def_cfa_offset:
          get_uleb128 (offset, program, end);
        def_cfa_offset:
-         require_cfa_offset ();
+         require_cfa_offset (fs);
          fs->cfa_val_offset = offset;
          continue;
 
@@ -310,7 +313,7 @@ execute_cfi (Dwarf_CFI *cache,
          cfi_assert (cie->initial_state != NULL);
 
          /* Restore the CIE's initial rule for this register.  */
-         if (unlikely (! enough_registers (operand)))
+         if (unlikely (! enough_registers (operand, &fs, &result)))
            goto out;
          if (cie->initial_state->nregs > operand)
            fs->regs[operand] = cie->initial_state->regs[operand];
@@ -347,7 +350,7 @@ execute_cfi (Dwarf_CFI *cache,
        case DW_CFA_GNU_window_save:
          /* This is magic shorthand used only by SPARC.  It's equivalent
             to a bunch of DW_CFA_register and DW_CFA_offset operations.  */
-         if (unlikely (! enough_registers (31)))
+         if (unlikely (! enough_registers (31, &fs, &result)))
            goto out;
          for (regno = 8; regno < 16; ++regno)
            {