GNU bug report logs - #12541
Prefer plain 'static' to 'static inline'.

Previous Next

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 12541 in the body.
You can then email your comments to 12541 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: bug-gnu-emacs <at> gnu.org
Subject: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 01:00:25 -0700

Tags: patch

This one should be pretty self-explanatory.

=== modified file 'src/ChangeLog'
--- src/ChangeLog	2012-09-30 07:26:32 +0000
+++ src/ChangeLog	2012-09-30 07:57:28 +0000
@@ -1,3 +1,98 @@
+2012-09-30  Paul Eggert  <eggert <at> cs.ucla.edu>
+
+	Prefer plain 'static' to 'static inline'.
+	With static functions, modern compilers inline pretty well by
+	themselves; advice from programmers often hurts as much as it helps.
+	On my host (x86-64, Fedora 17, GCC 4.7.2, default 'configure'),
+	this change shrinks the text size of the Emacs executable by 1.7%
+	without affecting CPU significantly in my benchmark.
+	* alloc.c (mem_find, live_string_p, live_cons_p, live_symbol_p)
+	(live_float_p, live_misc_p, live_vector_p, live_buffer_p)
+	(mark_maybe_object, mark_maybe_pointer, bounded_number):
+	* bidi.c (bidi_get_type, bidi_check_type, bidi_get_category)
+	(bidi_set_sor_type, bidi_push_embedding_level)
+	(bidi_pop_embedding_level, bidi_remember_char, bidi_copy_it)
+	(bidi_cache_reset, bidi_cache_shrink, bidi_cache_fetch_state)
+	(bidi_cache_search, bidi_cache_ensure_space)
+	(bidi_cache_iterator_state, bidi_cache_find)
+	(bidi_peek_at_next_level, bidi_set_paragraph_end)
+	(bidi_count_bytes, bidi_char_at_pos, bidi_fetch_char)
+	(bidi_explicit_dir_char, bidi_resolve_neutral_1):
+	* buffer.c (bset_abbrev_mode, bset_abbrev_table)
+	(bset_auto_fill_function, bset_auto_save_file_format)
+	(bset_auto_save_file_name, bset_backed_up, bset_begv_marker)
+	(bset_bidi_display_reordering, bset_buffer_file_coding_system)
+	(bset_cache_long_line_scans, bset_case_fold_search)
+	(bset_ctl_arrow, bset_cursor_in_non_selected_windows)
+	(bset_cursor_type, bset_display_table, bset_extra_line_spacing)
+	(bset_file_format, bset_file_truename, bset_fringe_cursor_alist)
+	(bset_fringe_indicator_alist, bset_fringes_outside_margins)
+	(bset_header_line_format, bset_indicate_buffer_boundaries)
+	(bset_indicate_empty_lines, bset_invisibility_spec)
+	(bset_left_fringe_width, bset_major_mode, bset_mark)
+	(bset_minor_modes, bset_mode_line_format, bset_mode_name)
+	(bset_name, bset_overwrite_mode, bset_pt_marker)
+	(bset_right_fringe_width, bset_save_length)
+	(bset_scroll_bar_width, bset_scroll_down_aggressively)
+	(bset_scroll_up_aggressively, bset_selective_display)
+	(bset_selective_display_ellipses, bset_vertical_scroll_bar_type)
+	(bset_word_wrap, bset_zv_marker, set_buffer_overlays_before)
+	(set_buffer_overlays_after):
+	* category.c (bset_category_table):
+	* charset.c (read_hex):
+	* coding.c (produce_composition, produce_charset)
+	(handle_composition_annotation, handle_charset_annotation)
+	(char_encodable_p):
+	* dispnew.c (swap_glyph_pointers, copy_row_except_pointers)
+	(assign_row, set_frame_matrix_frame, make_current)
+	(add_row_entry):
+	* eval.c (set_specpdl_symbol, set_specpdl_old_value):
+	* fns.c (maybe_resize_hash_table):
+	* frame.c (fset_buffer_predicate, fset_minibuffer_window):
+	* gmalloc.c (register_heapinfo):
+	* image.c (lookup_image_type):
+	* intervals.c (set_interval_object, set_interval_left)
+	(set_interval_right, copy_interval_parent, rotate_right)
+	(rotate_left, balance_possible_root_interval):
+	* keyboard.c (kset_echo_string, kset_kbd_queue)
+	(kset_keyboard_translate_table, kset_last_prefix_arg)
+	(kset_last_repeatable_command, kset_local_function_key_map)
+	(kset_overriding_terminal_local_map, kset_real_last_command)
+	(kset_system_key_syms, clear_event, set_prop):
+	* lread.c (digit_to_number):
+	* marker.c (attach_marker, live_buffer, set_marker_internal):
+	* nsterm.m (ns_compute_glyph_string_overhangs):
+	* process.c (pset_buffer, pset_command)
+	(pset_decode_coding_system, pset_decoding_buf)
+	(pset_encode_coding_system, pset_encoding_buf, pset_filter)
+	(pset_log, pset_mark, pset_name, pset_plist, pset_sentinel)
+	(pset_status, pset_tty_name, pset_type, pset_write_queue):
+	* syntax.c (bset_syntax_table, dec_bytepos):
+	* terminal.c (tset_param_alist):
+	* textprop.c (interval_has_some_properties)
+	(interval_has_some_properties_list):
+	* window.c (wset_combination_limit, wset_dedicated)
+	(wset_display_table, wset_hchild, wset_left_fringe_width)
+	(wset_left_margin_cols, wset_new_normal, wset_new_total)
+	(wset_normal_cols, wset_normal_lines, wset_parent, wset_pointm)
+	(wset_right_fringe_width, wset_right_margin_cols)
+	(wset_scroll_bar_width, wset_start, wset_temslot, wset_vchild)
+	(wset_vertical_scroll_bar_type, wset_window_parameters):
+	* xdisp.c (wset_base_line_number, wset_base_line_pos)
+	(wset_column_number_displayed, wset_region_showing)
+	(window_box_edges, run_window_scroll_functions)
+	(append_glyph_string_lists, prepend_glyph_string_lists)
+	(append_glyph_string, set_glyph_string_background_width)
+	(append_glyph, append_composite_glyph)
+	(take_vertical_position_into_account):
+	* xfaces.c (x_create_gc, x_free_gc, merge_face_vectors)
+	(face_attr_equal_p, lface_equal_p, hash_string_case_insensitive)
+	(lface_hash, lface_same_font_attributes_p, lookup_face):
+	* xml.c (libxml2_loaded_p):
+	* xterm.c (x_set_mode_line_face_gc, x_set_glyph_string_gc)
+	(x_set_glyph_string_clipping, x_clear_glyph_string_rect):
+	Now 'static', not 'static inline'.
+
 2012-09-30  Eli Zaretskii  <eliz <at> gnu.org>
 
 	* profiler.c (Fprofiler_cpu_stop): Use timer_settime only if

=== modified file 'src/alloc.c'
--- src/alloc.c	2012-09-29 02:02:34 +0000
+++ src/alloc.c	2012-09-30 07:00:20 +0000
@@ -354,7 +354,7 @@
 static void mem_rotate_right (struct mem_node *);
 static void mem_delete (struct mem_node *);
 static void mem_delete_fixup (struct mem_node *);
-static inline struct mem_node *mem_find (void *);
+static struct mem_node *mem_find (void *);
 #endif
 
 
@@ -3549,7 +3549,7 @@
 /* Value is a pointer to the mem_node containing START.  Value is
    MEM_NIL if there is no node in the tree containing START.  */
 
-static inline struct mem_node *
+static struct mem_node *
 mem_find (void *start)
 {
   struct mem_node *p;
@@ -3925,7 +3925,7 @@
 /* Value is non-zero if P is a pointer to a live Lisp string on
    the heap.  M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_string_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_STRING)
@@ -3948,7 +3948,7 @@
 /* Value is non-zero if P is a pointer to a live Lisp cons on
    the heap.  M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_cons_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_CONS)
@@ -3974,7 +3974,7 @@
 /* Value is non-zero if P is a pointer to a live Lisp symbol on
    the heap.  M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_symbol_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_SYMBOL)
@@ -4000,7 +4000,7 @@
 /* Value is non-zero if P is a pointer to a live Lisp float on
    the heap.  M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_float_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_FLOAT)
@@ -4024,7 +4024,7 @@
 /* Value is non-zero if P is a pointer to a live Lisp Misc on
    the heap.  M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_misc_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_MISC)
@@ -4050,7 +4050,7 @@
 /* Value is non-zero if P is a pointer to a live vector-like object.
    M is a pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_vector_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_VECTOR_BLOCK)
@@ -4086,7 +4086,7 @@
 /* Value is non-zero if P is a pointer to a live buffer.  M is a
    pointer to the mem_block for P.  */
 
-static inline bool
+static bool
 live_buffer_p (struct mem_node *m, void *p)
 {
   /* P must point to the start of the block, and the buffer
@@ -4152,7 +4152,7 @@
 
 /* Mark OBJ if we can prove it's a Lisp_Object.  */
 
-static inline void
+static void
 mark_maybe_object (Lisp_Object obj)
 {
   void *po;
@@ -4221,7 +4221,7 @@
 /* If P points to Lisp data, mark that as live if it isn't already
    marked.  */
 
-static inline void
+static void
 mark_maybe_pointer (void *p)
 {
   struct mem_node *m;
@@ -5051,7 +5051,7 @@
 /* Used to avoid possible overflows when
    converting from C to Lisp integers.  */
 
-static inline Lisp_Object
+static Lisp_Object
 bounded_number (EMACS_INT number)
 {
   return make_number (min (MOST_POSITIVE_FIXNUM, number));

=== modified file 'src/bidi.c'
--- src/bidi.c	2012-09-15 07:06:56 +0000
+++ src/bidi.c	2012-09-30 07:00:20 +0000
@@ -96,7 +96,7 @@
 
 /* Return the bidi type of a character CH, subject to the current
    directional OVERRIDE.  */
-static inline bidi_type_t
+static bidi_type_t
 bidi_get_type (int ch, bidi_dir_t override)
 {
   bidi_type_t default_type;
@@ -145,14 +145,14 @@
     }
 }
 
-static inline void
+static void
 bidi_check_type (bidi_type_t type)
 {
   eassert (UNKNOWN_BT <= type && type <= NEUTRAL_ON);
 }
 
 /* Given a bidi TYPE of a character, return its category.  */
-static inline bidi_category_t
+static bidi_category_t
 bidi_get_category (bidi_type_t type)
 {
   switch (type)
@@ -226,7 +226,7 @@
    embedding levels on either side of the run boundary.  Also, update
    the saved info about previously seen characters, since that info is
    generally valid for a single level run.  */
-static inline void
+static void
 bidi_set_sor_type (struct bidi_it *bidi_it, int level_before, int level_after)
 {
   int higher_level = (level_before > level_after ? level_before : level_after);
@@ -257,7 +257,7 @@
 
 /* Push the current embedding level and override status; reset the
    current level to LEVEL and the current override status to OVERRIDE.  */
-static inline void
+static void
 bidi_push_embedding_level (struct bidi_it *bidi_it,
 			   int level, bidi_dir_t override)
 {
@@ -269,7 +269,7 @@
 
 /* Pop the embedding level and directional override status from the
    stack, and return the new level.  */
-static inline int
+static int
 bidi_pop_embedding_level (struct bidi_it *bidi_it)
 {
   /* UAX#9 says to ignore invalid PDFs.  */
@@ -279,7 +279,7 @@
 }
 
 /* Record in SAVED_INFO the information about the current character.  */
-static inline void
+static void
 bidi_remember_char (struct bidi_saved_info *saved_info,
 		    struct bidi_it *bidi_it)
 {
@@ -295,7 +295,7 @@
 
 /* Copy the bidi iterator from FROM to TO.  To save cycles, this only
    copies the part of the level stack that is actually in use.  */
-static inline void
+static void
 bidi_copy_it (struct bidi_it *to, struct bidi_it *from)
 {
   int i;
@@ -344,7 +344,7 @@
    intact.  This is called when the cached information is no more
    useful for the current iteration, e.g. when we were reseated to a
    new position on the same object.  */
-static inline void
+static void
 bidi_cache_reset (void)
 {
   bidi_cache_idx = bidi_cache_start;
@@ -355,7 +355,7 @@
    iterator for reordering a buffer or a string that does not come
    from display properties, because that means all the previously
    cached info is of no further use.  */
-static inline void
+static void
 bidi_cache_shrink (void)
 {
   if (bidi_cache_size > BIDI_CACHE_CHUNK)
@@ -366,7 +366,7 @@
   bidi_cache_reset ();
 }
 
-static inline void
+static void
 bidi_cache_fetch_state (ptrdiff_t idx, struct bidi_it *bidi_it)
 {
   int current_scan_dir = bidi_it->scan_dir;
@@ -383,7 +383,7 @@
    level less or equal to LEVEL.  if LEVEL is -1, disregard the
    resolved levels in cached states.  DIR, if non-zero, means search
    in that direction from the last cache hit.  */
-static inline ptrdiff_t
+static ptrdiff_t
 bidi_cache_search (ptrdiff_t charpos, int level, int dir)
 {
   ptrdiff_t i, i_start;
@@ -488,7 +488,7 @@
   return -1;
 }
 
-static inline void
+static void
 bidi_cache_ensure_space (ptrdiff_t idx)
 {
   /* Enlarge the cache as needed.  */
@@ -510,7 +510,7 @@
     }
 }
 
-static inline void
+static void
 bidi_cache_iterator_state (struct bidi_it *bidi_it, bool resolved)
 {
   ptrdiff_t idx;
@@ -567,7 +567,7 @@
     bidi_cache_idx = idx + 1;
 }
 
-static inline bidi_type_t
+static bidi_type_t
 bidi_cache_find (ptrdiff_t charpos, int level, struct bidi_it *bidi_it)
 {
   ptrdiff_t i = bidi_cache_search (charpos, level, bidi_it->scan_dir);
@@ -587,7 +587,7 @@
   return UNKNOWN_BT;
 }
 
-static inline int
+static int
 bidi_peek_at_next_level (struct bidi_it *bidi_it)
 {
   if (bidi_cache_idx == bidi_cache_start || bidi_cache_last_idx == -1)
@@ -790,7 +790,7 @@
 
 /* Do whatever UAX#9 clause X8 says should be done at paragraph's
    end.  */
-static inline void
+static void
 bidi_set_paragraph_end (struct bidi_it *bidi_it)
 {
   bidi_it->invalid_levels = 0;
@@ -872,7 +872,7 @@
 /* Count bytes in string S between BEG/BEGBYTE and END.  BEG and END
    are zero-based character positions in S, BEGBYTE is byte position
    corresponding to BEG.  UNIBYTE means S is a unibyte string.  */
-static inline ptrdiff_t
+static ptrdiff_t
 bidi_count_bytes (const unsigned char *s, const ptrdiff_t beg,
 		  const ptrdiff_t begbyte, const ptrdiff_t end, bool unibyte)
 {
@@ -900,7 +900,7 @@
    non-NULL, fetch the character from string S; otherwise fetch the
    character from the current buffer.  UNIBYTE means S is a
    unibyte string.  */
-static inline int
+static int
 bidi_char_at_pos (ptrdiff_t bytepos, const unsigned char *s, bool unibyte)
 {
   if (s)
@@ -928,7 +928,7 @@
    u+2029 to handle it as a paragraph separator.  STRING->s is the C
    string to iterate, or NULL if iterating over a buffer or a Lisp
    string; in the latter case, STRING->lstring is the Lisp string.  */
-static inline int
+static int
 bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
 		 int *disp_prop, struct bidi_string_data *string,
 		 bool frame_window_p, ptrdiff_t *ch_len, ptrdiff_t *nchars)
@@ -1318,7 +1318,7 @@
   The rest of this file constitutes the core of the UBA implementation.
  ***********************************************************************/
 
-static inline bool
+static bool
 bidi_explicit_dir_char (int ch)
 {
   bidi_type_t ch_type;
@@ -1841,7 +1841,7 @@
 
 /* Resolve the type of a neutral character according to the type of
    surrounding strong text and the current embedding level.  */
-static inline bidi_type_t
+static bidi_type_t
 bidi_resolve_neutral_1 (bidi_type_t prev_type, bidi_type_t next_type, int lev)
 {
   /* N1: European and Arabic numbers are treated as though they were R.  */

=== modified file 'src/buffer.c'
--- src/buffer.c	2012-09-23 08:44:20 +0000
+++ src/buffer.c	2012-09-30 07:00:20 +0000
@@ -150,222 +150,222 @@
 static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool);
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 bset_abbrev_mode (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (abbrev_mode) = val;
 }
-static inline void
+static void
 bset_abbrev_table (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (abbrev_table) = val;
 }
-static inline void
+static void
 bset_auto_fill_function (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (auto_fill_function) = val;
 }
-static inline void
+static void
 bset_auto_save_file_format (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (auto_save_file_format) = val;
 }
-static inline void
+static void
 bset_auto_save_file_name (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (auto_save_file_name) = val;
 }
-static inline void
+static void
 bset_backed_up (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (backed_up) = val;
 }
-static inline void
+static void
 bset_begv_marker (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (begv_marker) = val;
 }
-static inline void
+static void
 bset_bidi_display_reordering (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (bidi_display_reordering) = val;
 }
-static inline void
+static void
 bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (buffer_file_coding_system) = val;
 }
-static inline void
+static void
 bset_cache_long_line_scans (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (cache_long_line_scans) = val;
 }
-static inline void
+static void
 bset_case_fold_search (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (case_fold_search) = val;
 }
-static inline void
+static void
 bset_ctl_arrow (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (ctl_arrow) = val;
 }
-static inline void
+static void
 bset_cursor_in_non_selected_windows (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (cursor_in_non_selected_windows) = val;
 }
-static inline void
+static void
 bset_cursor_type (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (cursor_type) = val;
 }
-static inline void
+static void
 bset_display_table (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (display_table) = val;
 }
-static inline void
+static void
 bset_extra_line_spacing (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (extra_line_spacing) = val;
 }
-static inline void
+static void
 bset_file_format (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (file_format) = val;
 }
-static inline void
+static void
 bset_file_truename (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (file_truename) = val;
 }
-static inline void
+static void
 bset_fringe_cursor_alist (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (fringe_cursor_alist) = val;
 }
-static inline void
+static void
 bset_fringe_indicator_alist (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (fringe_indicator_alist) = val;
 }
-static inline void
+static void
 bset_fringes_outside_margins (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (fringes_outside_margins) = val;
 }
-static inline void
+static void
 bset_header_line_format (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (header_line_format) = val;
 }
-static inline void
+static void
 bset_indicate_buffer_boundaries (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (indicate_buffer_boundaries) = val;
 }
-static inline void
+static void
 bset_indicate_empty_lines (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (indicate_empty_lines) = val;
 }
-static inline void
+static void
 bset_invisibility_spec (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (invisibility_spec) = val;
 }
-static inline void
+static void
 bset_left_fringe_width (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (left_fringe_width) = val;
 }
-static inline void
+static void
 bset_major_mode (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (major_mode) = val;
 }
-static inline void
+static void
 bset_mark (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (mark) = val;
 }
-static inline void
+static void
 bset_minor_modes (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (minor_modes) = val;
 }
-static inline void
+static void
 bset_mode_line_format (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (mode_line_format) = val;
 }
-static inline void
+static void
 bset_mode_name (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (mode_name) = val;
 }
-static inline void
+static void
 bset_name (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (name) = val;
 }
-static inline void
+static void
 bset_overwrite_mode (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (overwrite_mode) = val;
 }
-static inline void
+static void
 bset_pt_marker (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (pt_marker) = val;
 }
-static inline void
+static void
 bset_right_fringe_width (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (right_fringe_width) = val;
 }
-static inline void
+static void
 bset_save_length (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (save_length) = val;
 }
-static inline void
+static void
 bset_scroll_bar_width (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (scroll_bar_width) = val;
 }
-static inline void
+static void
 bset_scroll_down_aggressively (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (scroll_down_aggressively) = val;
 }
-static inline void
+static void
 bset_scroll_up_aggressively (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (scroll_up_aggressively) = val;
 }
-static inline void
+static void
 bset_selective_display (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (selective_display) = val;
 }
-static inline void
+static void
 bset_selective_display_ellipses (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (selective_display_ellipses) = val;
 }
-static inline void
+static void
 bset_vertical_scroll_bar_type (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (vertical_scroll_bar_type) = val;
 }
-static inline void
+static void
 bset_word_wrap (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (word_wrap) = val;
 }
-static inline void
+static void
 bset_zv_marker (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (zv_marker) = val;
@@ -651,13 +651,13 @@
 
 /* Set an appropriate overlay of B.  */
 
-static inline void
+static void
 set_buffer_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
 {
   b->overlays_before = o;
 }
 
-static inline void
+static void
 set_buffer_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
 {
   b->overlays_after = o;

=== modified file 'src/category.c'
--- src/category.c	2012-09-15 07:06:56 +0000
+++ src/category.c	2012-09-30 07:00:20 +0000
@@ -40,7 +40,7 @@
 #include "keymap.h"
 
 /* This setter is used only in this file, so it can be private.  */
-static inline void
+static void
 bset_category_table (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (category_table) = val;

=== modified file 'src/charset.c'
--- src/charset.c	2012-09-26 20:00:29 +0000
+++ src/charset.c	2012-09-30 07:00:20 +0000
@@ -421,7 +421,7 @@
 /* Read a hexadecimal number (preceded by "0x") from the file FP while
    paying attention to comment character '#'.  */
 
-static inline unsigned
+static unsigned
 read_hex (FILE *fp, bool *eof, bool *overflow)
 {
   int c;

=== modified file 'src/coding.c'
--- src/coding.c	2012-09-25 12:44:13 +0000
+++ src/coding.c	2012-09-30 07:00:20 +0000
@@ -6805,7 +6805,7 @@
      [ -LENGTH ANNOTATION_MASK NCHARS NBYTES METHOD [ COMPONENTS... ] ]
  */
 
-static inline void
+static void
 produce_composition (struct coding_system *coding, int *charbuf, ptrdiff_t pos)
 {
   int len;
@@ -6849,7 +6849,7 @@
      [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
  */
 
-static inline void
+static void
 produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos)
 {
   ptrdiff_t from = pos - charbuf[2];
@@ -7084,7 +7084,7 @@
    position of a composition after POS (if any) or to LIMIT, and
    return BUF.  */
 
-static inline int *
+static int *
 handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit,
 			       struct coding_system *coding, int *buf,
 			       ptrdiff_t *stop)
@@ -7167,7 +7167,7 @@
    If the property value is nil, set *STOP to the position where the
    property value is non-nil (limiting by LIMIT), and return BUF.  */
 
-static inline int *
+static int *
 handle_charset_annotation (ptrdiff_t pos, ptrdiff_t limit,
 			   struct coding_system *coding, int *buf,
 			   ptrdiff_t *stop)
@@ -8412,7 +8412,7 @@
 }
 
 
-static inline bool
+static bool
 char_encodable_p (int c, Lisp_Object attrs)
 {
   Lisp_Object tail;

=== modified file 'src/dispnew.c'
--- src/dispnew.c	2012-09-23 08:44:20 +0000
+++ src/dispnew.c	2012-09-30 07:00:20 +0000
@@ -1028,7 +1028,7 @@
    these should all go together for the row's hash value to be
    correct.  */
 
-static inline void
+static void
 swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b)
 {
   int i;
@@ -1057,7 +1057,7 @@
    that glyph pointers, the `used' counts, and the hash values in the
    structures are left unchanged.  */
 
-static inline void
+static void
 copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
 {
   struct glyph *pointers[1 + LAST_AREA];
@@ -1084,7 +1084,7 @@
    exchanged between TO and FROM.  Pointers must be exchanged to avoid
    a memory leak.  */
 
-static inline void
+static void
 assign_row (struct glyph_row *to, struct glyph_row *from)
 {
   swap_glyph_pointers (to, from);
@@ -1249,7 +1249,7 @@
 /* Return true if the glyph rows A and B have equal contents.
    MOUSE_FACE_P means compare the mouse_face_p flags of A and B, too.  */
 
-static inline bool
+static bool
 row_equal_p (struct glyph_row *a, struct glyph_row *b, bool mouse_face_p)
 {
   eassert (verify_row_hash (a));
@@ -2657,7 +2657,7 @@
    function must be called before updates to make explicit that we are
    working on frame matrices or not.  */
 
-static inline void
+static void
 set_frame_matrix_frame (struct frame *f)
 {
   frame_matrix_frame = f;
@@ -2672,7 +2672,7 @@
    done in frame matrices, and that we have to perform analogous
    operations in window matrices of frame_matrix_frame.  */
 
-static inline void
+static void
 make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_matrix, int row)
 {
   struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
@@ -4158,7 +4158,7 @@
 
 /* Add glyph row ROW to the scrolling hash table.  */
 
-static inline struct row_entry *
+static struct row_entry *
 add_row_entry (struct glyph_row *row)
 {
   struct row_entry *entry;

=== modified file 'src/eval.c'
--- src/eval.c	2012-09-29 02:02:34 +0000
+++ src/eval.c	2012-09-30 07:00:20 +0000
@@ -119,13 +119,13 @@
 
 /* Functions to set Lisp_Object slots of struct specbinding.  */
 
-static inline void
+static void
 set_specpdl_symbol (Lisp_Object symbol)
 {
   specpdl_ptr->symbol = symbol;
 }
 
-static inline void
+static void
 set_specpdl_old_value (Lisp_Object oldval)
 {
   specpdl_ptr->old_value = oldval;

=== modified file 'src/fns.c'
--- src/fns.c	2012-09-26 15:19:10 +0000
+++ src/fns.c	2012-09-30 07:00:20 +0000
@@ -3694,7 +3694,7 @@
 /* Resize hash table H if it's too full.  If H cannot be resized
    because it's already too large, throw an error.  */
 
-static inline void
+static void
 maybe_resize_hash_table (struct Lisp_Hash_Table *h)
 {
   if (NILP (h->next_free))

=== modified file 'src/frame.c'
--- src/frame.c	2012-09-23 08:44:20 +0000
+++ src/frame.c	2012-09-30 07:00:20 +0000
@@ -120,12 +120,12 @@
 #endif
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 fset_buffer_predicate (struct frame *f, Lisp_Object val)
 {
   f->buffer_predicate = val;
 }
-static inline void
+static void
 fset_minibuffer_window (struct frame *f, Lisp_Object val)
 {
   f->minibuffer_window = val;

=== modified file 'src/gmalloc.c'
--- src/gmalloc.c	2012-07-14 10:03:30 +0000
+++ src/gmalloc.c	2012-08-18 07:54:14 +0000
@@ -460,7 +460,7 @@
 /* This is called when `_heapinfo' and `heapsize' have just
    been set to describe a new info table.  Set up the table
    to describe itself and account for it in the statistics.  */
-static inline void
+static void
 register_heapinfo (void)
 {
   size_t block, blocks;

=== modified file 'src/intervals.c'
--- src/intervals.c	2012-09-16 21:43:55 +0000
+++ src/intervals.c	2012-09-30 07:00:20 +0000
@@ -64,7 +64,7 @@
 /* Use these functions to set Lisp_Object
    or pointer slots of struct interval.  */
 
-static inline void
+static void
 set_interval_object (INTERVAL i, Lisp_Object obj)
 {
   eassert (BUFFERP (obj) || STRINGP (obj));
@@ -72,13 +72,13 @@
   i->up.obj = obj;
 }
 
-static inline void
+static void
 set_interval_left (INTERVAL i, INTERVAL left)
 {
   i->left = left;
 }
 
-static inline void
+static void
 set_interval_right (INTERVAL i, INTERVAL right)
 {
   i->right = right;
@@ -87,7 +87,7 @@
 /* Make the parent of D be whatever the parent of S is, regardless
    of the type.  This is used when balancing an interval tree.  */
 
-static inline void
+static void
 copy_interval_parent (INTERVAL d, INTERVAL s)
 {
   d->up = s->up;
@@ -341,7 +341,7 @@
      c		  c
 */
 
-static inline INTERVAL
+static INTERVAL
 rotate_right (INTERVAL interval)
 {
   INTERVAL i;
@@ -388,7 +388,7 @@
     c               c
 */
 
-static inline INTERVAL
+static INTERVAL
 rotate_left (INTERVAL interval)
 {
   INTERVAL i;
@@ -466,7 +466,7 @@
 /* Balance INTERVAL, potentially stuffing it back into its parent
    Lisp Object.  */
 
-static inline INTERVAL
+static INTERVAL
 balance_possible_root_interval (INTERVAL interval)
 {
   Lisp_Object parent;

=== modified file 'src/keyboard.c'
--- src/keyboard.c	2012-09-23 08:44:20 +0000
+++ src/keyboard.c	2012-09-30 07:00:20 +0000
@@ -448,47 +448,47 @@
 static void store_user_signal_events (void);
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 kset_echo_string (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (echo_string) = val;
 }
-static inline void
+static void
 kset_kbd_queue (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (kbd_queue) = val;
 }
-static inline void
+static void
 kset_keyboard_translate_table (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Vkeyboard_translate_table) = val;
 }
-static inline void
+static void
 kset_last_prefix_arg (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Vlast_prefix_arg) = val;
 }
-static inline void
+static void
 kset_last_repeatable_command (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Vlast_repeatable_command) = val;
 }
-static inline void
+static void
 kset_local_function_key_map (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Vlocal_function_key_map) = val;
 }
-static inline void
+static void
 kset_overriding_terminal_local_map (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Voverriding_terminal_local_map) = val;
 }
-static inline void
+static void
 kset_real_last_command (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (Vreal_last_command) = val;
 }
-static inline void
+static void
 kset_system_key_syms (struct kboard *kb, Lisp_Object val)
 {
   kb->INTERNAL_FIELD (system_key_syms) = val;
@@ -3749,7 +3749,7 @@
 
 /* Clear input event EVENT.  */
 
-static inline void
+static void
 clear_event (struct input_event *event)
 {
   event->kind = NO_EVENT;
@@ -8054,7 +8054,7 @@
 
 /* Access slot with index IDX of vector tool_bar_item_properties.  */
 #define PROP(IDX) AREF (tool_bar_item_properties, (IDX))
-static inline void
+static void
 set_prop (ptrdiff_t idx, Lisp_Object val)
 {
   ASET (tool_bar_item_properties, idx, val);

=== modified file 'src/lread.c'
--- src/lread.c	2012-09-28 07:45:18 +0000
+++ src/lread.c	2012-09-30 07:00:20 +0000
@@ -2283,7 +2283,7 @@
 /* Return the digit that CHARACTER stands for in the given BASE.
    Return -1 if CHARACTER is out of range for BASE,
    and -2 if CHARACTER is not valid for any supported BASE.  */
-static inline int
+static int
 digit_to_number (int character, int base)
 {
   int digit;

=== modified file 'src/marker.c'
--- src/marker.c	2012-09-15 07:06:56 +0000
+++ src/marker.c	2012-09-30 07:00:20 +0000
@@ -427,7 +427,7 @@
 
 /* Change M so it points to B at CHARPOS and BYTEPOS.  */
 
-static inline void
+static void
 attach_marker (struct Lisp_Marker *m, struct buffer *b,
 	       ptrdiff_t charpos, ptrdiff_t bytepos)
 {
@@ -454,7 +454,7 @@
    whether BUFFER is a buffer object and return buffer pointer
    corresponding to BUFFER if BUFFER is live, or NULL otherwise.  */
 
-static inline struct buffer *
+static struct buffer *
 live_buffer (Lisp_Object buffer)
 {
   struct buffer *b;
@@ -477,7 +477,7 @@
 /* Internal function to set MARKER in BUFFER at POSITION.  Non-zero
    RESTRICTED means limit the POSITION by the visible part of BUFFER.  */
 
-static inline Lisp_Object
+static Lisp_Object
 set_marker_internal (Lisp_Object marker, Lisp_Object position,
 		     Lisp_Object buffer, int restricted)
 {

=== modified file 'src/nsterm.m'
--- src/nsterm.m	2012-09-24 21:38:23 +0000
+++ src/nsterm.m	2012-09-30 07:00:20 +0000
@@ -2155,7 +2155,7 @@
    ========================================================================== */
 
 
-static inline void
+static void
 ns_compute_glyph_string_overhangs (struct glyph_string *s)
 /* --------------------------------------------------------------------------
      External (RIF); compute left/right overhang of whole string and set in s

=== modified file 'src/process.c'
--- src/process.c	2012-09-23 08:44:20 +0000
+++ src/process.c	2012-09-30 07:00:20 +0000
@@ -335,82 +335,82 @@
 static int pty_max_bytes;
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 pset_buffer (struct Lisp_Process *p, Lisp_Object val)
 {
   p->buffer = val;
 }
-static inline void
+static void
 pset_command (struct Lisp_Process *p, Lisp_Object val)
 {
   p->command = val;
 }
-static inline void
+static void
 pset_decode_coding_system (struct Lisp_Process *p, Lisp_Object val)
 {
   p->decode_coding_system = val;
 }
-static inline void
+static void
 pset_decoding_buf (struct Lisp_Process *p, Lisp_Object val)
 {
   p->decoding_buf = val;
 }
-static inline void
+static void
 pset_encode_coding_system (struct Lisp_Process *p, Lisp_Object val)
 {
   p->encode_coding_system = val;
 }
-static inline void
+static void
 pset_encoding_buf (struct Lisp_Process *p, Lisp_Object val)
 {
   p->encoding_buf = val;
 }
-static inline void
+static void
 pset_filter (struct Lisp_Process *p, Lisp_Object val)
 {
   p->filter = val;
 }
-static inline void
+static void
 pset_log (struct Lisp_Process *p, Lisp_Object val)
 {
   p->log = val;
 }
-static inline void
+static void
 pset_mark (struct Lisp_Process *p, Lisp_Object val)
 {
   p->mark = val;
 }
-static inline void
+static void
 pset_name (struct Lisp_Process *p, Lisp_Object val)
 {
   p->name = val;
 }
-static inline void
+static void
 pset_plist (struct Lisp_Process *p, Lisp_Object val)
 {
   p->plist = val;
 }
-static inline void
+static void
 pset_sentinel (struct Lisp_Process *p, Lisp_Object val)
 {
   p->sentinel = val;
 }
-static inline void
+static void
 pset_status (struct Lisp_Process *p, Lisp_Object val)
 {
   p->status = val;
 }
-static inline void
+static void
 pset_tty_name (struct Lisp_Process *p, Lisp_Object val)
 {
   p->tty_name = val;
 }
-static inline void
+static void
 pset_type (struct Lisp_Process *p, Lisp_Object val)
 {
   p->type = val;
 }
-static inline void
+static void
 pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
 {
   p->write_queue = val;

=== modified file 'src/syntax.c'
--- src/syntax.c	2012-09-15 07:06:56 +0000
+++ src/syntax.c	2012-09-30 07:00:20 +0000
@@ -151,7 +151,7 @@
 static int in_classes (int, Lisp_Object);
 
 /* This setter is used only in this file, so it can be private.  */
-static inline void
+static void
 bset_syntax_table (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (syntax_table) = val;
@@ -372,7 +372,7 @@
 /* Return the bytepos one character before BYTEPOS.
    We assume that BYTEPOS is not at the start of the buffer.  */
 
-static inline ptrdiff_t
+static ptrdiff_t
 dec_bytepos (ptrdiff_t bytepos)
 {
   if (NILP (BVAR (current_buffer, enable_multibyte_characters)))

=== modified file 'src/terminal.c'
--- src/terminal.c	2012-09-15 07:06:56 +0000
+++ src/terminal.c	2012-09-30 07:00:20 +0000
@@ -42,7 +42,7 @@
 static void delete_initial_terminal (struct terminal *);
 
 /* This setter is used only in this file, so it can be private.  */
-static inline void
+static void
 tset_param_alist (struct terminal *t, Lisp_Object val)
 {
   t->param_alist = val;

=== modified file 'src/textprop.c'
--- src/textprop.c	2012-09-15 07:06:56 +0000
+++ src/textprop.c	2012-09-30 07:00:20 +0000
@@ -241,7 +241,7 @@
 /* Return nonzero if the plist of interval I has any of the
    properties of PLIST, regardless of their values.  */
 
-static inline int
+static int
 interval_has_some_properties (Lisp_Object plist, INTERVAL i)
 {
   register Lisp_Object tail1, tail2, sym;
@@ -263,7 +263,7 @@
 /* Return nonzero if the plist of interval I has any of the
    property names in LIST, regardless of their values.  */
 
-static inline int
+static int
 interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
 {
   register Lisp_Object tail1, tail2, sym;

=== modified file 'src/window.c'
--- src/window.c	2012-09-23 08:44:20 +0000
+++ src/window.c	2012-09-30 07:00:20 +0000
@@ -133,102 +133,102 @@
 static EMACS_INT window_scroll_preserve_vpos;
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 wset_combination_limit (struct window *w, Lisp_Object val)
 {
   w->combination_limit = val;
 }
-static inline void
+static void
 wset_dedicated (struct window *w, Lisp_Object val)
 {
   w->dedicated = val;
 }
-static inline void
+static void
 wset_display_table (struct window *w, Lisp_Object val)
 {
   w->display_table = val;
 }
-static inline void
+static void
 wset_hchild (struct window *w, Lisp_Object val)
 {
   w->hchild = val;
 }
-static inline void
+static void
 wset_left_fringe_width (struct window *w, Lisp_Object val)
 {
   w->left_fringe_width = val;
 }
-static inline void
+static void
 wset_left_margin_cols (struct window *w, Lisp_Object val)
 {
   w->left_margin_cols = val;
 }
-static inline void
+static void
 wset_new_normal (struct window *w, Lisp_Object val)
 {
   w->new_normal = val;
 }
-static inline void
+static void
 wset_new_total (struct window *w, Lisp_Object val)
 {
   w->new_total = val;
 }
-static inline void
+static void
 wset_normal_cols (struct window *w, Lisp_Object val)
 {
   w->normal_cols = val;
 }
-static inline void
+static void
 wset_normal_lines (struct window *w, Lisp_Object val)
 {
   w->normal_lines = val;
 }
-static inline void
+static void
 wset_parent (struct window *w, Lisp_Object val)
 {
   w->parent = val;
 }
-static inline void
+static void
 wset_pointm (struct window *w, Lisp_Object val)
 {
   w->pointm = val;
 }
-static inline void
+static void
 wset_right_fringe_width (struct window *w, Lisp_Object val)
 {
   w->right_fringe_width = val;
 }
-static inline void
+static void
 wset_right_margin_cols (struct window *w, Lisp_Object val)
 {
   w->right_margin_cols = val;
 }
-static inline void
+static void
 wset_scroll_bar_width (struct window *w, Lisp_Object val)
 {
   w->scroll_bar_width = val;
 }
-static inline void
+static void
 wset_start (struct window *w, Lisp_Object val)
 {
   w->start = val;
 }
-static inline void
+static void
 wset_temslot (struct window *w, Lisp_Object val)
 {
   w->temslot = val;
 }
-static inline void
+static void
 wset_vchild (struct window *w, Lisp_Object val)
 {
   w->vchild = val;
 }
-static inline void
+static void
 wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
 {
   w->vertical_scroll_bar_type = val;
 }
-static inline void
+static void
 wset_window_parameters (struct window *w, Lisp_Object val)
 {
   w->window_parameters = val;

=== modified file 'src/xdisp.c'
--- src/xdisp.c	2012-09-29 02:02:34 +0000
+++ src/xdisp.c	2012-09-30 07:00:20 +0000
@@ -367,22 +367,22 @@
 static Lisp_Object Qline_height;
 
 /* These setters are used only in this file, so they can be private.  */
-static inline void
+static void
 wset_base_line_number (struct window *w, Lisp_Object val)
 {
   w->base_line_number = val;
 }
-static inline void
+static void
 wset_base_line_pos (struct window *w, Lisp_Object val)
 {
   w->base_line_pos = val;
 }
-static inline void
+static void
 wset_column_number_displayed (struct window *w, Lisp_Object val)
 {
   w->column_number_displayed = val;
 }
-static inline void
+static void
 wset_region_showing (struct window *w, Lisp_Object val)
 {
   w->region_showing = val;
@@ -1191,7 +1191,7 @@
    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
    box.  */
 
-static inline void
+static void
 window_box_edges (struct window *w, int area, int *top_left_x, int *top_left_y,
 		   int *bottom_right_x, int *bottom_right_y)
 {
@@ -1278,7 +1278,7 @@
 /* Limit insanely large values of W->hscroll on frame F to the largest
    value that will still prevent first_visible_x and last_visible_x of
    'struct it' from overflowing an int.  */
-static inline int
+static int
 window_hscroll_limited (struct window *w, struct frame *f)
 {
   ptrdiff_t window_hscroll = w->hscroll;
@@ -1625,7 +1625,7 @@
    returns an invalid character.  If we find one, we return a `?', but
    with the length of the invalid character.  */
 
-static inline int
+static int
 string_char_and_length (const unsigned char *str, int *len)
 {
   int c;
@@ -1673,7 +1673,7 @@
 /* Value is the text position, i.e. character and byte position,
    for character position CHARPOS in STRING.  */
 
-static inline struct text_pos
+static struct text_pos
 string_pos (ptrdiff_t charpos, Lisp_Object string)
 {
   struct text_pos pos;
@@ -12577,7 +12577,7 @@
    buffer position, END is given as a distance from Z.  Used in
    redisplay_internal for display optimization.  */
 
-static inline int
+static int
 text_outside_line_unchanged_p (struct window *w,
 			       ptrdiff_t start, ptrdiff_t end)
 {
@@ -12838,7 +12838,7 @@
 /* Reconsider the setting of B->clip_changed which is displayed
    in window W.  */
 
-static inline void
+static void
 reconsider_clip_changes (struct window *w, struct buffer *b)
 {
   if (b->clip_changed
@@ -14538,7 +14538,7 @@
 
    We assume that the window's buffer is really current.  */
 
-static inline struct text_pos
+static struct text_pos
 run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
 {
   struct window *w = XWINDOW (window);
@@ -22491,7 +22491,7 @@
 /* Append the list of glyph strings with head H and tail T to the list
    with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
 
-static inline void
+static void
 append_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 			   struct glyph_string *h, struct glyph_string *t)
 {
@@ -22511,7 +22511,7 @@
    list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
    result.  */
 
-static inline void
+static void
 prepend_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 			    struct glyph_string *h, struct glyph_string *t)
 {
@@ -22530,7 +22530,7 @@
 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
    Set *HEAD and *TAIL to the resulting list.  */
 
-static inline void
+static void
 append_glyph_string (struct glyph_string **head, struct glyph_string **tail,
 		     struct glyph_string *s)
 {
@@ -22545,7 +22545,7 @@
    Value is a pointer to a realized face that is ready for display if
    DISPLAY_P is non-zero.  */
 
-static inline struct face *
+static struct face *
 get_char_face_and_encoding (struct frame *f, int c, int face_id,
 			    XChar2b *char2b, int display_p)
 {
@@ -22578,7 +22578,7 @@
    The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
    a pointer to a realized face that is ready for display.  */
 
-static inline struct face *
+static struct face *
 get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 			     XChar2b *char2b, int *two_byte_p)
 {
@@ -22615,7 +22615,7 @@
 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
    Return 1 if FONT has a glyph for C, otherwise return 0.  */
 
-static inline int
+static int
 get_char_glyph_code (int c, struct font *font, XChar2b *char2b)
 {
   unsigned code;
@@ -23089,7 +23089,7 @@
    first glyph following S.  LAST_X is the right-most x-position + 1
    in the drawing area.  */
 
-static inline void
+static void
 set_glyph_string_background_width (struct glyph_string *s, int start, int last_x)
 {
   /* If the face of this glyph string has to be drawn to the end of
@@ -23650,7 +23650,7 @@
 /* Store one glyph for IT->char_to_display in IT->glyph_row.
    Called from x_produce_glyphs when IT->glyph_row is non-null.  */
 
-static inline void
+static void
 append_glyph (struct it *it)
 {
   struct glyph *glyph;
@@ -23724,7 +23724,7 @@
    IT->glyph_row.  Called from x_produce_glyphs when IT->glyph_row is
    non-null.  */
 
-static inline void
+static void
 append_composite_glyph (struct it *it)
 {
   struct glyph *glyph;
@@ -23793,7 +23793,7 @@
 /* Change IT->ascent and IT->height according to the setting of
    IT->voffset.  */
 
-static inline void
+static void
 take_vertical_position_into_account (struct it *it)
 {
   if (it->voffset)

=== modified file 'src/xfaces.c'
--- src/xfaces.c	2012-09-24 21:38:23 +0000
+++ src/xfaces.c	2012-09-30 07:00:20 +0000
@@ -601,7 +601,7 @@
 /* Create and return a GC for use on frame F.  GC values and mask
    are given by XGCV and MASK.  */
 
-static inline GC
+static GC
 x_create_gc (struct frame *f, long unsigned int mask, XGCValues *xgcv)
 {
   GC gc;
@@ -615,7 +615,7 @@
 
 /* Free GC which was used on frame F.  */
 
-static inline void
+static void
 x_free_gc (struct frame *f, GC gc)
 {
   eassert (input_blocked_p ());
@@ -628,7 +628,7 @@
 #ifdef WINDOWSNT
 /* W32 emulation of GCs */
 
-static inline GC
+static GC
 x_create_gc (struct frame *f, unsigned long mask, XGCValues *xgcv)
 {
   GC gc;
@@ -642,7 +642,7 @@
 
 /* Free GC which was used on frame F.  */
 
-static inline void
+static void
 x_free_gc (struct frame *f, GC gc)
 {
   IF_DEBUG (eassert (--ngcs >= 0));
@@ -654,7 +654,7 @@
 #ifdef HAVE_NS
 /* NS emulation of GCs */
 
-static inline GC
+static GC
 x_create_gc (struct frame *f,
 	     unsigned long mask,
 	     XGCValues *xgcv)
@@ -664,7 +664,7 @@
   return gc;
 }
 
-static inline void
+static void
 x_free_gc (struct frame *f, GC gc)
 {
   xfree (gc);
@@ -677,7 +677,7 @@
    CHECK_LIVE_FRAME.  This is here because it's a frequent pattern in
    Lisp function definitions.  */
 
-static inline struct frame *
+static struct frame *
 frame_or_selected_frame (Lisp_Object frame, int nparam)
 {
   if (NILP (frame))
@@ -1920,7 +1920,7 @@
    FACE_NAME and NAMED_MERGE_POINT_KIND, as the head of the linked list
    pointed to by NAMED_MERGE_POINTS, and return 1.  */
 
-static inline int
+static int
 push_named_merge_point (struct named_merge_point *new_named_merge_point,
 			Lisp_Object face_name,
 			enum named_merge_point_kind named_merge_point_kind,
@@ -2004,7 +2004,7 @@
    face text properties; Ediff uses that).  If SIGNAL_P is non-zero,
    signal an error if FACE_NAME is not a valid face name.  If SIGNAL_P
    is zero, value is nil if FACE_NAME is not a valid face name.  */
-static inline Lisp_Object
+static Lisp_Object
 lface_from_face_name_no_resolve (struct frame *f, Lisp_Object face_name,
 				 int signal_p)
 {
@@ -2033,7 +2033,7 @@
    non-zero, signal an error if FACE_NAME is not a valid face name.
    If SIGNAL_P is zero, value is nil if FACE_NAME is not a valid face
    name.  */
-static inline Lisp_Object
+static Lisp_Object
 lface_from_face_name (struct frame *f, Lisp_Object face_name, int signal_p)
 {
   face_name = resolve_face_name (face_name, signal_p);
@@ -2047,7 +2047,7 @@
    is non-zero, signal an error if FACE_NAME does not name a face.
    Otherwise, value is zero if FACE_NAME is not a face.  */
 
-static inline int
+static int
 get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name,
 			       Lisp_Object *attrs, int signal_p)
 {
@@ -2069,7 +2069,7 @@
    non-zero, signal an error if FACE_NAME does not name a face.
    Otherwise, value is zero if FACE_NAME is not a face.  */
 
-static inline int
+static int
 get_lface_attributes (struct frame *f, Lisp_Object face_name,
 		      Lisp_Object *attrs, int signal_p,
 		      struct named_merge_point *named_merge_points)
@@ -2234,7 +2234,7 @@
    loops in face inheritance/remapping; it should be 0 when called from
    other places.  */
 
-static inline void
+static void
 merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
 		    struct named_merge_point *named_merge_points)
 {
@@ -3906,7 +3906,7 @@
    all attributes are `equal'.  Tries to be fast because this function
    is called quite often.  */
 
-static inline int
+static int
 face_attr_equal_p (Lisp_Object v1, Lisp_Object v2)
 {
   /* Type can differ, e.g. when one attribute is unspecified, i.e. nil,
@@ -3939,7 +3939,7 @@
    all attributes are `equal'.  Tries to be fast because this function
    is called quite often.  */
 
-static inline int
+static int
 lface_equal_p (Lisp_Object *v1, Lisp_Object *v2)
 {
   int i, equal_p = 1;
@@ -4024,7 +4024,7 @@
 /* Return a hash code for Lisp string STRING with case ignored.  Used
    below in computing a hash value for a Lisp face.  */
 
-static inline unsigned
+static unsigned
 hash_string_case_insensitive (Lisp_Object string)
 {
   const unsigned char *s;
@@ -4038,7 +4038,7 @@
 
 /* Return a hash code for face attribute vector V.  */
 
-static inline unsigned
+static unsigned
 lface_hash (Lisp_Object *v)
 {
   return (hash_string_case_insensitive (v[LFACE_FAMILY_INDEX])
@@ -4057,7 +4057,7 @@
    family, point size, weight, width, slant, and font.  Both
    LFACE1 and LFACE2 must be fully-specified.  */
 
-static inline int
+static int
 lface_same_font_attributes_p (Lisp_Object *lface1, Lisp_Object *lface2)
 {
   eassert (lface_fully_specified_p (lface1)
@@ -4453,7 +4453,7 @@
    Value is the ID of the face found.  If no suitable face is found,
    realize a new one.  */
 
-static inline int
+static int
 lookup_face (struct frame *f, Lisp_Object *attr)
 {
   struct face_cache *cache = FRAME_FACE_CACHE (f);

=== modified file 'src/xml.c'
--- src/xml.c	2012-09-23 09:16:57 +0000
+++ src/xml.c	2012-09-30 07:00:20 +0000
@@ -73,7 +73,7 @@
 #define fn_xmlCleanupParser     xmlCleanupParser
 #define fn_xmlCheckVersion      xmlCheckVersion
 
-static inline int
+static int
 libxml2_loaded_p (void)
 {
   return 1;

=== modified file 'src/xterm.c'
--- src/xterm.c	2012-09-24 21:38:23 +0000
+++ src/xterm.c	2012-09-30 07:00:20 +0000
@@ -1027,7 +1027,7 @@
    Faces to use in the mode line have already been computed when the
    matrix was built, so there isn't much to do, here.  */
 
-static inline void
+static void
 x_set_mode_line_face_gc (struct glyph_string *s)
 {
   s->gc = s->face->gc;
@@ -1038,7 +1038,7 @@
    S->stippled_p to a non-zero value if the face of S has a stipple
    pattern.  */
 
-static inline void
+static void
 x_set_glyph_string_gc (struct glyph_string *s)
 {
   PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
@@ -1083,7 +1083,7 @@
 /* Set clipping for output of glyph string S.  S may be part of a mode
    line or menu if we don't have X toolkit support.  */
 
-static inline void
+static void
 x_set_glyph_string_clipping (struct glyph_string *s)
 {
   XRectangle *r = s->clip;
@@ -1156,7 +1156,7 @@
 
 /* Fill rectangle X, Y, W, H with background color of glyph string S.  */
 
-static inline void
+static void
 x_clear_glyph_string_rect (struct glyph_string *s, int x, int y, int w, int h)
 {
   XGCValues xgcv;

Message #8 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Paul Eggert <eggert <at> cs.ucla.edu>
Cc: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 11:49:46 +0200

> Date: Sun, 30 Sep 2012 01:00:25 -0700
> From: Paul Eggert <eggert <at> cs.ucla.edu>
> 
> This one should be pretty self-explanatory.
> 
> === modified file 'src/ChangeLog'
> --- src/ChangeLog	2012-09-30 07:26:32 +0000
> +++ src/ChangeLog	2012-09-30 07:57:28 +0000
> @@ -1,3 +1,98 @@
> +2012-09-30  Paul Eggert  <eggert <at> cs.ucla.edu>
> +
> +	Prefer plain 'static' to 'static inline'.
> +	With static functions, modern compilers inline pretty well by
> +	themselves; advice from programmers often hurts as much as it helps.
> +	On my host (x86-64, Fedora 17, GCC 4.7.2, default 'configure'),
> +	this change shrinks the text size of the Emacs executable by 1.7%
> +	without affecting CPU significantly in my benchmark.

Since what version of GCC we can trust that static functions are
inlined?

The inline functions in bidi.c _must_ be inlined for performance
reasons.  If the only way to make sure they are is to make them
external, then so be it.

Message #11 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Jason Rumney <jasonr <at> gnu.org>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: Paul Eggert <eggert <at> cs.ucla.edu>, 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 22:18:48 +0800

Eli Zaretskii <eliz <at> gnu.org> writes:

> The inline functions in bidi.c _must_ be inlined for performance
> reasons.  If the only way to make sure they are is to make them
> external, then so be it.

The only way to ensure they are inlined is to make them macros. Modern
compilers treat "inline" as a hint, not an instruction, if they take any
notice of it at all.

Message #14 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Jason Rumney <jasonr <at> gnu.org>
Cc: eggert <at> cs.ucla.edu, 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 17:57:53 +0200

> From: Jason Rumney <jasonr <at> gnu.org>
> Cc: Paul Eggert <eggert <at> cs.ucla.edu>,  12541 <at> debbugs.gnu.org
> Date: Sun, 30 Sep 2012 22:18:48 +0800
> 
> Eli Zaretskii <eliz <at> gnu.org> writes:
> 
> > The inline functions in bidi.c _must_ be inlined for performance
> > reasons.  If the only way to make sure they are is to make them
> > external, then so be it.
> 
> The only way to ensure they are inlined is to make them macros. Modern
> compilers treat "inline" as a hint, not an instruction, if they take any
> notice of it at all.

In general, you are right.  But I would settle with getting the right
result in practice.  Surely, for GCC at least the information must be
there.

Message #17 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 10:58:57 -0700

On 09/30/2012 02:49 AM, Eli Zaretskii wrote:

> Since what version of GCC we can trust that static functions are
> inlined?

Since pretty long ago.  From the online documentation GCC has been
inlining functions not explicitly declared 'inline' since at least GCC
2.95.3, the oldest manual that's at gcc.gnu.org.  (The documentation
talks about C++ functions not C, but the underlying technology applies
to C too, and I'd be surprised if C differed.)

The exact set of functions that are inlined depends on the platform
and compiler options, as well as the compiler version.

> The inline functions in bidi.c _must_ be inlined for performance
> reasons.

Well, as Jason said, 'inline' is just advice and GCC doesn't always
inline them even now.  On my platform (GCC 4.7.2 -O3, x86-64, Fedora
17, trunk bzr 110287) GCC does not always inline 'bidi_char_at_pos':
in a couple of cases the function is only partly inlined.

With the proposed change, the set of functions that are not always
inlined expands to bidi_cache_iterator_state, bidi_char_at_pos, and
bidi_fetch_char, and (if we also include functions that are partially
inlined) bidi_cache_search and bidi_get_type.  This is all with the
same platform as before.

I don't offhand see how this would slow down Emacs significantly,
as these functions are fairly large.  Is there some benchmark I could
try out, to see the performance effects that are of concern here?

Message #20 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Paul Eggert <eggert <at> cs.ucla.edu>
Cc: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 20:33:04 +0200

> Date: Sun, 30 Sep 2012 10:58:57 -0700
> From: Paul Eggert <eggert <at> cs.ucla.edu>
> CC: 12541 <at> debbugs.gnu.org
> 
> On my platform (GCC 4.7.2 -O3, x86-64, Fedora 17, trunk bzr 110287)
> GCC does not always inline 'bidi_char_at_pos': in a couple of cases
> the function is only partly inlined.

Is this so with either 'static inline' or with 'static'?  More
generally, is there any difference, in terms of generated code, that
you see between using and not using 'inline' for these functions?

If you don't see any difference, I guess modern platforms are fast
enough to make non-inlined versions fast enough, or else people would
have complained long ago.

> With the proposed change, the set of functions that are not always
> inlined expands to bidi_cache_iterator_state, bidi_char_at_pos, and
> bidi_fetch_char, and (if we also include functions that are partially
> inlined) bidi_cache_search and bidi_get_type.

Were they also not inlined before the change?

> I don't offhand see how this would slow down Emacs significantly,
> as these functions are fairly large.

They are in the innermost loops of the display engine.  They are
called whenever the display engine needs to examine the next character
for display.

> Is there some benchmark I could try out, to see the performance
> effects that are of concern here?

My old benchmark was to run the reordering engine, as a stand-alone
program, on a large text file.  But that was long ago (10 years), so
perhaps my conclusions from those runs are no longer valid.

Message #23 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 11:48:15 -0700

On 09/30/2012 11:33 AM, Eli Zaretskii wrote:
>> From: Paul Eggert <eggert <at> cs.ucla.edu>
>>
>> On my platform (GCC 4.7.2 -O3, x86-64, Fedora 17, trunk bzr 110287)
>> GCC does not always inline 'bidi_char_at_pos': in a couple of cases
>> the function is only partly inlined.
> 
> Is this so with either 'static inline' or with 'static'?

The former.  That is, the above comment is talking about the current
trunk, which uses 'static inline'.

> is there any difference, in terms of generated code, that
> you see between using and not using 'inline' for these functions?

Yes, as described below, if we omit 'inline' GCC does less inlining:
it inlines the small static functions, but some of the larger ones are
not inlined.

>> With the proposed change, the set of functions that are not always
>> inlined expands to bidi_cache_iterator_state, bidi_char_at_pos, and
>> bidi_fetch_char, and (if we also include functions that are partially
>> inlined) bidi_cache_search and bidi_get_type.
> 
> Were they also not inlined before the change?

Most of these functions were inlined before the change.  However, as
described above, bidi_char_at_pos was only partially inlined before
the change.

Message #26 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Sun, 30 Sep 2012 23:38:31 -0700

For now, I installed everything in the patch
other than the bidi.c stuff.  I think the bidi.c
part should be OK too but am holding off on that
to give more time for comment.

Message #29 received at 12541 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Paul Eggert <eggert <at> cs.ucla.edu>
Cc: 12541 <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Mon, 01 Oct 2012 19:14:00 +0200

> Date: Sun, 30 Sep 2012 11:48:15 -0700
> From: Paul Eggert <eggert <at> cs.ucla.edu>
> CC: 12541 <at> debbugs.gnu.org
> 
> >> With the proposed change, the set of functions that are not always
> >> inlined expands to bidi_cache_iterator_state, bidi_char_at_pos, and
> >> bidi_fetch_char, and (if we also include functions that are partially
> >> inlined) bidi_cache_search and bidi_get_type.
> > 
> > Were they also not inlined before the change?
> 
> Most of these functions were inlined before the change.  However, as
> described above, bidi_char_at_pos was only partially inlined before
> the change.

It surprises me that bidi_char_at_pos is only partially inlined, or
not at all, since its body is just this:

  static inline int
  bidi_char_at_pos (ptrdiff_t bytepos, const unsigned char *s, bool unibyte)
  {
    if (s)
      {
	s += bytepos;
	if (unibyte)
	  return *s;
      }
    else
      s = BYTE_POS_ADDR (bytepos);
    return STRING_CHAR (s);
  }

Perhaps that's because STRING_CHAR could call a function?

Likewise with bidi_get_type.  This one was supposed to be as fast as
the C ctype macros, or close.  Handa-san told me that the uniprop
tables he implemented for this should really be fast.  Maybe again the
problem is that CHAR_TABLE_REF can call a function?

Anyway, it's disturbing that the functions you mention will no longer
be inlined, because they are at the lowest level of walking the buffer
and deciding what to do with the next character.  In particular,
bidi_get_type and bidi_fetch_char are invoked for every character we
display, even if there's no R2L characters anywhere in sight.  (By
contrast, bidi_cache_iterator_state and bidi_cache_search will only be
invoked if we bump into an R2L character.)

Nevertheless, I'm okay with removing the 'inline' qualifier from
bidi.c.  If the performance hit is significant, I'm sure we will hear
from users shortly.  Otherwise, I'll try to measure the performance
with and without 'inline' when I have time, and we can take it from
there.

Message #34 received at 12541-done <at> debbugs.gnu.org (full text, mbox):

From: Paul Eggert <eggert <at> cs.ucla.edu>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 12541-done <at> debbugs.gnu.org
Subject: Re: bug#12541: Prefer plain 'static' to 'static inline'.
Date: Tue, 02 Oct 2012 00:00:54 -0700

On 10/01/2012 10:14 AM, Eli Zaretskii wrote:
> Perhaps that's because STRING_CHAR could call a function?

Yes, I suspect that's it.  When there's enough register pressure it
can sometimes make sense to put a call inside a function rather than
inline it.

> Nevertheless, I'm okay with removing the 'inline' qualifier from
> bidi.c.  If the performance hit is significant, I'm sure we will hear
> from users shortly.  Otherwise, I'll try to measure the performance
> with and without 'inline' when I have time, and we can take it from
> there.

Thanks, I did that as trunk bzr 110345 and am marking this as done.

For what it's worth, the amount of inlining often depends greatly on
exactly which compiler flags are used -- with GCC, for example, it can
matter quite a bit whether one uses -O1, -O2, or -O3.

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.