if (outmode == VOIDmode && out != 0)
outmode = GET_MODE (out);
- /* If IN is a pseudo register everywhere-equivalent to a constant, and
- it is not in a hard register, reload straight from the constant,
- since we want to get rid of such pseudo registers.
- Often this is done earlier, but not always in find_reloads_address. */
+ /* If find_reloads and friends until now missed to replace a pseudo
+ with a constant of reg_equiv_constant something went wrong
+ beforehand.
+ Note that it can't simply be done here if we missed it earlier
+ since the constant might need to be pushed into the literal pool
+ and the resulting memref would probably need further
+ reloading. */
if (in != 0 && REG_P (in))
{
int regno = REGNO (in);
- if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
- && reg_equiv_constant[regno] != 0)
- in = reg_equiv_constant[regno];
+ gcc_assert (regno < FIRST_PSEUDO_REGISTER
+ || reg_renumber[regno] >= 0
+ || reg_equiv_constant[regno] == NULL_RTX);
}
- /* Likewise for OUT. Of course, OUT will never be equivalent to
- an actual constant, but it might be equivalent to a memory location
- (in the case of a parameter). */
+ /* reg_equiv_constant only contains constants which are obviously
+ not appropriate as destination. So if we would need to replace
+ the destination pseudo with a constant we are in real
+ trouble. */
if (out != 0 && REG_P (out))
{
int regno = REGNO (out);
- if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
- && reg_equiv_constant[regno] != 0)
- out = reg_equiv_constant[regno];
+ gcc_assert (regno < FIRST_PSEUDO_REGISTER
+ || reg_renumber[regno] >= 0
+ || reg_equiv_constant[regno] == NULL_RTX);
}
/* If we have a read-write operand with an address side-effect,
{
regno = REGNO (ad);
- /* If the register is equivalent to an invariant expression, substitute
- the invariant, and eliminate any eliminable register references. */
- tem = reg_equiv_constant[regno];
- if (tem != 0
- && (tem = eliminate_regs (tem, mode, insn))
- && strict_memory_address_p (mode, tem))
+ if (reg_equiv_constant[regno] != 0)
{
- *loc = ad = tem;
- return 0;
+ find_reloads_address_part (reg_equiv_constant[regno], loc,
+ base_reg_class (mode, MEM, SCRATCH),
+ GET_MODE (ad), opnum, type, ind_levels);
+ return 1;
}
tem = reg_equiv_memory_loc[regno];
--- /dev/null
+// { dg-require-effective-target fpic }
+// { dg-options "-fPIC" }
+// { dg-do compile }
+
+
+typedef long unsigned int size_t;
+extern "C" void *
+malloc (size_t __size)
+throw () __attribute__ ((__malloc__));
+ namespace std __attribute__ ((__visibility__ ("default")))
+{
+ using::size_t;
+}
+inline void *operator
+new (std::size_t, void *__p)
+throw ()
+{
+ return __p;
+}
+template < class _T1, class _T2 > struct pair
+{
+ _T1 first;
+ _T2 second;
+ pair (const _T1 & __a, const _T2 & __b):first (__a), second (__b)
+ {
+ }
+ template < class _U1, class _U2 >
+ pair (const pair < _U1, _U2 > &__p):first (__p.first), second (__p.second)
+ {
+ }
+};
+
+template < class _T1, class _T2 >
+ inline pair < _T1, _T2 > make_pair (_T1 __x, _T2 __y)
+{
+ return pair < _T1, _T2 > (__x, __y);
+}
+template < typename _Tp > inline const _Tp &
+max (const _Tp & __a, const _Tp & __b)
+{
+}
+typedef unsigned short int uint16_t;
+typedef unsigned long int uintptr_t;
+typedef uint16_t UChar;
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+ struct __numeric_limits_base
+ {
+ };
+ template < typename _Tp > struct numeric_limits:public __numeric_limits_base
+ {
+ static _Tp max () throw ()
+ {
+ }
+ };
+}
+
+template < typename T > class VectorBufferBase
+{
+public:
+ void allocateBuffer (size_t newCapacity)
+ {
+ if (newCapacity > std::numeric_limits < size_t >::max () / sizeof (T))
+ *(int *) (uintptr_t) 0xbbadbeef = 0;
+ }
+};
+
+template < typename T, size_t inlineCapacity > class VectorBuffer;
+template < typename T > class VectorBuffer < T, 0 >:private VectorBufferBase <
+ T >
+{
+ typedef VectorBufferBase < T > Base;
+ using Base::allocateBuffer;
+};
+
+template < typename T, size_t inlineCapacity = 0 > class Vector
+{
+ typedef VectorBuffer < T, inlineCapacity > Impl;
+public:
+ typedef T *iterator;
+ size_t size () const
+ {
+ return m_size;
+ }
+ size_t capacity () const
+ {
+ }
+ iterator begin ()
+ {
+ }
+ iterator end ()
+ {
+ return begin () + m_size;
+ }
+ void shrink (size_t size);
+ void reserveCapacity (size_t newCapacity);
+ void clear ()
+ {
+ shrink (0);
+ }
+ template < typename U > void append (const U &);
+ void expandCapacity (size_t newMinCapacity);
+ template < typename U > U * expandCapacity (size_t newMinCapacity, U *);
+ size_t m_size;
+ Impl m_impl;
+};
+template < typename T, size_t inlineCapacity >
+ void Vector < T, inlineCapacity >::expandCapacity (size_t newMinCapacity)
+{
+ reserveCapacity (max
+ (newMinCapacity,
+ max (static_cast < size_t > (16),
+ capacity () + capacity () / 4 + 1)));
+}
+
+template < typename T, size_t inlineCapacity >
+ template < typename U >
+ inline U * Vector < T,
+ inlineCapacity >::expandCapacity (size_t newMinCapacity, U * ptr)
+{
+ expandCapacity (newMinCapacity);
+}
+template < typename T, size_t inlineCapacity >
+ void Vector < T, inlineCapacity >::reserveCapacity (size_t newCapacity)
+{
+ m_impl.allocateBuffer (newCapacity);
+}
+template < typename T, size_t inlineCapacity >
+ template < typename U >
+ inline void Vector < T, inlineCapacity >::append (const U & val)
+{
+ const U *ptr = &val;
+ if (size () == capacity ())
+ ptr = expandCapacity (size () + 1, ptr);
+ new (end ())T (*ptr);
+}
+
+class Range;
+class TextIterator
+{
+public:
+ explicit TextIterator (const Range *,
+ bool emitCharactersBetweenAllVisiblePositions =
+ false);
+ bool atEnd () const
+ {
+ }
+ void advance ();
+ int length () const
+ {
+ }
+};
+UChar *
+plainTextToMallocAllocatedBuffer (const Range * r, unsigned &bufferLength)
+{
+ static const unsigned cMaxSegmentSize = 1 << 16;
+ typedef pair < UChar *, unsigned >TextSegment;
+ Vector < TextSegment > *textSegments = 0;
+ Vector < UChar > textBuffer;
+ for (TextIterator it (r); !it.atEnd (); it.advance ())
+ {
+ if (textBuffer.size ()
+ && textBuffer.size () + it.length () > cMaxSegmentSize)
+ {
+ UChar *newSegmentBuffer =
+ static_cast <
+ UChar * >(malloc (textBuffer.size () * sizeof (UChar)));
+ if (!textSegments)
+ textSegments = new Vector < TextSegment >;
+ textSegments->
+ append (make_pair (newSegmentBuffer, textBuffer.size ()));
+ textBuffer.clear ();
+ }
+ }
+}
projects / platform / upstream / linaro-gcc.git / commitdiff