===================================================================
@@ -5627,28 +5627,59 @@ objc_build_throw_stmt (location_t loc, t
}
tree
-objc_build_synchronized (location_t start_locus, tree mutex, tree body)
+objc_build_synchronized (location_t start_locus, tree object_expr,
tree body)
{
- tree args, call;
+ /* object_expr should never be NULL; but in case it is, convert it to
+ error_mark_node. */
+ if (object_expr == NULL)
+ object_expr = error_mark_node;
- /* First lock the mutex. */
- mutex = save_expr (mutex);
- args = tree_cons (NULL, mutex, NULL);
- call = build_function_call (input_location,
- objc_sync_enter_decl, args);
- SET_EXPR_LOCATION (call, start_locus);
- add_stmt (call);
-
- /* Build the mutex unlock. */
- args = tree_cons (NULL, mutex, NULL);
- call = build_function_call (input_location,
- objc_sync_exit_decl, args);
- SET_EXPR_LOCATION (call, input_location);
-
- /* Put the that and the body in a TRY_FINALLY. */
- objc_begin_try_stmt (start_locus, body);
- objc_build_finally_clause (input_location, call);
- return objc_finish_try_stmt ();
+ /* Validate object_expr. If not valid, set it to error_mark_node.
*/
+ if (object_expr != error_mark_node)
+ {
+ if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr),
true))
+ {
+ error_at (start_locus, "%<@synchronized%> argument is not an
object");
+ object_expr = error_mark_node;
+ }
+ }
+
+ if (object_expr == error_mark_node)
+ {
+ /* If we found an error, we simply ignore the '@synchronized'.
+ Compile the body so we can keep going with minimal
+ casualties. */
+ return add_stmt (body);
+ }
+ else
+ {
+ tree call;
+ tree args;
+
+ /* objc_sync_enter (object_expr); */
+ object_expr = save_expr (object_expr);
+ args = tree_cons (NULL, object_expr, NULL);
+ call = build_function_call (input_location,
+ objc_sync_enter_decl, args);
+ SET_EXPR_LOCATION (call, start_locus);
+ add_stmt (call);
+
+ /* Build "objc_sync_exit (object_expr);" but do not add it yet;
+ it goes inside the @finalize() clause. */
+ args = tree_cons (NULL, object_expr, NULL);
+ call = build_function_call (input_location,
+ objc_sync_exit_decl, args);
+ SET_EXPR_LOCATION (call, input_location);
+
+ /* @try { body; } */
+ objc_begin_try_stmt (start_locus, body);
+
+ /* @finally { objc_sync_exit (object_expr); } */
+ objc_build_finally_clause (input_location, call);
+
+ /* End of try statement. */
+ return objc_finish_try_stmt ();
+ }
}
^L
===================================================================
@@ -1,3 +1,11 @@
+2010-12-29 Nicola Pero <nicola.pero@meta-innovation.com>
+
+ PR objc/47118
+ * objc-act.c (objc_build_synchronized): Check the argument of
+ @synchronized and emit an appropriate error if it is not a valid
+ Objective-C object. Deal gracefully with that case. Updated
+ comments and variable names.
+
2010-12-28 Nicola Pero <nicola.pero@meta-innovation.com>
PR objc/47076
===================================================================
@@ -1,3 +1,9 @@
+2010-12-29 Nicola Pero <nicola.pero@meta-innovation.com>
+
+ PR objc/47118
+ * objc.dg/sync-3.m: New.
+ * obj-c++.dg/sync-3.mm: New.
+
2010-12-28 Jason Merrill <jason@redhat.com>
PR c++/47068
===================================================================
@@ -0,0 +1,128 @@
+/* Contributed by Nicola Pero <nicola.pero@meta-innovation.com>,
December 2010. */
+/* { dg-options "-fobjc-exceptions" } */
+/* { dg-do compile } */
+
+/* Test that the compiler is checking the argument of @synchronized(),
+ and produce errors when invalid types are used. */
+
+#include <objc/objc.h>
+
+@interface MyObject
+{
+ Class isa;
+}
+@end
+
+@implementation MyObject
+@end
+
+@protocol MyProtocol;
+
+typedef MyObject MyObjectTypedef;
+typedef MyObject *MyObjectPtrTypedef;
+typedef int intTypedef;
+
+typedef struct { float x; float y; } point, *point_ptr;
+
+int test (id object)
+{
+ int dummy = 0;
+
+ {
+ int x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ intTypedef x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ int *x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ point x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ point_ptr x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ id x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ id <MyProtocol> x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObject *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObject <MyProtocol> *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ static MyObject *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectTypedef *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectTypedef <MyProtocol> *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectPtrTypedef x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ Class x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ @synchronized (1) /* { dg-error ".@synchronized. argument is not an
object" } */
+ { dummy++; }
+
+ @synchronized ("Test") /* { dg-error ".@synchronized. argument is
not an object" } */
+ { dummy++; }
+
+ @synchronized () /* { dg-error "expected expression" } */
+ { dummy++; }
+
+ @synchronized (int) /* { dg-error "expected expression" } */
+ { dummy++; }
+
+ return dummy;
+}
===================================================================
@@ -0,0 +1,128 @@
+/* Contributed by Nicola Pero <nicola.pero@meta-innovation.com>,
December 2010. */
+/* { dg-options "-fobjc-exceptions" } */
+/* { dg-do compile } */
+
+/* Test that the compiler is checking the argument of @synchronized(),
+ and produce errors when invalid types are used. */
+
+#include <objc/objc.h>
+
+@interface MyObject
+{
+ Class isa;
+}
+@end
+
+@implementation MyObject
+@end
+
+@protocol MyProtocol;
+
+typedef MyObject MyObjectTypedef;
+typedef MyObject *MyObjectPtrTypedef;
+typedef int intTypedef;
+
+typedef struct { float x; float y; } point, *point_ptr;
+
+int test (id object)
+{
+ int dummy = 0;
+
+ {
+ int x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ intTypedef x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ int *x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ point x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ point_ptr x;
+ @synchronized (x) /* { dg-error ".@synchronized. argument is not
an object" } */
+ { dummy++; }
+ }
+
+ {
+ id x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ id <MyProtocol> x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObject *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObject <MyProtocol> *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ static MyObject *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectTypedef *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectTypedef <MyProtocol> *x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ MyObjectPtrTypedef x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ {
+ Class x;
+ @synchronized (x) /* Ok */
+ { dummy++; }
+ }
+
+ @synchronized (1) /* { dg-error ".@synchronized. argument is not an
object" } */
+ { dummy++; }
+
+ @synchronized ("Test") /* { dg-error ".@synchronized. argument is
not an object" } */
+ { dummy++; }
+
This patch fixes PR objc/47118. The problem occurs when use @synchronized() with an invalid argument that is not an Objective-C object. GCC from trunk wasn't properly checking and sanitizing the argument; moreover, some invalid arguments would confuse it to the point of crashing. This patch adds the checks, prints a nice error message if the argument is invalid, and deals with errors gracefully. A full testcase is included, testing lots of cases. Ok to commit ? Thanks + @synchronized () /* { dg-error "expected" } */ + { dummy++; } + + @synchronized (int) /* { dg-error "expected" } */ + { dummy++; } + + return dummy; +}