Re: Multiple translation unit regression

[Christopher Li <sparse@chrisli.org>]

[-- Attachment #1: Type: text/plain, Size: 927 bytes --]

On Fri, Jul 10, 2009 at 1:53 PM, Ramsay Jones<ramsay@ramsay1.demon.co.uk> wrote:
>    11  extern int g(int);
>    12
>    13  extern __inline__ int
>    14  g(int x)
>    15  {
>    16          return x;
>    17  }
>    18

Err, that is ugly. I just find out what happen there.
The none inline version picks up the function definition
from the inline version because they are both "extern".
Sparse only has one global extern scope.

Later even the inline version get remove from the
filescope, the second file still conflict with the non-inline
version of the function body, which steal from the inline
version.

I add two lines to distinguish the "extern inline" vs "extern".
They are not the same_symbol any more. Because effectly
the "extern inline" is not visiable in the global "extern" scope.
Any one see problem using this approach?

I attach the patch follows. Can you give it a try?

Chris

[-- Attachment #2: extern-inline-1 --]
[-- Type: application/octet-stream, Size: 2942 bytes --]

move extern inline function to file scope

In gcc extern inline function has special meaning. The inline
function will never emit stand alone copy of the function. It also
allow multiple implementations cross different file. That effectively
makes the extern inline has file scope.

Index: sparse.chrisl/symbol.h
===================================================================
--- sparse.chrisl.orig/symbol.h
+++ sparse.chrisl/symbol.h
@@ -340,6 +340,18 @@ static inline int is_void_type(struct sy
 	return type == &void_ctype;
 }
 
+static inline int is_function(struct symbol *type)
+{
+	return type && type->type == SYM_FN;
+}
+
+static inline int is_extern_inline(struct symbol *sym)
+{
+	return (sym->ctype.modifiers & MOD_EXTERN) &&
+		(sym->ctype.modifiers & MOD_INLINE) &&
+		is_function(sym->ctype.base_type);
+}
+
 static inline int get_sym_type(struct symbol *type)
 {
 	if (type->type == SYM_NODE)
Index: sparse.chrisl/evaluate.c
===================================================================
--- sparse.chrisl.orig/evaluate.c
+++ sparse.chrisl/evaluate.c
@@ -536,11 +536,6 @@ static inline int lvalue_expression(stru
 	return expr->type == EXPR_PREOP && expr->op == '*';
 }
 
-static inline int is_function(struct symbol *type)
-{
-	return type && type->type == SYM_FN;
-}
-
 static struct symbol *evaluate_ptr_add(struct expression *expr, struct symbol *itype)
 {
 	struct expression *index = expr->right;
Index: sparse.chrisl/symbol.c
===================================================================
--- sparse.chrisl.orig/symbol.c
+++ sparse.chrisl/symbol.c
@@ -522,6 +522,8 @@ void check_declaration(struct symbol *sy
 			return;
 		}
 		if (sym->ctype.modifiers & next->ctype.modifiers & MOD_EXTERN) {
+			if ((sym->ctype.modifiers ^ next->ctype.modifiers) & MOD_INLINE)
+				continue;
 			sym->same_symbol = next;
 			return;
 		}
@@ -558,8 +560,10 @@ void bind_symbol(struct symbol *sym, str
 	scope = block_scope;
 	if (ns == NS_SYMBOL && toplevel(scope)) {
 		unsigned mod = MOD_ADDRESSABLE | MOD_TOPLEVEL;
+
 		scope = global_scope;
-		if (sym->ctype.modifiers & MOD_STATIC) {
+		if (sym->ctype.modifiers & MOD_STATIC ||
+		    is_extern_inline(sym)) {
 			scope = file_scope;
 			mod = MOD_TOPLEVEL;
 		}
Index: sparse.chrisl/scope.c
===================================================================
Index: sparse.chrisl/validation/extern-inline.c
===================================================================
--- sparse.chrisl.orig/validation/extern-inline.c
+++ sparse.chrisl/validation/extern-inline.c
@@ -0,0 +1,22 @@
+extern __inline__ int f(int);
+
+extern __inline__ int
+f(int x)
+{
+        return x;
+}
+
+extern int g(int);
+
+extern __inline__ int
+g(int x)
+{
+        return x;
+}
+
+
+/*
+ * check-name: extern inline function
+ * check-description: Extern inline function never emits stand alone copy
+ * of the function. It allows multiple such definitions in different file.
+ */