lib/Target/AMDGPU/AMDILPatterns.td

   1 //===- AMDILPatterns.td - AMDIL Target Patterns------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //==-----------------------------------------------------------------------===//
   9
  10 //===----------------------------------------------------------------------===//
  11 // Store pattern fragments
  12 //===----------------------------------------------------------------------===//
  13 def truncstorei64 : PatFrag<(ops node:$val, node:$ptr),
  14                            (truncstore node:$val, node:$ptr), [{
  15   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i64;
  16 }]>;
  17 def truncstorev2i8 : PatFrag<(ops node:$val, node:$ptr),
  18                            (truncstore node:$val, node:$ptr), [{
  19   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2i8;
  20 }]>;
  21 def truncstorev2i16 : PatFrag<(ops node:$val, node:$ptr),
  22                             (truncstore node:$val, node:$ptr), [{
  23   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2i16;
  24 }]>;
  25 def truncstorev2i32 : PatFrag<(ops node:$val, node:$ptr),
  26                             (truncstore node:$val, node:$ptr), [{
  27   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2i32;
  28 }]>;
  29 def truncstorev2i64 : PatFrag<(ops node:$val, node:$ptr),
  30                             (truncstore node:$val, node:$ptr), [{
  31   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2i64;
  32 }]>;
  33 def truncstorev2f32 : PatFrag<(ops node:$val, node:$ptr),
  34                             (truncstore node:$val, node:$ptr), [{
  35   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2f32;
  36 }]>;
  37 def truncstorev2f64 : PatFrag<(ops node:$val, node:$ptr),
  38                             (truncstore node:$val, node:$ptr), [{
  39   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v2f64;
  40 }]>;
  41 def truncstorev4i8 : PatFrag<(ops node:$val, node:$ptr),
  42                            (truncstore node:$val, node:$ptr), [{
  43   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4i8;
  44 }]>;
  45 def truncstorev4i16 : PatFrag<(ops node:$val, node:$ptr),
  46                             (truncstore node:$val, node:$ptr), [{
  47   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4i16;
  48 }]>;
  49 def truncstorev4i32 : PatFrag<(ops node:$val, node:$ptr),
  50                             (truncstore node:$val, node:$ptr), [{
  51   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4i32;
  52 }]>;
  53 def truncstorev4f32 : PatFrag<(ops node:$val, node:$ptr),
  54                             (truncstore node:$val, node:$ptr), [{
  55   return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4f32;
  56 }]>;
  57
  58 def global_store : PatFrag<(ops node:$val, node:$ptr),
  59     (store node:$val, node:$ptr), [{
  60         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  61 }]>;
  62 def private_store : PatFrag<(ops node:$val, node:$ptr),
  63     (store node:$val, node:$ptr), [{
  64         return isPrivateStore(dyn_cast<StoreSDNode>(N));
  65 }]>;
  66 def local_store : PatFrag<(ops node:$val, node:$ptr),
  67     (store node:$val, node:$ptr), [{
  68         return isLocalStore(dyn_cast<StoreSDNode>(N));
  69 }]>;
  70 def region_store : PatFrag<(ops node:$val, node:$ptr),
  71     (store node:$val, node:$ptr), [{
  72         return isRegionStore(dyn_cast<StoreSDNode>(N));
  73 }]>;
  74 def global_i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
  75     (truncstorei8 node:$val, node:$ptr), [{
  76         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  77 }]>;
  78 def global_i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
  79     (truncstorei16 node:$val, node:$ptr), [{
  80         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  81 }]>;
  82 def global_i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
  83     (truncstorei32 node:$val, node:$ptr), [{
  84         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  85 }]>;
  86 def global_i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
  87     (truncstorei64 node:$val, node:$ptr), [{
  88         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  89 }]>;
  90 def global_f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
  91     (truncstoref32 node:$val, node:$ptr), [{
  92         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  93 }]>;
  94 def global_f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
  95     (truncstoref64 node:$val, node:$ptr), [{
  96         return isGlobalStore(dyn_cast<StoreSDNode>(N));
  97 }]>;
  98 def global_v2i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
  99     (truncstorev2i8 node:$val, node:$ptr), [{
 100         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 101 }]>;
 102 def global_v2i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 103     (truncstorev2i16 node:$val, node:$ptr), [{
 104         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 105 }]>;
 106 def global_v2i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 107     (truncstorev2i32 node:$val, node:$ptr), [{
 108         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 109 }]>;
 110 def global_v2i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 111     (truncstorev2i64 node:$val, node:$ptr), [{
 112         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 113 }]>;
 114 def global_v2f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 115     (truncstorev2f32 node:$val, node:$ptr), [{
 116         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 117 }]>;
 118 def global_v2f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 119     (truncstorev2f64 node:$val, node:$ptr), [{
 120         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 121 }]>;
 122 def global_v4i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 123     (truncstorev4i8 node:$val, node:$ptr), [{
 124         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 125 }]>;
 126 def global_v4i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 127     (truncstorev4i16 node:$val, node:$ptr), [{
 128         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 129 }]>;
 130 def global_v4i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 131     (truncstorev4i32 node:$val, node:$ptr), [{
 132         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 133 }]>;
 134 def global_v4f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 135     (truncstorev4f32 node:$val, node:$ptr), [{
 136         return isGlobalStore(dyn_cast<StoreSDNode>(N));
 137 }]>;
 138 def private_trunc_store : PatFrag<(ops node:$val, node:$ptr),
 139     (truncstore node:$val, node:$ptr), [{
 140         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 141 }]>;
 142 def private_i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 143     (truncstorei8 node:$val, node:$ptr), [{
 144         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 145 }]>;
 146 def private_i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 147     (truncstorei16 node:$val, node:$ptr), [{
 148         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 149 }]>;
 150 def private_i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 151     (truncstorei32 node:$val, node:$ptr), [{
 152         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 153 }]>;
 154 def private_i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 155     (truncstorei64 node:$val, node:$ptr), [{
 156         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 157 }]>;
 158 def private_f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 159     (truncstoref32 node:$val, node:$ptr), [{
 160         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 161 }]>;
 162 def private_f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 163     (truncstoref64 node:$val, node:$ptr), [{
 164         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 165 }]>;
 166 def private_v2i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 167     (truncstorev2i8 node:$val, node:$ptr), [{
 168         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 169 }]>;
 170 def private_v2i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 171     (truncstorev2i16 node:$val, node:$ptr), [{
 172         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 173 }]>;
 174 def private_v2i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 175     (truncstorev2i32 node:$val, node:$ptr), [{
 176         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 177 }]>;
 178 def private_v2i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 179     (truncstorev2i64 node:$val, node:$ptr), [{
 180         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 181 }]>;
 182 def private_v2f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 183     (truncstorev2f32 node:$val, node:$ptr), [{
 184         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 185 }]>;
 186 def private_v2f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 187     (truncstorev2f64 node:$val, node:$ptr), [{
 188         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 189 }]>;
 190 def private_v4i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 191     (truncstorev4i8 node:$val, node:$ptr), [{
 192         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 193 }]>;
 194 def private_v4i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 195     (truncstorev4i16 node:$val, node:$ptr), [{
 196         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 197 }]>;
 198 def private_v4i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 199     (truncstorev4i32 node:$val, node:$ptr), [{
 200         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 201 }]>;
 202 def private_v4f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 203     (truncstorev4f32 node:$val, node:$ptr), [{
 204         return isPrivateStore(dyn_cast<StoreSDNode>(N));
 205 }]>;
 206
 207 def local_trunc_store : PatFrag<(ops node:$val, node:$ptr),
 208     (truncstore node:$val, node:$ptr), [{
 209         return isLocalStore(dyn_cast<StoreSDNode>(N));
 210 }]>;
 211 def local_i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 212     (truncstorei8 node:$val, node:$ptr), [{
 213         return isLocalStore(dyn_cast<StoreSDNode>(N));
 214 }]>;
 215 def local_i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 216     (truncstorei16 node:$val, node:$ptr), [{
 217         return isLocalStore(dyn_cast<StoreSDNode>(N));
 218 }]>;
 219 def local_i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 220     (truncstorei32 node:$val, node:$ptr), [{
 221         return isLocalStore(dyn_cast<StoreSDNode>(N));
 222 }]>;
 223 def local_i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 224     (truncstorei64 node:$val, node:$ptr), [{
 225         return isLocalStore(dyn_cast<StoreSDNode>(N));
 226 }]>;
 227 def local_f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 228     (truncstoref32 node:$val, node:$ptr), [{
 229         return isLocalStore(dyn_cast<StoreSDNode>(N));
 230 }]>;
 231 def local_f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 232     (truncstoref64 node:$val, node:$ptr), [{
 233         return isLocalStore(dyn_cast<StoreSDNode>(N));
 234 }]>;
 235 def local_v2i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 236     (truncstorev2i8 node:$val, node:$ptr), [{
 237         return isLocalStore(dyn_cast<StoreSDNode>(N));
 238 }]>;
 239 def local_v2i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 240     (truncstorev2i16 node:$val, node:$ptr), [{
 241         return isLocalStore(dyn_cast<StoreSDNode>(N));
 242 }]>;
 243 def local_v2i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 244     (truncstorev2i32 node:$val, node:$ptr), [{
 245         return isLocalStore(dyn_cast<StoreSDNode>(N));
 246 }]>;
 247 def local_v2i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 248     (truncstorev2i64 node:$val, node:$ptr), [{
 249         return isLocalStore(dyn_cast<StoreSDNode>(N));
 250 }]>;
 251 def local_v2f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 252     (truncstorev2f32 node:$val, node:$ptr), [{
 253         return isLocalStore(dyn_cast<StoreSDNode>(N));
 254 }]>;
 255 def local_v2f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 256     (truncstorev2f64 node:$val, node:$ptr), [{
 257         return isLocalStore(dyn_cast<StoreSDNode>(N));
 258 }]>;
 259 def local_v4i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 260     (truncstorev4i8 node:$val, node:$ptr), [{
 261         return isLocalStore(dyn_cast<StoreSDNode>(N));
 262 }]>;
 263 def local_v4i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 264     (truncstorev4i16 node:$val, node:$ptr), [{
 265         return isLocalStore(dyn_cast<StoreSDNode>(N));
 266 }]>;
 267 def local_v4i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 268     (truncstorev4i32 node:$val, node:$ptr), [{
 269         return isLocalStore(dyn_cast<StoreSDNode>(N));
 270 }]>;
 271 def local_v4f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 272     (truncstorev4f32 node:$val, node:$ptr), [{
 273         return isLocalStore(dyn_cast<StoreSDNode>(N));
 274 }]>;
 275
 276 def region_trunc_store : PatFrag<(ops node:$val, node:$ptr),
 277     (truncstore node:$val, node:$ptr), [{
 278         return isRegionStore(dyn_cast<StoreSDNode>(N));
 279 }]>;
 280 def region_i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 281     (truncstorei8 node:$val, node:$ptr), [{
 282         return isRegionStore(dyn_cast<StoreSDNode>(N));
 283 }]>;
 284 def region_i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 285     (truncstorei16 node:$val, node:$ptr), [{
 286         return isRegionStore(dyn_cast<StoreSDNode>(N));
 287 }]>;
 288 def region_i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 289     (truncstorei32 node:$val, node:$ptr), [{
 290         return isRegionStore(dyn_cast<StoreSDNode>(N));
 291 }]>;
 292 def region_i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 293     (truncstorei64 node:$val, node:$ptr), [{
 294         return isRegionStore(dyn_cast<StoreSDNode>(N));
 295 }]>;
 296 def region_f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 297     (truncstoref32 node:$val, node:$ptr), [{
 298         return isRegionStore(dyn_cast<StoreSDNode>(N));
 299 }]>;
 300 def region_f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 301     (truncstoref64 node:$val, node:$ptr), [{
 302         return isRegionStore(dyn_cast<StoreSDNode>(N));
 303 }]>;
 304 def region_v2i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 305     (truncstorev2i8 node:$val, node:$ptr), [{
 306         return isRegionStore(dyn_cast<StoreSDNode>(N));
 307 }]>;
 308 def region_v2i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 309     (truncstorev2i16 node:$val, node:$ptr), [{
 310         return isRegionStore(dyn_cast<StoreSDNode>(N));
 311 }]>;
 312 def region_v2i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 313     (truncstorev2i32 node:$val, node:$ptr), [{
 314         return isRegionStore(dyn_cast<StoreSDNode>(N));
 315 }]>;
 316 def region_v2i64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 317     (truncstorev2i64 node:$val, node:$ptr), [{
 318         return isRegionStore(dyn_cast<StoreSDNode>(N));
 319 }]>;
 320 def region_v2f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 321     (truncstorev2f32 node:$val, node:$ptr), [{
 322         return isRegionStore(dyn_cast<StoreSDNode>(N));
 323 }]>;
 324 def region_v2f64trunc_store : PatFrag<(ops node:$val, node:$ptr),
 325     (truncstorev2f64 node:$val, node:$ptr), [{
 326         return isRegionStore(dyn_cast<StoreSDNode>(N));
 327 }]>;
 328 def region_v4i8trunc_store : PatFrag<(ops node:$val, node:$ptr),
 329     (truncstorev4i8 node:$val, node:$ptr), [{
 330         return isRegionStore(dyn_cast<StoreSDNode>(N));
 331 }]>;
 332 def region_v4i16trunc_store : PatFrag<(ops node:$val, node:$ptr),
 333     (truncstorev4i16 node:$val, node:$ptr), [{
 334         return isRegionStore(dyn_cast<StoreSDNode>(N));
 335 }]>;
 336 def region_v4i32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 337     (truncstorev4i32 node:$val, node:$ptr), [{
 338         return isRegionStore(dyn_cast<StoreSDNode>(N));
 339 }]>;
 340 def region_v4f32trunc_store : PatFrag<(ops node:$val, node:$ptr),
 341     (truncstorev4f32 node:$val, node:$ptr), [{
 342         return isRegionStore(dyn_cast<StoreSDNode>(N));
 343 }]>;
 344
 345 //===----------------------------------------------------------------------===//
 346 // Load pattern fragments
 347 //===----------------------------------------------------------------------===//
 348 // Global address space loads
 349 def global_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 350     return isGlobalLoad(dyn_cast<LoadSDNode>(N));
 351 }]>;
 352 def global_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 353     return isGlobalLoad(dyn_cast<LoadSDNode>(N));
 354 }]>;
 355 def global_aext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 356     return isGlobalLoad(dyn_cast<LoadSDNode>(N));
 357 }]>;
 358 def global_zext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 359     return isGlobalLoad(dyn_cast<LoadSDNode>(N));
 360 }]>;
 361 // Private address space loads
 362 def private_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 363     return isPrivateLoad(dyn_cast<LoadSDNode>(N));
 364 }]>;
 365 def private_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 366     return isPrivateLoad(dyn_cast<LoadSDNode>(N));
 367 }]>;
 368 def private_aext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 369     return isPrivateLoad(dyn_cast<LoadSDNode>(N));
 370 }]>;
 371 def private_zext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 372     return isPrivateLoad(dyn_cast<LoadSDNode>(N));
 373 }]>;
 374 // Local address space loads
 375 def local_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 376     return isLocalLoad(dyn_cast<LoadSDNode>(N));
 377 }]>;
 378 def local_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 379     return isLocalLoad(dyn_cast<LoadSDNode>(N));
 380 }]>;
 381 def local_aext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 382     return isLocalLoad(dyn_cast<LoadSDNode>(N));
 383 }]>;
 384 def local_zext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 385     return isLocalLoad(dyn_cast<LoadSDNode>(N));
 386 }]>;
 387 // Region address space loads
 388 def region_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 389     return isRegionLoad(dyn_cast<LoadSDNode>(N));
 390 }]>;
 391 def region_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 392     return isRegionLoad(dyn_cast<LoadSDNode>(N));
 393 }]>;
 394 def region_aext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 395     return isRegionLoad(dyn_cast<LoadSDNode>(N));
 396 }]>;
 397 def region_zext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 398     return isRegionLoad(dyn_cast<LoadSDNode>(N));
 399 }]>;
 400 // Constant address space loads
 401 def constant_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 402     return isConstantLoad(dyn_cast<LoadSDNode>(N), -1);
 403 }]>;
 404 def constant_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 405     return isConstantLoad(dyn_cast<LoadSDNode>(N), -1);
 406 }]>;
 407 def constant_aext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 408     return isConstantLoad(dyn_cast<LoadSDNode>(N), -1);
 409 }]>;
 410 def constant_zext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 411     return isConstantLoad(dyn_cast<LoadSDNode>(N), -1);
 412 }]>;
 413 // Constant pool loads
 414 def cp_load : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 415   return isCPLoad(dyn_cast<LoadSDNode>(N));
 416 }]>;
 417 def cp_sext_load : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 418   return isCPLoad(dyn_cast<LoadSDNode>(N));
 419 }]>;
 420 def cp_zext_load : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 421   return isCPLoad(dyn_cast<LoadSDNode>(N));
 422 }]>;
 423 def cp_aext_load : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 424   return isCPLoad(dyn_cast<LoadSDNode>(N));
 425 }]>;
 426
 427 //===----------------------------------------------------------------------===//
 428 // Complex addressing mode patterns
 429 //===----------------------------------------------------------------------===//
 430 def ADDR : ComplexPattern<i32, 2, "SelectADDR", [], []>;
 431 def ADDRF : ComplexPattern<i32, 2, "SelectADDR", [frameindex], []>;
 432 def ADDR64 : ComplexPattern<i64, 2, "SelectADDR64", [], []>;
 433 def ADDR64F : ComplexPattern<i64, 2, "SelectADDR64", [frameindex], []>;
 434
 435
 436 //===----------------------------------------------------------------------===//
 437 // Conditional Instruction Pattern Leafs
 438 //===----------------------------------------------------------------------===//
 439 class IL_CC_Op<int N> : PatLeaf<(i32 N)>;
 440 def IL_CC_D_EQ  : IL_CC_Op<0>;
 441 def IL_CC_D_GE  : IL_CC_Op<1>;
 442 def IL_CC_D_LT  : IL_CC_Op<2>;
 443 def IL_CC_D_NE  : IL_CC_Op<3>;
 444 def IL_CC_F_EQ  : IL_CC_Op<4>;
 445 def IL_CC_F_GE  : IL_CC_Op<5>;
 446 def IL_CC_F_LT  : IL_CC_Op<6>;
 447 def IL_CC_F_NE  : IL_CC_Op<7>;
 448 def IL_CC_I_EQ  : IL_CC_Op<8>;
 449 def IL_CC_I_GE  : IL_CC_Op<9>;
 450 def IL_CC_I_LT  : IL_CC_Op<10>;
 451 def IL_CC_I_NE  : IL_CC_Op<11>;
 452 def IL_CC_U_GE  : IL_CC_Op<12>;
 453 def IL_CC_U_LT  : IL_CC_Op<13>;
 454 // Pseudo IL comparison instructions that aren't natively supported
 455 def IL_CC_F_GT  : IL_CC_Op<14>;
 456 def IL_CC_U_GT  : IL_CC_Op<15>;
 457 def IL_CC_I_GT  : IL_CC_Op<16>;
 458 def IL_CC_D_GT  : IL_CC_Op<17>;
 459 def IL_CC_F_LE  : IL_CC_Op<18>;
 460 def IL_CC_U_LE  : IL_CC_Op<19>;
 461 def IL_CC_I_LE  : IL_CC_Op<20>;
 462 def IL_CC_D_LE  : IL_CC_Op<21>;
 463 def IL_CC_F_UNE : IL_CC_Op<22>;
 464 def IL_CC_F_UEQ : IL_CC_Op<23>;
 465 def IL_CC_F_ULT : IL_CC_Op<24>;
 466 def IL_CC_F_UGT : IL_CC_Op<25>;
 467 def IL_CC_F_ULE : IL_CC_Op<26>;
 468 def IL_CC_F_UGE : IL_CC_Op<27>;
 469 def IL_CC_F_ONE : IL_CC_Op<28>;
 470 def IL_CC_F_OEQ : IL_CC_Op<29>;
 471 def IL_CC_F_OLT : IL_CC_Op<30>;
 472 def IL_CC_F_OGT : IL_CC_Op<31>;
 473 def IL_CC_F_OLE : IL_CC_Op<32>;
 474 def IL_CC_F_OGE : IL_CC_Op<33>;
 475 def IL_CC_D_UNE : IL_CC_Op<34>;
 476 def IL_CC_D_UEQ : IL_CC_Op<35>;
 477 def IL_CC_D_ULT : IL_CC_Op<36>;
 478 def IL_CC_D_UGT : IL_CC_Op<37>;
 479 def IL_CC_D_ULE : IL_CC_Op<38>;
 480 def IL_CC_D_UGE : IL_CC_Op<39>;
 481 def IL_CC_D_ONE : IL_CC_Op<30>;
 482 def IL_CC_D_OEQ : IL_CC_Op<41>;
 483 def IL_CC_D_OLT : IL_CC_Op<42>;
 484 def IL_CC_D_OGT : IL_CC_Op<43>;
 485 def IL_CC_D_OLE : IL_CC_Op<44>;
 486 def IL_CC_D_OGE : IL_CC_Op<45>;
 487 def IL_CC_U_EQ  : IL_CC_Op<46>;
 488 def IL_CC_U_NE  : IL_CC_Op<47>;
 489 def IL_CC_F_O   : IL_CC_Op<48>;
 490 def IL_CC_D_O   : IL_CC_Op<49>;
 491 def IL_CC_F_UO  : IL_CC_Op<50>;
 492 def IL_CC_D_UO  : IL_CC_Op<51>;
 493 def IL_CC_L_LE  : IL_CC_Op<52>;
 494 def IL_CC_L_GE  : IL_CC_Op<53>;
 495 def IL_CC_L_EQ  : IL_CC_Op<54>;
 496 def IL_CC_L_NE  : IL_CC_Op<55>;
 497 def IL_CC_L_LT  : IL_CC_Op<56>;
 498 def IL_CC_L_GT  : IL_CC_Op<57>;
 499 def IL_CC_UL_LE  : IL_CC_Op<58>;
 500 def IL_CC_UL_GE  : IL_CC_Op<59>;
 501 def IL_CC_UL_EQ  : IL_CC_Op<60>;
 502 def IL_CC_UL_NE  : IL_CC_Op<61>;
 503 def IL_CC_UL_LT  : IL_CC_Op<62>;
 504 def IL_CC_UL_GT  : IL_CC_Op<63>;