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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [rtlhooks.c] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Generic hooks for the RTL middle-end.
2
   Copyright (C) 2004, 2005, 2007 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
  /* If it's a REG, it must be a hard reg that's not valid in MODE.  */
47
  else if (REG_P (x)
48
           /* Or we could have a subreg of a floating point value.  */
49
           || (GET_CODE (x) == SUBREG
50
               && FLOAT_MODE_P (GET_MODE (SUBREG_REG (x)))))
51
    {
52
      result = gen_lowpart_common (mode, copy_to_reg (x));
53
      gcc_assert (result != 0);
54
      return result;
55
    }
56
  else
57
    {
58
      int offset = 0;
59
 
60
      /* The only additional case we can do is MEM.  */
61
      gcc_assert (MEM_P (x));
62
 
63
      /* The following exposes the use of "x" to CSE.  */
64
      if (GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
65
          && SCALAR_INT_MODE_P (GET_MODE (x))
66
          && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
67
                                    GET_MODE_BITSIZE (GET_MODE (x)))
68
          && ! no_new_pseudos)
69
        return gen_lowpart_general (mode, force_reg (GET_MODE (x), x));
70
 
71
      if (WORDS_BIG_ENDIAN)
72
        offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
73
                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
74
 
75
      if (BYTES_BIG_ENDIAN)
76
        /* Adjust the address so that the address-after-the-data
77
           is unchanged.  */
78
        offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
79
                   - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
80
 
81
      return adjust_address (x, mode, offset);
82
    }
83
}
84
 
85
/* Similar to gen_lowpart, but cannot emit any instruction via
86
   copy_to_reg or force_reg.  Mainly used in simplify-rtx.c.  */
87
rtx
88
gen_lowpart_no_emit_general (enum machine_mode mode, rtx x)
89
{
90
  rtx result = gen_lowpart_if_possible (mode, x);
91
  if (result)
92
    return result;
93
  else
94
    return x;
95
}
96
 
97
rtx
98
reg_num_sign_bit_copies_general (rtx x ATTRIBUTE_UNUSED,
99
                                 enum machine_mode mode ATTRIBUTE_UNUSED,
100
                                 rtx known_x ATTRIBUTE_UNUSED,
101
                                 enum machine_mode known_mode ATTRIBUTE_UNUSED,
102
                                 unsigned int known_ret ATTRIBUTE_UNUSED,
103
                                 unsigned int *result ATTRIBUTE_UNUSED)
104
{
105
  return NULL;
106
}
107
 
108
rtx
109
reg_nonzero_bits_general (rtx x ATTRIBUTE_UNUSED,
110
                          enum machine_mode mode ATTRIBUTE_UNUSED,
111
                          rtx known_x ATTRIBUTE_UNUSED,
112
                          enum machine_mode known_mode ATTRIBUTE_UNUSED,
113
                          unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
114
                          unsigned HOST_WIDE_INT *nonzero ATTRIBUTE_UNUSED)
115
{
116
  return NULL;
117
}
118
 
119
bool
120
reg_truncated_to_mode_general (enum machine_mode mode ATTRIBUTE_UNUSED,
121
                               rtx x ATTRIBUTE_UNUSED)
122
{
123
  return false;
124
}
125
 
126
/* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a fixed-point
127
   number, return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
128
   least-significant part of X.
129
   MODE specifies how big a part of X to return.
130
 
131
   If the requested operation cannot be done, 0 is returned.
132
 
133
   This is similar to gen_lowpart_general.  */
134
 
135
rtx
136
gen_lowpart_if_possible (enum machine_mode mode, rtx x)
137
{
138
  rtx result = gen_lowpart_common (mode, x);
139
 
140
  if (result)
141
    return result;
142
  else if (MEM_P (x))
143
    {
144
      /* This is the only other case we handle.  */
145
      int offset = 0;
146
      rtx new;
147
 
148
      if (WORDS_BIG_ENDIAN)
149
        offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
150
                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
151
      if (BYTES_BIG_ENDIAN)
152
        /* Adjust the address so that the address-after-the-data is
153
           unchanged.  */
154
        offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
155
                   - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
156
 
157
      new = adjust_address_nv (x, mode, offset);
158
      if (! memory_address_p (mode, XEXP (new, 0)))
159
        return 0;
160
 
161
      return new;
162
    }
163
  else if (mode != GET_MODE (x) && GET_MODE (x) != VOIDmode)
164
    return gen_lowpart_SUBREG (mode, x);
165
  else
166
    return 0;
167
}
168
 

powered by: WebSVN 2.1.0

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