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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [xtensa/] [predicates.md] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn
;; Predicate definitions for Xtensa.
2
;; Copyright (C) 2005, 2006, 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
7
;; it under the terms of the GNU General Public License as published by
8
;; the Free Software Foundation; either version 3, or (at your option)
9
;; any later version.
10
;;
11
;; GCC is distributed in the hope that it will be useful,
12
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
;; GNU General Public License 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
;; .
19
 
20
(define_predicate "add_operand"
21
  (ior (and (match_code "const_int")
22
            (match_test "xtensa_simm8 (INTVAL (op))
23
                         || xtensa_simm8x256 (INTVAL (op))"))
24
       (match_operand 0 "register_operand")))
25
 
26
(define_predicate "addsubx_operand"
27
  (and (match_code "const_int")
28
       (match_test "INTVAL (op) == 2
29
                    || INTVAL (op) == 4
30
                    || INTVAL (op) == 8")))
31
 
32
(define_predicate "arith_operand"
33
  (ior (and (match_code "const_int")
34
            (match_test "xtensa_simm8 (INTVAL (op))"))
35
       (match_operand 0 "register_operand")))
36
 
37
;; Non-immediate operand excluding the constant pool.
38
(define_predicate "nonimmed_operand"
39
  (ior (and (match_operand 0 "memory_operand")
40
            (match_test "!constantpool_mem_p (op)"))
41
       (match_operand 0 "register_operand")))
42
 
43
;; Memory operand excluding the constant pool.
44
(define_predicate "mem_operand"
45
  (and (match_operand 0 "memory_operand")
46
       (match_test "!constantpool_mem_p (op)")))
47
 
48
;; Memory operand in the constant pool.
49
(define_predicate "constantpool_operand"
50
  (match_test "constantpool_mem_p (op)"))
51
 
52
(define_predicate "mask_operand"
53
  (ior (and (match_code "const_int")
54
            (match_test "xtensa_mask_immediate (INTVAL (op))"))
55
       (match_operand 0 "register_operand")))
56
 
57
(define_predicate "extui_fldsz_operand"
58
  (and (match_code "const_int")
59
       (match_test "xtensa_mask_immediate ((1 << INTVAL (op)) - 1)")))
60
 
61
(define_predicate "sext_operand"
62
  (if_then_else (match_test "TARGET_SEXT")
63
                (match_operand 0 "nonimmed_operand")
64
                (match_operand 0 "mem_operand")))
65
 
66
(define_predicate "sext_fldsz_operand"
67
  (and (match_code "const_int")
68
       (match_test "INTVAL (op) >= 8 && INTVAL (op) <= 23")))
69
 
70
(define_predicate "lsbitnum_operand"
71
  (and (match_code "const_int")
72
       (match_test "BITS_BIG_ENDIAN
73
                    ? (INTVAL (op) == BITS_PER_WORD - 1)
74
                    : (INTVAL (op) == 0)")))
75
 
76
(define_predicate "branch_operand"
77
  (ior (and (match_code "const_int")
78
            (match_test "xtensa_b4const_or_zero (INTVAL (op))"))
79
       (match_operand 0 "register_operand")))
80
 
81
(define_predicate "ubranch_operand"
82
  (ior (and (match_code "const_int")
83
            (match_test "xtensa_b4constu (INTVAL (op))"))
84
       (match_operand 0 "register_operand")))
85
 
86
(define_predicate "call_insn_operand"
87
  (match_code "const_int,const,symbol_ref,reg")
88
{
89
  if ((GET_CODE (op) == REG)
90
      && (op != arg_pointer_rtx)
91
      && ((REGNO (op) < FRAME_POINTER_REGNUM)
92
          || (REGNO (op) > LAST_VIRTUAL_REGISTER)))
93
    return true;
94
 
95
  if (CONSTANT_ADDRESS_P (op))
96
    {
97
      /* Direct calls only allowed to static functions with PIC.  */
98
      if (flag_pic)
99
        {
100
          tree callee, callee_sec, caller_sec;
101
 
102
          if (GET_CODE (op) != SYMBOL_REF
103
              || !SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_EXTERNAL_P (op))
104
            return false;
105
 
106
          /* Don't attempt a direct call if the callee is known to be in
107
             a different section, since there's a good chance it will be
108
             out of range.  */
109
 
110
          if (flag_function_sections
111
              || DECL_ONE_ONLY (current_function_decl))
112
            return false;
113
          caller_sec = DECL_SECTION_NAME (current_function_decl);
114
          callee = SYMBOL_REF_DECL (op);
115
          if (callee)
116
            {
117
              if (DECL_ONE_ONLY (callee))
118
                return false;
119
              callee_sec = DECL_SECTION_NAME (callee);
120
              if (((caller_sec == NULL_TREE) ^ (callee_sec == NULL_TREE))
121
                  || (caller_sec != NULL_TREE
122
                      && strcmp (TREE_STRING_POINTER (caller_sec),
123
                                 TREE_STRING_POINTER (callee_sec)) != 0))
124
                return false;
125
            }
126
          else if (caller_sec != NULL_TREE)
127
            return false;
128
        }
129
      return true;
130
    }
131
 
132
  return false;
133
})
134
 
135
(define_predicate "move_operand"
136
  (ior
137
     (ior (match_operand 0 "register_operand")
138
          (and (match_operand 0 "memory_operand")
139
               (match_test "!constantpool_mem_p (op)
140
                            || GET_MODE_SIZE (mode) % UNITS_PER_WORD == 0")))
141
     (ior (and (match_code "const_int")
142
               (match_test "GET_MODE_CLASS (mode) == MODE_INT
143
                            && xtensa_simm12b (INTVAL (op))"))
144
          (and (match_code "const_int,const_double,const,symbol_ref,label_ref")
145
               (match_test "TARGET_CONST16 && CONSTANT_P (op)
146
                            && GET_MODE_SIZE (mode) % UNITS_PER_WORD == 0")))))
147
 
148
;; Accept the floating point constant 1 in the appropriate mode.
149
(define_predicate "const_float_1_operand"
150
  (match_code "const_double")
151
{
152
  REAL_VALUE_TYPE d;
153
  REAL_VALUE_FROM_CONST_DOUBLE (d, op);
154
  return REAL_VALUES_EQUAL (d, dconst1);
155
})
156
 
157
(define_predicate "fpmem_offset_operand"
158
  (and (match_code "const_int")
159
       (match_test "xtensa_mem_offset (INTVAL (op), SFmode)")))
160
 
161
(define_predicate "branch_operator"
162
  (match_code "eq,ne,lt,ge"))
163
 
164
(define_predicate "ubranch_operator"
165
  (match_code "ltu,geu"))
166
 
167
(define_predicate "boolean_operator"
168
  (match_code "eq,ne"))
169
 
170
(define_predicate "xtensa_cstoresi_operator"
171
  (match_code "eq,ne,gt,ge,lt,le"))
172
 
173
(define_predicate "tls_symbol_operand"
174
  (and (match_code "symbol_ref")
175
       (match_test "SYMBOL_REF_TLS_MODEL (op) != 0")))

powered by: WebSVN 2.1.0

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