OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [rtlhooks.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Generic hooks for the RTL middle-end.
2
   Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3
 
4
This file is part of GCC.
5
 
6
GCC is free software; you can redistribute it and/or modify it under
7
the terms of the GNU General Public License as published by the Free
8
Software Foundation; either version 3, or (at your option) any later
9
version.
10
 
11
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12
WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GCC; see the file COPYING3.  If not see
18
<http://www.gnu.org/licenses/>.  */
19
 
20
#include "config.h"
21
#include "system.h"
22
#include "coretypes.h"
23
#include "tm.h"
24
#include "rtl.h"
25
#include "rtlhooks-def.h"
26
#include "expr.h"
27
#include "recog.h"
28
 
29
 
30
/* For speed, we will copy the RTX hooks struct member-by-member
31
   instead of doing indirect calls.  For these reason, we initialize
32
   *two* struct rtl_hooks globals: rtl_hooks is the one that is used
33
   to actually call the hooks, while general_rtl_hooks is used
34
   to restore the hooks by passes that modify them.  */
35
 
36
const struct rtl_hooks general_rtl_hooks = RTL_HOOKS_INITIALIZER;
37
struct rtl_hooks rtl_hooks = RTL_HOOKS_INITIALIZER;
38
 
39
rtx
40
gen_lowpart_general (enum machine_mode mode, rtx x)
41
{
42
  rtx result = gen_lowpart_common (mode, x);
43
 
44
  if (result)
45
    return result;
46
  /* Handle SUBREGs and hard REGs that were rejected by
47
     simplify_gen_subreg.  */
48
  else if (REG_P (x) || GET_CODE (x) == SUBREG)
49
    {
50
      result = gen_lowpart_common (mode, copy_to_reg (x));
51
      gcc_assert (result != 0);
52
      return result;
53
    }
54
  else
55
    {
56
      int offset = 0;
57
 
58
      /* The only additional case we can do is MEM.  */
59
      gcc_assert (MEM_P (x));
60
 
61
      /* The following exposes the use of "x" to CSE.  */
62
      if (GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
63
          && SCALAR_INT_MODE_P (GET_MODE (x))
64
          && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
65
                                    GET_MODE_BITSIZE (GET_MODE (x)))
66
          && !reload_completed)
67
        return gen_lowpart_general (mode, force_reg (GET_MODE (x), x));
68
 
69
      if (WORDS_BIG_ENDIAN)
70
        offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
71
                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
72
 
73
      if (BYTES_BIG_ENDIAN)
74
        /* Adjust the address so that the address-after-the-data
75
           is unchanged.  */
76
        offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
77
                   - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
78
 
79
      return adjust_address (x, mode, offset);
80
    }
81
}
82
 
83
/* Similar to gen_lowpart, but cannot emit any instruction via
84
   copy_to_reg or force_reg.  Mainly used in simplify-rtx.c.  */
85
rtx
86
gen_lowpart_no_emit_general (enum machine_mode mode, rtx x)
87
{
88
  rtx result = gen_lowpart_if_possible (mode, x);
89
  if (result)
90
    return result;
91
  else
92
    return x;
93
}
94
 
95
rtx
96
reg_num_sign_bit_copies_general (const_rtx x ATTRIBUTE_UNUSED,
97
                                 enum machine_mode mode ATTRIBUTE_UNUSED,
98
                                 const_rtx known_x ATTRIBUTE_UNUSED,
99
                                 enum machine_mode known_mode ATTRIBUTE_UNUSED,
100
                                 unsigned int known_ret ATTRIBUTE_UNUSED,
101
                                 unsigned int *result ATTRIBUTE_UNUSED)
102
{
103
  return NULL;
104
}
105
 
106
rtx
107
reg_nonzero_bits_general (const_rtx x ATTRIBUTE_UNUSED,
108
                          enum machine_mode mode ATTRIBUTE_UNUSED,
109
                          const_rtx known_x ATTRIBUTE_UNUSED,
110
                          enum machine_mode known_mode ATTRIBUTE_UNUSED,
111
                          unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
112
                          unsigned HOST_WIDE_INT *nonzero ATTRIBUTE_UNUSED)
113
{
114
  return NULL;
115
}
116
 
117
bool
118
reg_truncated_to_mode_general (enum machine_mode mode ATTRIBUTE_UNUSED,
119
                               const_rtx x ATTRIBUTE_UNUSED)
120
{
121
  return false;
122
}
123
 
124
/* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a fixed-point
125
   number, return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
126
   least-significant part of X.
127
   MODE specifies how big a part of X to return.
128
 
129
   If the requested operation cannot be done, 0 is returned.
130
 
131
   This is similar to gen_lowpart_general.  */
132
 
133
rtx
134
gen_lowpart_if_possible (enum machine_mode mode, rtx x)
135
{
136
  rtx result = gen_lowpart_common (mode, x);
137
 
138
  if (result)
139
    return result;
140
  else if (MEM_P (x))
141
    {
142
      /* This is the only other case we handle.  */
143
      int offset = 0;
144
      rtx new_rtx;
145
 
146
      if (WORDS_BIG_ENDIAN)
147
        offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
148
                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
149
      if (BYTES_BIG_ENDIAN)
150
        /* Adjust the address so that the address-after-the-data is
151
           unchanged.  */
152
        offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
153
                   - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
154
 
155
      new_rtx = adjust_address_nv (x, mode, offset);
156
      if (! memory_address_addr_space_p (mode, XEXP (new_rtx, 0),
157
                                         MEM_ADDR_SPACE (x)))
158
        return 0;
159
 
160
      return new_rtx;
161
    }
162
  else if (mode != GET_MODE (x) && GET_MODE (x) != VOIDmode
163
           && validate_subreg (mode, GET_MODE (x), x,
164
                                subreg_lowpart_offset (mode, GET_MODE (x))))
165
    return gen_lowpart_SUBREG (mode, x);
166
  else
167
    return 0;
168
}
169
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.