[GR-20670] Fix linking of always-inline C API functions with -std=gnu90 (#1837, #1879).

eregon · eregon · commit 5e8700722500 · 2020-01-17T15:39:56.000Z
PullRequest: truffleruby/1271
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -74,6 +74,7 @@ Bug fixes:
 * Fixed type conversion for `Numeric#step` `step` parameter.
 * Fixed `Kernel#Integer` conversion.
 * Fixed `IO.try_convert` parameter conversion.
+* Fixed linking of always-inline C API functions with `-std=gnu90` (#1837, #1879).
 
 Compatibility:
 
diff --git a/lib/cext/include/ruby/ruby.h b/lib/cext/include/ruby/ruby.h
@@ -477,8 +477,16 @@ enum ruby_special_consts {
 #endif
 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
 
+#ifdef TRUFFLERUBY
+#define RB_NIL_P(value) ((int) polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "RB_NIL_P", value)))
 int RTEST(VALUE value);
 #define NIL_P(v) RB_NIL_P(v)
+#else
+#define RB_TEST(v) !(((VALUE)(v) & (VALUE)~RUBY_Qnil) == 0)
+#define RB_NIL_P(v) !((VALUE)(v) != RUBY_Qnil)
+#define RTEST(v) RB_TEST(v)
+#define NIL_P(v) RB_NIL_P(v)
+#endif
 
 #define CLASS_OF(v) rb_class_of((VALUE)(v))
 
@@ -550,19 +558,23 @@ enum ruby_value_type {
 int rb_type(VALUE value);
 #define TYPE(x) rb_type((VALUE)(x))
 
-/* Truffle: Simplify the RB_FLOAT_TYPE_P check based on our representation of Floats.
+#ifdef TRUFFLERUBY
+/* TruffleRuby: Simplify the RB_FLOAT_TYPE_P check based on our representation of Floats. */
+#define RB_FLOAT_TYPE_P(obj) (\
+	polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "RB_FLOAT_TYPE_P", rb_tr_unwrap(value))))
+#else
 #define RB_FLOAT_TYPE_P(obj) (\
 	RB_FLONUM_P(obj) || \
 	(!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == RUBY_T_FLOAT))
-*/
-MUST_INLINE int RB_FLOAT_TYPE_P(VALUE obj);
+#endif
 
 bool RB_TYPE_P(VALUE value, int type);
 
 #ifdef __GNUC__
 #define RB_GC_GUARD(v) \
     (*__extension__ ({ \
-	volatile VALUE *rb_gc_guarded_ptr = rb_tr_gc_guard(&v);   \
+	polyglot_invoke(RUBY_CEXT, "rb_tr_gc_guard", v); \
+	volatile VALUE *rb_gc_guarded_ptr = &v; \
 	rb_gc_guarded_ptr; \
     }))
 #elif defined _MSC_VER
@@ -586,13 +598,25 @@ void rb_check_type(VALUE,int);
 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
 
 VALUE rb_str_to_str(VALUE);
-MUST_INLINE VALUE rb_string_value(VALUE *value_pointer);
-MUST_INLINE char *rb_string_value_ptr(VALUE *value_pointer);
-MUST_INLINE char *rb_string_value_cstr(VALUE *value_pointer);
+#ifdef TRUFFLERUBY
+VALUE rb_string_value(VALUE *value_pointer);
+char *rb_string_value_ptr(VALUE *value_pointer);
+char *rb_string_value_cstr(VALUE *value_pointer);
+#else
+VALUE rb_string_value(volatile VALUE*);
+char *rb_string_value_ptr(volatile VALUE*);
+char *rb_string_value_cstr(volatile VALUE*);
+#endif
 
+#ifdef TRUFFLERUBY
+#define StringValue(v) rb_tr_string_value(&(v))
+#define StringValuePtr(v) rb_tr_string_value_ptr(&(v))
+#define StringValueCStr(v) rb_tr_string_value_cstr(&(v))
+#else
 #define StringValue(v) rb_string_value(&(v))
 #define StringValuePtr(v) rb_string_value_ptr(&(v))
 #define StringValueCStr(v) rb_string_value_cstr(&(v))
+#endif
 
 void rb_check_safe_obj(VALUE);
 #define SafeStringValue(v) do {\
@@ -1147,7 +1171,11 @@ struct rb_data_type_struct {
 struct RTypedData {
     struct RBasic basic;
     const rb_data_type_t *type;
+#ifdef TRUFFLERUBY
+    int typed_flag; /* 1 or not */
+#else
     VALUE typed_flag; /* 1 or not */
+#endif
     void *data;
 };
 
diff --git a/lib/cext/include/ruby/thread_native.h b/lib/cext/include/ruby/thread_native.h
@@ -47,10 +47,10 @@ RUBY_SYMBOL_EXPORT_BEGIN
 
 rb_nativethread_id_t rb_nativethread_self();
 
-MUST_INLINE int rb_nativethread_lock_initialize(rb_nativethread_lock_t *lock);
-MUST_INLINE int rb_nativethread_lock_destroy(rb_nativethread_lock_t *lock);
-MUST_INLINE int rb_nativethread_lock_lock(rb_nativethread_lock_t *lock);
-MUST_INLINE int rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock);
+void rb_nativethread_lock_initialize(rb_nativethread_lock_t *lock);
+void rb_nativethread_lock_destroy(rb_nativethread_lock_t *lock);
+void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock);
+void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock);
 
 RUBY_SYMBOL_EXPORT_END
 
diff --git a/lib/cext/include/truffleruby/truffleruby-pre.h b/lib/cext/include/truffleruby/truffleruby-pre.h
@@ -44,22 +44,12 @@ typedef VALUE ID;
 extern void* rb_tr_cext;
 #define RUBY_CEXT rb_tr_cext
 
-#define MUST_INLINE __attribute__((always_inline)) inline
-
 // Wrapping and unwrapping of values.
 
 extern void* (*rb_tr_unwrap)(VALUE obj);
 extern VALUE (*rb_tr_wrap)(void *obj);
 extern VALUE (*rb_tr_longwrap)(long obj);
 
-// Needed for GC guarding
-
-MUST_INLINE VALUE *rb_tr_gc_guard(VALUE *ptr) {
-  polyglot_invoke(RUBY_CEXT, "rb_tr_gc_guard", *ptr);
-  return ptr;
-}
-
-#define RB_NIL_P(value) ((int)polyglot_as_boolean(polyglot_invoke(rb_tr_cext, "RB_NIL_P", value)))
 
 #include <ruby/thread_native.h>
 
diff --git a/lib/cext/include/truffleruby/truffleruby.h b/lib/cext/include/truffleruby/truffleruby.h
@@ -90,8 +90,6 @@ if (polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "warning?"))) { \
 } \
 } while (0);
 
-MUST_INLINE int rb_tr_scan_args(int argc, VALUE *argv, const char *format, VALUE *v1, VALUE *v2, VALUE *v3, VALUE *v4, VALUE *v5, VALUE *v6, VALUE *v7, VALUE *v8, VALUE *v9, VALUE *v10);
-
 #define rb_tr_scan_args_1(ARGC, ARGV, FORMAT, V1) rb_tr_scan_args(ARGC, ARGV, FORMAT, V1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 #define rb_tr_scan_args_2(ARGC, ARGV, FORMAT, V1, V2) rb_tr_scan_args(ARGC, ARGV, FORMAT, V1, V2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 #define rb_tr_scan_args_3(ARGC, ARGV, FORMAT, V1, V2, V3) rb_tr_scan_args(ARGC, ARGV, FORMAT, V1, V2, V3, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
@@ -164,51 +162,31 @@ VALUE rb_ivar_lookup(VALUE object, const char *name, VALUE default_value);
 
 // Inline implementations
 
-MUST_INLINE int rb_nativethread_lock_initialize(rb_nativethread_lock_t *lock) {
-  *lock = RUBY_CEXT_INVOKE("rb_nativethread_lock_initialize");
-  return 0;
-}
-
-MUST_INLINE int rb_nativethread_lock_destroy(rb_nativethread_lock_t *lock) {
-  *lock = RUBY_CEXT_INVOKE("rb_nativethread_lock_destroy", *lock);
-  return 0;
-}
-
-MUST_INLINE int rb_nativethread_lock_lock(rb_nativethread_lock_t *lock) {
-  RUBY_INVOKE_NO_WRAP(*lock, "lock");
-  return 0;
-}
-
-MUST_INLINE int rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock) {
-  RUBY_INVOKE_NO_WRAP(*lock, "unlock");
-  return 0;
-}
-
-MUST_INLINE VALUE rb_string_value(VALUE *value_pointer) {
+ALWAYS_INLINE(static VALUE rb_tr_string_value(VALUE *value_pointer));
+static inline VALUE rb_tr_string_value(VALUE *value_pointer) {
   VALUE value = *value_pointer;
-
   if (!RB_TYPE_P(value, T_STRING)) {
     value = rb_str_to_str(value);
     *value_pointer = value;
   }
-
   return value;
 }
 
-MUST_INLINE char *rb_string_value_ptr(VALUE *value_pointer) {
+ALWAYS_INLINE(static char *rb_tr_string_value_ptr(VALUE *value_pointer));
+static inline char *rb_tr_string_value_ptr(VALUE *value_pointer) {
   VALUE string = rb_string_value(value_pointer);
   return RSTRING_PTR(string);
 }
 
-MUST_INLINE char *rb_string_value_cstr(VALUE *value_pointer) {
+ALWAYS_INLINE(static char *rb_tr_string_value_cstr(VALUE *value_pointer));
+static inline char *rb_tr_string_value_cstr(VALUE *value_pointer) {
   VALUE string = rb_string_value(value_pointer);
-
   RUBY_CEXT_INVOKE("rb_string_value_cstr_check", string);
-
   return RSTRING_PTR(string);
 }
 
-MUST_INLINE int rb_tr_scan_args(int argc, VALUE *argv, const char *format, VALUE *v1, VALUE *v2, VALUE *v3, VALUE *v4, VALUE *v5, VALUE *v6, VALUE *v7, VALUE *v8, VALUE *v9, VALUE *v10) {
+ALWAYS_INLINE(static int rb_tr_scan_args(int argc, VALUE *argv, const char *format, VALUE *v1, VALUE *v2, VALUE *v3, VALUE *v4, VALUE *v5, VALUE *v6, VALUE *v7, VALUE *v8, VALUE *v9, VALUE *v10));
+static inline int rb_tr_scan_args(int argc, VALUE *argv, const char *format, VALUE *v1, VALUE *v2, VALUE *v3, VALUE *v4, VALUE *v5, VALUE *v6, VALUE *v7, VALUE *v8, VALUE *v9, VALUE *v10) {
   // Parse the format string
 
   // TODO CS 7-Feb-17 maybe we could inline cache this part?
diff --git a/src/main/c/cext/ruby.c b/src/main/c/cext/ruby.c
@@ -419,10 +419,6 @@ int RB_FIXNUM_P(VALUE value) {
   return polyglot_as_boolean(RUBY_CEXT_INVOKE_NO_WRAP("RB_FIXNUM_P", value));
 }
 
-int RB_FLOAT_TYPE_P(VALUE value) {
-  return polyglot_as_boolean(RUBY_CEXT_INVOKE_NO_WRAP("RB_FLOAT_TYPE_P", value));
-}
-
 int RTEST(VALUE value) {
   return value != NULL && polyglot_as_boolean(RUBY_CEXT_INVOKE_NO_WRAP("RTEST", value));
 }
@@ -803,6 +799,18 @@ double rb_float_value(VALUE value) {
 
 // String
 
+VALUE rb_string_value(VALUE *value_pointer) {
+  return rb_tr_string_value(value_pointer);
+}
+
+char *rb_string_value_ptr(VALUE *value_pointer) {
+  return rb_tr_string_value_ptr(value_pointer);
+}
+
+char *rb_string_value_cstr(VALUE *value_pointer) {
+  return rb_tr_string_value_cstr(value_pointer);
+}
+
 char *RSTRING_PTR_IMPL(VALUE string) {
   return (char *)polyglot_as_i8_array(RUBY_CEXT_INVOKE_NO_WRAP("RSTRING_PTR", string));
 }
@@ -2637,6 +2645,22 @@ rb_nativethread_id_t rb_nativethread_self() {
   return RUBY_CEXT_INVOKE("rb_nativethread_self");
 }
 
+void rb_nativethread_lock_initialize(rb_nativethread_lock_t *lock) {
+  *lock = RUBY_CEXT_INVOKE("rb_nativethread_lock_initialize");
+}
+
+void rb_nativethread_lock_destroy(rb_nativethread_lock_t *lock) {
+  *lock = RUBY_CEXT_INVOKE("rb_nativethread_lock_destroy", *lock);
+}
+
+void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock) {
+  RUBY_INVOKE_NO_WRAP(*lock, "lock");
+}
+
+void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock) {
+  RUBY_INVOKE_NO_WRAP(*lock, "unlock");
+}
+
 // IO
 
 void rb_io_check_writable(rb_io_t *io) {
@@ -2794,7 +2818,6 @@ int rb_tr_writable(int mode) {
   return polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "rb_tr_writable", mode));
 }
 
-MUST_INLINE
 int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, int *fmode_p) {
   // TODO (pitr-ch 12-Jun-2017): review, just approximate implementation
   VALUE encoding = rb_cEncoding;
diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java
@@ -1426,7 +1426,6 @@ public abstract static class AddToMarkList extends CoreMethodArrayArgumentsNode
 
         @Specialization
         protected DynamicObject addToMarkList(Object markedObject,
-                @Cached BranchProfile exceptionProfile,
                 @Cached BranchProfile noExceptionProfile,
                 @Cached UnwrapNode.ToWrapperNode toWrapperNode) {
             ValueWrapper wrappedValue = toWrapperNode.execute(markedObject);
@@ -1440,16 +1439,13 @@ protected DynamicObject addToMarkList(Object markedObject,
             return nil();
         }
 
-        protected UnwrapNode createUnwrapNode() {
-            return UnwrapNodeGen.create();
-        }
     }
 
     @CoreMethod(names = "rb_tr_gc_guard", onSingleton = true, required = 1)
     public abstract static class GCGuardNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected DynamicObject addToMarkList(VirtualFrame frame, Object guardedObject,
+        protected DynamicObject addToMarkList(Object guardedObject,
                 @Cached MarkingServiceNodes.KeepAliveNode keepAliveNode,
                 @Cached BranchProfile noExceptionProfile,
                 @Cached UnwrapNode.ToWrapperNode toWrapperNode) {
@@ -1461,9 +1457,6 @@ protected DynamicObject addToMarkList(VirtualFrame frame, Object guardedObject,
             return nil();
         }
 
-        protected UnwrapNode createUnwrapNode() {
-            return UnwrapNodeGen.create();
-        }
     }
 
     @CoreMethod(names = "set_mark_list_on_object", onSingleton = true, required = 1)
