This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Don't combine instructions if they can't be copied
- From: Jie Zhang <jie at codesourcery dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Fri, 22 Oct 2010 11:14:04 +0800
- Subject: Don't combine instructions if they can't be copied
Compiling the test case in the attached patch using arm-linux-gnueabi
target g++ with the options "-O2 -fweb -fPIC -fvisibility=hidden" will
give an error:
Assembler messages:
Error: symbol `.LPIC0' is already defined
That's because an instruction, which can't be copied, is combined into
another instruction while that non-copyable instruction is still kept
since its result is needed later. GCC will generate the same label
".LPIC0" for that non-copyable instruction and the combined instruction
since the label number is also copied and same for both instructions.
With this patch, GCC will not combine instructions if they can't be
copied. Tested on arm-linux-gnueabi with c,c++,lto. No regressions are
found.
Is it OK?
Regards,
--
Jie Zhang
CodeSourcery
* combine.c (try_combine): Don't combine if can't copy
instructions.
testsuite/
g++.dg/opt/combine.c: New test.
Index: testsuite/g++.dg/opt/combine.C
===================================================================
--- testsuite/g++.dg/opt/combine.C (revision 0)
+++ testsuite/g++.dg/opt/combine.C (revision 0)
@@ -0,0 +1,72 @@
+// { dg-do assemble { target fpic } }
+// { dg-options "-O2 -fweb -fPIC -fvisibility=hidden" }
+
+class QBasicAtomicInt
+{
+public:
+ volatile int _q_value;
+ inline operator int () const {return _q_value;}
+};
+class QVariant;
+class QScriptContext;
+class QScriptEngine;
+class QScriptValue
+{
+public:
+ QVariant toVariant () const;
+};
+class QScriptDebuggerBackendPrivate
+{
+ static QScriptValue trace (QScriptContext *context);
+};
+template <typename T> struct QMetaTypeId { };
+template <typename T> struct QMetaTypeId2
+{
+ static inline int qt_metatype_id ()
+ {
+ return QMetaTypeId<T>::qt_metatype_id () ;
+ }
+};
+template <typename T> inline int qMetaTypeId (T * = 0)
+{
+ return QMetaTypeId2<T>::qt_metatype_id () ;
+}
+class QVariant { };
+template<typename T> inline T qvariant_cast (const QVariant &v)
+{
+ const int vid = qMetaTypeId<T> ((0)) ;
+};
+class QScriptContext
+{
+public:
+ QScriptValue callee () const;
+};
+class QScriptEngine
+{
+public:
+ static bool convertV2 (const QScriptValue &value , int type , void *ptr) ;
+};
+inline bool qscriptvalue_cast_helper (const QScriptValue &value , int type , void *ptr)
+{
+ return QScriptEngine::convertV2 (value, type, ptr) ;
+}
+template<typename T> T qscriptvalue_cast (const QScriptValue &value)
+{
+ T t;
+ const int id = qMetaTypeId<T> () ;
+ if ( qscriptvalue_cast_helper (value, id, &t))
+ return qvariant_cast<T> (value.toVariant ()) ;
+}
+template <> struct QMetaTypeId< QScriptDebuggerBackendPrivate* >
+{
+ static int qt_metatype_id ()
+ {
+ static QBasicAtomicInt metatype_id = { (0) };
+ return metatype_id;
+ }
+};
+QScriptValue QScriptDebuggerBackendPrivate::trace (QScriptContext *context)
+{
+ QScriptValue data = context->callee () ;
+ QScriptDebuggerBackendPrivate *self = qscriptvalue_cast<QScriptDebuggerBackendPrivate*> (data) ;
+}
Index: combine.c
===================================================================
--- combine.c (revision 165798)
+++ combine.c (working copy)
@@ -2917,6 +2917,15 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx
else
added_sets_0 = 0;
+ if (targetm.cannot_copy_insn_p
+ && ((added_sets_2 && targetm.cannot_copy_insn_p (i2))
+ || (i1 && added_sets_1 && targetm.cannot_copy_insn_p (i1))
+ || (i0 && added_sets_0 && targetm.cannot_copy_insn_p (i0))))
+ {
+ undo_all ();
+ return 0;
+ }
+
/* If the set in I2 needs to be kept around, we must make a copy of
PATTERN (I2), so that when we substitute I1SRC for I1DEST in
PATTERN (I2), we are only substituting for the original I1DEST, not into