text
stringlengths 1
22.8M
|
|---|
```objective-c
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#pragma once
#include <vector>
#include "paddle/phi/common/scalar.h"
#include "paddle/phi/core/distributed/auto_parallel/dist_meta_tensor.h"
#include "paddle/phi/core/distributed/type_defs.h"
namespace phi {
namespace distributed {
SpmdInfo GatherInferSpmdBase(const DistMetaTensor& x,
const DistMetaTensor& index,
int axis);
SpmdInfo GatherInferSpmdReverseBase(const DistMetaTensor& x,
const DistMetaTensor& index,
const DistMetaTensor& out,
int axis);
SpmdInfo GatherInferSpmdDynamic(const DistMetaTensor& x,
const DistMetaTensor& index,
const Scalar& axis);
SpmdInfo GatherInferSpmdReverseDynamic(const DistMetaTensor& x,
const DistMetaTensor& index,
const DistMetaTensor& out,
const Scalar& axis);
SpmdInfo GatherGradInferSpmd(const DistMetaTensor& x,
const DistMetaTensor& index,
const DistMetaTensor& out_grad,
const Scalar& axis);
} // namespace distributed
} // namespace phi
```
|
```xml
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
import {BusinessObject} from 'bpmn-js/lib/NavigatedViewer';
import isNil from 'lodash/isNil';
import {isWithinMultiInstance} from './isWithinMultiInstance';
import {isAttachedToAnEventBasedGateway} from './isAttachedToAnEventBasedGateway';
const isMoveModificationTarget = (
businessObject: BusinessObject | null | undefined,
) => {
return (
!isNil(businessObject) &&
!isWithinMultiInstance(businessObject) &&
!isAttachedToAnEventBasedGateway(businessObject) &&
businessObject.$type !== 'bpmn:StartEvent' &&
businessObject.$type !== 'bpmn:BoundaryEvent'
);
};
export {isMoveModificationTarget};
```
|
```xml
let item = "okay"
let item2 = "abc".length
item2 = item.length
item = "2".charAt(0).substr(0, 0)
item2 = parseInt("12")
item2 = "a".compare("b")
```
|
```ruby
class Cfengine < Formula
desc "Help manage and understand IT infrastructure"
homepage "path_to_url"
url "path_to_url"
sha256 your_sha256_hash
license all_of: ["BSD-3-Clause", "GPL-2.0-or-later", "GPL-3.0-only", "LGPL-2.0-or-later"]
livecheck do
url "path_to_url"
regex(/["']version["']:\s*["'](\d+(?:\.\d+)+)["']/i)
end
bottle do
sha256 arm64_sonoma: your_sha256_hash
sha256 arm64_ventura: your_sha256_hash
sha256 arm64_monterey: your_sha256_hash
sha256 sonoma: your_sha256_hash
sha256 ventura: your_sha256_hash
sha256 monterey: your_sha256_hash
sha256 x86_64_linux: your_sha256_hash
end
depends_on "lmdb"
depends_on "openssl@3"
depends_on "pcre2"
uses_from_macos "curl", since: :ventura # uses CURLOPT_PROTOCOLS_STR, available since curl 7.85.0
uses_from_macos "libxml2"
on_linux do
depends_on "linux-pam"
end
resource "masterfiles" do
url "path_to_url"
sha256 your_sha256_hash
end
def install
odie "masterfiles resource needs to be updated" if version != resource("masterfiles").version
args = %W[
--with-workdir=#{var}/cfengine
--with-lmdb=#{Formula["lmdb"].opt_prefix}
--with-pcre2=#{Formula["pcre2"].opt_prefix}
--without-mysql
--without-postgresql
]
args << "--with-systemd-service=no" if OS.linux?
system "./configure", *args, *std_configure_args
system "make", "install"
(pkgshare/"CoreBase").install resource("masterfiles")
end
def post_install
workdir = var/"cfengine"
secure_dirs = %W[
#{workdir}/inputs
#{workdir}/outputs
#{workdir}/ppkeys
#{workdir}/plugins
]
chmod 0700, secure_dirs
chmod 0750, workdir/"state"
chmod 0755, workdir/"modules"
end
test do
assert_equal "CFEngine Core #{version}", shell_output("#{bin}/cf-agent -V").chomp
end
end
```
|
The 1994 World Artistic Gymnastics Team Championships were held in Dortmund, Germany, from 15 to 20 November 1994.
Only the team event was contested at this meet. The individual events and all-around were contested at another World Championships in Brisbane, Australia in April 1994. This was the only year in which the World Championships were split into two separate competitions.
Participants
Men
Women
Medalists
Men's results
Women's results
References
World Artistic Gymnastics Championships
World Artistic Gymnastics Championships
World Artistic Gymnastics Championships, 1994
International gymnastics competitions hosted by Germany
World Artistic Championships
World Artistic Gymnastics Championships
World Artistic Gymnastics Championships, 1994
20th century in Dortmund
|
```c
/* This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks.
the dvipdfmx project team.
This program is free software; you can redistribute it and/or modify
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/
/*
* Currently, this is nearly useless.
*/
#include "dpx-pdfresource.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "tectonic_bridge_core.h"
#include "dpx-error.h"
#include "dpx-mem.h"
#include "dpx-pdfobj.h"
#define PDF_RESOURCE_DEBUG_STR "PDF"
#define PDF_RESOURCE_DEBUG 3
#define PDF_RESOURCE_FONT 0
#define PDF_RESOURCE_CIDFONT 1
#define PDF_RESOURCE_ENCODING 2
#define PDF_RESOURCE_CMAP 3
#define PDF_RESOURCE_XOBJECT 4
#define PDF_RESOURCE_COLORSPACE 5
#define PDF_RESOURCE_SHADING 6
#define PDF_RESOURCE_PATTERN 7
#define PDF_RESOURCE_GSTATE 8
typedef struct pdf_res
{
char *ident;
int flags;
int category;
void *cdata;
pdf_obj *object;
pdf_obj *reference;
} pdf_res;
static struct {
const char *name;
int cat_id;
} pdf_resource_categories[] = {
{"Font", PDF_RESOURCE_FONT},
{"CIDFont", PDF_RESOURCE_CIDFONT},
{"Encoding", PDF_RESOURCE_ENCODING},
{"CMap", PDF_RESOURCE_CMAP},
{"XObject", PDF_RESOURCE_XOBJECT},
{"ColorSpace", PDF_RESOURCE_COLORSPACE},
{"Shading", PDF_RESOURCE_SHADING},
{"Pattern", PDF_RESOURCE_PATTERN},
{"ExtGState", PDF_RESOURCE_GSTATE},
};
#define PDF_NUM_RESOURCE_CATEGORIES (sizeof(pdf_resource_categories)/sizeof(pdf_resource_categories[0]))
#define CACHE_ALLOC_SIZE 16u
struct res_cache
{
int count;
int capacity;
pdf_res *resources;
};
static struct res_cache resources[PDF_NUM_RESOURCE_CATEGORIES];
static void
pdf_init_resource (pdf_res *res)
{
assert(res);
res->ident = NULL;
res->category = -1;
res->flags = 0;
res->cdata = NULL;
res->object = NULL;
res->reference = NULL;
return;
}
static void
pdf_flush_resource (pdf_res *res)
{
if (res) {
pdf_release_obj(res->reference);
pdf_release_obj(res->object);
res->reference = NULL;
res->object = NULL;
}
}
static void
pdf_clean_resource (pdf_res *res)
{
if (res) {
if (res->reference || res->object)
dpx_warning("Trying to release un-flushed object.");
pdf_release_obj(res->reference);
pdf_release_obj(res->object);
res->ident = mfree(res->ident);
res->category = -1;
res->flags = 0;
}
}
void
pdf_init_resources (void)
{
unsigned int i;
for (i = 0;
i < PDF_NUM_RESOURCE_CATEGORIES; i++) {
resources[i].count = 0;
resources[i].capacity = 0;
resources[i].resources = NULL;
}
}
void
pdf_close_resources (void)
{
unsigned int i;
for (i = 0;
i < PDF_NUM_RESOURCE_CATEGORIES; i++) {
struct res_cache *rc;
int j;
rc = &resources[i];
for (j = 0; j < rc->count; j++) {
pdf_flush_resource(&rc->resources[j]);
pdf_clean_resource(&rc->resources[j]);
}
free(rc->resources);
rc->count = 0;
rc->capacity = 0;
rc->resources = NULL;
}
}
static int
get_category (const char *category)
{
unsigned int i;
for (i = 0;
i < PDF_NUM_RESOURCE_CATEGORIES; i++) {
if (streq_ptr(category, pdf_resource_categories[i].name)) {
return pdf_resource_categories[i].cat_id;
}
}
return -1;
}
int
pdf_defineresource (const char *category,
const char *resname, pdf_obj *object, int flags)
{
int res_id;
struct res_cache *rc;
int cat_id;
pdf_res *res = NULL;
assert(category && object);
cat_id = get_category(category);
if (cat_id < 0) {
_tt_abort("Unknown resource category: %s", category);
}
rc = &resources[cat_id];
if (resname) {
for (res_id = 0; res_id < rc->count; res_id++) {
res = &rc->resources[res_id];
if (streq_ptr(resname, res->ident)) {
dpx_warning("Resource %s (category: %s) already defined...",
resname, category);
pdf_flush_resource(res);
res->flags = flags;
if (flags & PDF_RES_FLUSH_IMMEDIATE) {
res->reference = pdf_ref_obj(object);
pdf_release_obj(object);
} else {
res->object = object;
}
return (cat_id << 16) | res_id;
}
}
} else {
res_id = rc->count;
}
if (res_id == rc->count) {
if (rc->count >= rc->capacity) {
rc->capacity += CACHE_ALLOC_SIZE;
rc->resources = RENEW(rc->resources, rc->capacity, pdf_res);
}
res = &rc->resources[res_id];
pdf_init_resource(res);
if (resname && resname[0] != '\0') {
res->ident = NEW(strlen(resname) + 1, char);
strcpy(res->ident, resname);
}
res->category = cat_id;
res->flags = flags;
if (flags & PDF_RES_FLUSH_IMMEDIATE) {
res->reference = pdf_ref_obj(object);
pdf_release_obj(object);
} else {
res->object = object;
}
rc->count++;
}
return (cat_id << 16) | res_id;
}
int
pdf_findresource (const char *category, const char *resname)
{
pdf_res *res;
int res_id, cat_id;
struct res_cache *rc;
assert(resname && category);
cat_id = get_category(category);
if (cat_id < 0) {
_tt_abort("Unknown resource category: %s", category);
}
rc = &resources[cat_id];
for (res_id = 0; res_id < rc->count; res_id++) {
res = &rc->resources[res_id];
if (streq_ptr(resname, res->ident)) {
return cat_id << 16 | res_id;
}
}
return -1;
}
pdf_obj *
pdf_get_resource_reference (int rc_id)
{
int cat_id, res_id;
struct res_cache *rc;
pdf_res *res;
cat_id = (rc_id >> 16) & 0xffff;
res_id = rc_id & 0xffff;
if (cat_id < 0 ||
cat_id >= PDF_NUM_RESOURCE_CATEGORIES) {
_tt_abort("Invalid category ID: %d", cat_id);
return NULL;
}
rc = &resources[cat_id];
if (res_id < 0 || res_id >= rc->count) {
_tt_abort("Invalid resource ID: %d", res_id);
return NULL;
}
res = &rc->resources[res_id];
if (!res->reference) {
if (!res->object) {
_tt_abort("Undefined object...");
return NULL;
} else {
res->reference = pdf_ref_obj(res->object);
}
}
return pdf_link_obj(res->reference);
}
```
|
The 2000 Super League Grand Final was the third official Grand Final and the conclusive and championship-deciding game of 2000's Super League V. Held on Saturday 14 October 2000 at Old Trafford, Manchester, the game was played between St. Helens and Wigan Warriors. Wigan wore blue for the encounter and St Helens wore their traditional red and white. The match was refereed by Russell Smith of Castleford and played before a crowd of 58,132. In the end St Helens, inspired by their captain Chris Joynt, defeated Wigan Warriors 29–16.
Background
Tetleys Super League V reverted to 12 teams after Gateshead Thunder and Sheffield Eagles left the league although Huddersfield Giants subsequently became Huddersfield-Sheffield Giants and finished bottom for the third consecutive season. Wigan Warriors finished top for the first time since Super League III when they won the Grand Final.
Route to the Final
Wigan Warriors
St Helens
Match details
References
External links
2000 Super League Grand Final at rlphotos.com
Super League Grand Finals
St Helens R.F.C. matches
Wigan Warriors matches
Grand final
|
```java
/*******************************************************************************
* <p>
* <p>
* path_to_url
* <p>
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*******************************************************************************/
package com.intuit.wasabi.eventlog;
import com.intuit.wasabi.authenticationobjects.UserInfo;
import com.intuit.wasabi.eventlog.events.EventLogEvent;
import java.util.List;
/**
* Provides an event log to register {@link EventLogListener}s and post events.
*/
public interface EventLog extends Runnable {
/**
* Denotes the system user, used for automated events.
*/
UserInfo SYSTEM_USER = new UserInfo.Builder(UserInfo.Username.valueOf("SYSTEM_USER"))
.withFirstName("System")
.withLastName("User")
.withEmail("admin@example.com")
.withUserId("SystemUser")
.build();
/**
* Registers a listener for all events.
*
* @param listener the listener
*/
void register(EventLogListener listener);
/**
* Registers a listener for a list of events.
*
* If no events are specified, the listener is registered for all events.
*
* @param listener the listener
* @param events the events
*/
void register(EventLogListener listener, List<Class<? extends EventLogEvent>> events);
/**
* Registers a listener for a list of events.
*
* If no events are specified, the listener is registered for all events.
*
* The class will first be tried to load as specified, and if that fails it will be tried as if it
* was in the package {@code com.intuit.wasabi.eventlog.events}.
*
* @param listener the listener
* @param events the event class names
*
* @throws ClassNotFoundException when listeners cannot be loaded in classpath
*/
void register(EventLogListener listener, String... events) throws ClassNotFoundException;
/**
* Post an event to the event log. This invokes {@link EventLogListener#postEvent(EventLogEvent)} for
* all listeners which are described to events of this type.
*
* @param event the event to notify the listeners about.
*/
void postEvent(EventLogEvent event);
}
```
|
```xml
<?xml version="1.0" encoding="UTF-8"?>
<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="11542" systemVersion="16B2659" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
<device id="retina4_7" orientation="portrait">
<adaptation id="fullscreen"/>
</device>
<dependencies>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="11524"/>
<capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
</dependencies>
<scenes>
<!--View Controller-->
<scene sceneID="tne-QT-ifu">
<objects>
<viewController id="BYZ-38-t0r" customClass="ViewController" customModule="GradientAnimation" customModuleProvider="target" sceneMemberID="viewController">
<layoutGuides>
<viewControllerLayoutGuide type="top" id="y3c-jy-aDJ"/>
<viewControllerLayoutGuide type="bottom" id="wfy-db-euE"/>
</layoutGuides>
<view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
<rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<subviews>
<imageView userInteractionEnabled="NO" contentMode="scaleAspectFill" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="background" translatesAutoresizingMaskIntoConstraints="NO" id="AUm-0P-2lY">
<rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
</imageView>
<view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="dG0-wb-vQe" customClass="LoadingLabel" customModule="GradientAnimation" customModuleProvider="target">
<rect key="frame" x="0.0" y="287" width="375" height="94"/>
<color key="backgroundColor" red="0.0" green="0.0" blue="0.0" alpha="0.0" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstAttribute="height" constant="94" id="WDI-Fz-82o"/>
</constraints>
<userDefinedRuntimeAttributes>
<userDefinedRuntimeAttribute type="string" keyPath="text" value="Paper"/>
</userDefinedRuntimeAttributes>
</view>
</subviews>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstAttribute="trailing" secondItem="AUm-0P-2lY" secondAttribute="trailing" id="06h-iC-4E2"/>
<constraint firstItem="dG0-wb-vQe" firstAttribute="centerY" secondItem="8bC-Xf-vdC" secondAttribute="centerY" id="TVr-6P-59P"/>
<constraint firstItem="AUm-0P-2lY" firstAttribute="top" secondItem="8bC-Xf-vdC" secondAttribute="top" id="aQD-qd-JSj"/>
<constraint firstItem="dG0-wb-vQe" firstAttribute="centerX" secondItem="8bC-Xf-vdC" secondAttribute="centerX" id="bdL-Cj-DEm"/>
<constraint firstItem="AUm-0P-2lY" firstAttribute="leading" secondItem="8bC-Xf-vdC" secondAttribute="leading" id="cVS-nX-Wnx"/>
<constraint firstAttribute="trailing" secondItem="dG0-wb-vQe" secondAttribute="trailing" id="hLw-Og-NQv"/>
<constraint firstItem="wfy-db-euE" firstAttribute="top" secondItem="AUm-0P-2lY" secondAttribute="bottom" id="i0i-iW-xBq"/>
<constraint firstItem="dG0-wb-vQe" firstAttribute="leading" secondItem="8bC-Xf-vdC" secondAttribute="leading" id="q6q-yf-zKu"/>
</constraints>
</view>
</viewController>
<placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="340" y="428.63568215892059"/>
</scene>
</scenes>
<resources>
<image name="background" width="1200" height="1200"/>
</resources>
</document>
```
|
```javascript
var isSymbol = require('./isSymbol');
/** Used as references for the maximum length and index of an array. */
var MAX_ARRAY_LENGTH = 4294967295,
MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeFloor = Math.floor,
nativeMin = Math.min;
/**
* The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
* which invokes `iteratee` for `value` and each element of `array` to compute
* their sort ranking. The iteratee is invoked with one argument; (value).
*
* @private
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @param {Function} iteratee The iteratee invoked per element.
* @param {boolean} [retHighest] Specify returning the highest qualified index.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
*/
function baseSortedIndexBy(array, value, iteratee, retHighest) {
var low = 0,
high = array == null ? 0 : array.length;
if (high === 0) {
return 0;
}
value = iteratee(value);
var valIsNaN = value !== value,
valIsNull = value === null,
valIsSymbol = isSymbol(value),
valIsUndefined = value === undefined;
while (low < high) {
var mid = nativeFloor((low + high) / 2),
computed = iteratee(array[mid]),
othIsDefined = computed !== undefined,
othIsNull = computed === null,
othIsReflexive = computed === computed,
othIsSymbol = isSymbol(computed);
if (valIsNaN) {
var setLow = retHighest || othIsReflexive;
} else if (valIsUndefined) {
setLow = othIsReflexive && (retHighest || othIsDefined);
} else if (valIsNull) {
setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
} else if (valIsSymbol) {
setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
} else if (othIsNull || othIsSymbol) {
setLow = false;
} else {
setLow = retHighest ? (computed <= value) : (computed < value);
}
if (setLow) {
low = mid + 1;
} else {
high = mid;
}
}
return nativeMin(high, MAX_ARRAY_INDEX);
}
module.exports = baseSortedIndexBy;
```
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.tencent.tinker.android.dx.instruction;
import com.tencent.tinker.android.dex.DexException;
import com.tencent.tinker.android.dx.util.Hex;
import com.tencent.tinker.android.utils.SparseIntArray;
/**
* *** This file is NOT a part of AOSP. ***
*
* Created by tangyinsheng on 2016/8/11.
*/
public final class InstructionPromoter extends InstructionVisitor {
private final SparseIntArray addressMap = new SparseIntArray();
// Notice that the unit of currentPromotedAddress is not 'byte'
// but 'short'
private int currentPromotedAddress = 0;
public InstructionPromoter() {
super(null);
}
private void mapAddressIfNeeded(int currentAddress) {
if (currentAddress != this.currentPromotedAddress) {
addressMap.append(currentAddress, this.currentPromotedAddress);
}
}
public int getPromotedAddress(int currentAddress) {
int index = addressMap.indexOfKey(currentAddress);
if (index < 0) {
return currentAddress;
} else {
return addressMap.valueAt(index);
}
}
public int getPromotedAddressCount() {
return addressMap.size();
}
@Override
public void visitZeroRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.SPECIAL_FORMAT:
case Opcodes.NOP:
case Opcodes.RETURN_VOID: {
this.currentPromotedAddress += 1;
break;
}
case Opcodes.GOTO: {
int relativeTarget = InstructionCodec.getTarget(target, this.currentPromotedAddress);
if (relativeTarget != (byte) relativeTarget) {
if (relativeTarget != (short) relativeTarget) {
this.currentPromotedAddress += 3;
} else {
this.currentPromotedAddress += 2;
}
} else {
this.currentPromotedAddress += 1;
}
break;
}
case Opcodes.GOTO_16: {
int relativeTarget = InstructionCodec.getTarget(target, this.currentPromotedAddress);
if (relativeTarget != (short) relativeTarget) {
this.currentPromotedAddress += 3;
} else {
this.currentPromotedAddress += 2;
}
break;
}
case Opcodes.GOTO_32: {
this.currentPromotedAddress += 3;
break;
}
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitOneRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.CONST_STRING: {
if (index > 0xFFFF) {
this.currentPromotedAddress += 3;
} else {
this.currentPromotedAddress += 2;
}
break;
}
case Opcodes.CONST_STRING_JUMBO: {
this.currentPromotedAddress += 3;
break;
}
case Opcodes.CONST_4:
case Opcodes.MOVE_RESULT:
case Opcodes.MOVE_RESULT_WIDE:
case Opcodes.MOVE_RESULT_OBJECT:
case Opcodes.MOVE_EXCEPTION:
case Opcodes.RETURN:
case Opcodes.RETURN_WIDE:
case Opcodes.RETURN_OBJECT:
case Opcodes.MONITOR_ENTER:
case Opcodes.MONITOR_EXIT:
case Opcodes.THROW: {
this.currentPromotedAddress += 1;
break;
}
case Opcodes.IF_EQZ:
case Opcodes.IF_NEZ:
case Opcodes.IF_LTZ:
case Opcodes.IF_GEZ:
case Opcodes.IF_GTZ:
case Opcodes.IF_LEZ:
case Opcodes.CONST_16:
case Opcodes.CONST_WIDE_16:
case Opcodes.CONST_HIGH16:
case Opcodes.CONST_WIDE_HIGH16:
case Opcodes.CONST_CLASS:
case Opcodes.CHECK_CAST:
case Opcodes.NEW_INSTANCE:
case Opcodes.SGET:
case Opcodes.SGET_WIDE:
case Opcodes.SGET_OBJECT:
case Opcodes.SGET_BOOLEAN:
case Opcodes.SGET_BYTE:
case Opcodes.SGET_CHAR:
case Opcodes.SGET_SHORT:
case Opcodes.SPUT:
case Opcodes.SPUT_WIDE:
case Opcodes.SPUT_OBJECT:
case Opcodes.SPUT_BOOLEAN:
case Opcodes.SPUT_BYTE:
case Opcodes.SPUT_CHAR:
case Opcodes.SPUT_SHORT: {
this.currentPromotedAddress += 2;
break;
}
case Opcodes.CONST:
case Opcodes.CONST_WIDE_32:
case Opcodes.FILL_ARRAY_DATA:
case Opcodes.PACKED_SWITCH:
case Opcodes.SPARSE_SWITCH:
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
case Opcodes.CONST_WIDE: {
this.currentPromotedAddress += 5;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitTwoRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a, int b) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.MOVE:
case Opcodes.MOVE_WIDE:
case Opcodes.MOVE_OBJECT:
case Opcodes.ARRAY_LENGTH:
case Opcodes.NEG_INT:
case Opcodes.NOT_INT:
case Opcodes.NEG_LONG:
case Opcodes.NOT_LONG:
case Opcodes.NEG_FLOAT:
case Opcodes.NEG_DOUBLE:
case Opcodes.INT_TO_LONG:
case Opcodes.INT_TO_FLOAT:
case Opcodes.INT_TO_DOUBLE:
case Opcodes.LONG_TO_INT:
case Opcodes.LONG_TO_FLOAT:
case Opcodes.LONG_TO_DOUBLE:
case Opcodes.FLOAT_TO_INT:
case Opcodes.FLOAT_TO_LONG:
case Opcodes.FLOAT_TO_DOUBLE:
case Opcodes.DOUBLE_TO_INT:
case Opcodes.DOUBLE_TO_LONG:
case Opcodes.DOUBLE_TO_FLOAT:
case Opcodes.INT_TO_BYTE:
case Opcodes.INT_TO_CHAR:
case Opcodes.INT_TO_SHORT:
case Opcodes.ADD_INT_2ADDR:
case Opcodes.SUB_INT_2ADDR:
case Opcodes.MUL_INT_2ADDR:
case Opcodes.DIV_INT_2ADDR:
case Opcodes.REM_INT_2ADDR:
case Opcodes.AND_INT_2ADDR:
case Opcodes.OR_INT_2ADDR:
case Opcodes.XOR_INT_2ADDR:
case Opcodes.SHL_INT_2ADDR:
case Opcodes.SHR_INT_2ADDR:
case Opcodes.USHR_INT_2ADDR:
case Opcodes.ADD_LONG_2ADDR:
case Opcodes.SUB_LONG_2ADDR:
case Opcodes.MUL_LONG_2ADDR:
case Opcodes.DIV_LONG_2ADDR:
case Opcodes.REM_LONG_2ADDR:
case Opcodes.AND_LONG_2ADDR:
case Opcodes.OR_LONG_2ADDR:
case Opcodes.XOR_LONG_2ADDR:
case Opcodes.SHL_LONG_2ADDR:
case Opcodes.SHR_LONG_2ADDR:
case Opcodes.USHR_LONG_2ADDR:
case Opcodes.ADD_FLOAT_2ADDR:
case Opcodes.SUB_FLOAT_2ADDR:
case Opcodes.MUL_FLOAT_2ADDR:
case Opcodes.DIV_FLOAT_2ADDR:
case Opcodes.REM_FLOAT_2ADDR:
case Opcodes.ADD_DOUBLE_2ADDR:
case Opcodes.SUB_DOUBLE_2ADDR:
case Opcodes.MUL_DOUBLE_2ADDR:
case Opcodes.DIV_DOUBLE_2ADDR:
case Opcodes.REM_DOUBLE_2ADDR: {
this.currentPromotedAddress += 1;
break;
}
case Opcodes.MOVE_FROM16:
case Opcodes.MOVE_WIDE_FROM16:
case Opcodes.MOVE_OBJECT_FROM16: {
this.currentPromotedAddress += 2;
break;
}
case Opcodes.ADD_INT_LIT8:
case Opcodes.RSUB_INT_LIT8:
case Opcodes.MUL_INT_LIT8:
case Opcodes.DIV_INT_LIT8:
case Opcodes.REM_INT_LIT8:
case Opcodes.AND_INT_LIT8:
case Opcodes.OR_INT_LIT8:
case Opcodes.XOR_INT_LIT8:
case Opcodes.SHL_INT_LIT8:
case Opcodes.SHR_INT_LIT8:
case Opcodes.USHR_INT_LIT8:
case Opcodes.IF_EQ:
case Opcodes.IF_NE:
case Opcodes.IF_LT:
case Opcodes.IF_GE:
case Opcodes.IF_GT:
case Opcodes.IF_LE:
case Opcodes.ADD_INT_LIT16:
case Opcodes.RSUB_INT:
case Opcodes.MUL_INT_LIT16:
case Opcodes.DIV_INT_LIT16:
case Opcodes.REM_INT_LIT16:
case Opcodes.AND_INT_LIT16:
case Opcodes.OR_INT_LIT16:
case Opcodes.XOR_INT_LIT16:
case Opcodes.INSTANCE_OF:
case Opcodes.NEW_ARRAY:
case Opcodes.IGET:
case Opcodes.IGET_WIDE:
case Opcodes.IGET_OBJECT:
case Opcodes.IGET_BOOLEAN:
case Opcodes.IGET_BYTE:
case Opcodes.IGET_CHAR:
case Opcodes.IGET_SHORT:
case Opcodes.IPUT:
case Opcodes.IPUT_WIDE:
case Opcodes.IPUT_OBJECT:
case Opcodes.IPUT_BOOLEAN:
case Opcodes.IPUT_BYTE:
case Opcodes.IPUT_CHAR:
case Opcodes.IPUT_SHORT: {
this.currentPromotedAddress += 2;
break;
}
case Opcodes.MOVE_16:
case Opcodes.MOVE_WIDE_16:
case Opcodes.MOVE_OBJECT_16:
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitThreeRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a, int b, int c) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.CMPL_FLOAT:
case Opcodes.CMPG_FLOAT:
case Opcodes.CMPL_DOUBLE:
case Opcodes.CMPG_DOUBLE:
case Opcodes.CMP_LONG:
case Opcodes.AGET:
case Opcodes.AGET_WIDE:
case Opcodes.AGET_OBJECT:
case Opcodes.AGET_BOOLEAN:
case Opcodes.AGET_BYTE:
case Opcodes.AGET_CHAR:
case Opcodes.AGET_SHORT:
case Opcodes.APUT:
case Opcodes.APUT_WIDE:
case Opcodes.APUT_OBJECT:
case Opcodes.APUT_BOOLEAN:
case Opcodes.APUT_BYTE:
case Opcodes.APUT_CHAR:
case Opcodes.APUT_SHORT:
case Opcodes.ADD_INT:
case Opcodes.SUB_INT:
case Opcodes.MUL_INT:
case Opcodes.DIV_INT:
case Opcodes.REM_INT:
case Opcodes.AND_INT:
case Opcodes.OR_INT:
case Opcodes.XOR_INT:
case Opcodes.SHL_INT:
case Opcodes.SHR_INT:
case Opcodes.USHR_INT:
case Opcodes.ADD_LONG:
case Opcodes.SUB_LONG:
case Opcodes.MUL_LONG:
case Opcodes.DIV_LONG:
case Opcodes.REM_LONG:
case Opcodes.AND_LONG:
case Opcodes.OR_LONG:
case Opcodes.XOR_LONG:
case Opcodes.SHL_LONG:
case Opcodes.SHR_LONG:
case Opcodes.USHR_LONG:
case Opcodes.ADD_FLOAT:
case Opcodes.SUB_FLOAT:
case Opcodes.MUL_FLOAT:
case Opcodes.DIV_FLOAT:
case Opcodes.REM_FLOAT:
case Opcodes.ADD_DOUBLE:
case Opcodes.SUB_DOUBLE:
case Opcodes.MUL_DOUBLE:
case Opcodes.DIV_DOUBLE:
case Opcodes.REM_DOUBLE: {
this.currentPromotedAddress += 2;
break;
}
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitFourRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a, int b, int c, int d) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitFiveRegisterInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a, int b, int c, int d, int e) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.FILLED_NEW_ARRAY:
case Opcodes.INVOKE_VIRTUAL:
case Opcodes.INVOKE_SUPER:
case Opcodes.INVOKE_DIRECT:
case Opcodes.INVOKE_STATIC:
case Opcodes.INVOKE_INTERFACE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitRegisterRangeInsn(int currentAddress, int opcode, int index, int indexType, int target, long literal, int a, int registerCount) {
mapAddressIfNeeded(currentAddress);
switch (opcode) {
case Opcodes.FILLED_NEW_ARRAY_RANGE:
case Opcodes.INVOKE_VIRTUAL_RANGE:
case Opcodes.INVOKE_SUPER_RANGE:
case Opcodes.INVOKE_DIRECT_RANGE:
case Opcodes.INVOKE_STATIC_RANGE:
case Opcodes.INVOKE_INTERFACE_RANGE: {
this.currentPromotedAddress += 3;
break;
}
default: {
throw new IllegalStateException("unexpected opcode: " + Hex.u2or4(opcode));
}
}
}
@Override
public void visitSparseSwitchPayloadInsn(int currentAddress, int opcode, int[] keys, int[] targets) {
mapAddressIfNeeded(currentAddress);
this.currentPromotedAddress += 2;
this.currentPromotedAddress += keys.length * 2;
this.currentPromotedAddress += targets.length * 2;
}
@Override
public void visitPackedSwitchPayloadInsn(int currentAddress, int opcode, int firstKey, int[] targets) {
mapAddressIfNeeded(currentAddress);
this.currentPromotedAddress += 2 + 2;
this.currentPromotedAddress += targets.length * 2;
}
@Override
public void visitFillArrayDataPayloadInsn(int currentAddress, int opcode, Object data, int size, int elementWidth) {
mapAddressIfNeeded(currentAddress);
this.currentPromotedAddress += 2 + 2;
switch (elementWidth) {
case 1: {
int length = ((byte[]) data).length;
this.currentPromotedAddress += (length >> 1) + (length & 1);
break;
}
case 2: {
this.currentPromotedAddress += ((short[]) data).length * 1;
break;
}
case 4: {
this.currentPromotedAddress += ((int[]) data).length * 2;
break;
}
case 8: {
this.currentPromotedAddress += ((long[]) data).length * 4;
break;
}
default: {
throw new DexException("bogus element_width: " + Hex.u2(elementWidth));
}
}
}
}
```
|
```javascript
(function () {
'use strict';
angular.module('theHiveDirectives').directive('tagItem', function (TaxonomyCacheSrv, TagSrv) {
return {
restrict: 'E',
replace: true,
scope: {
value: '=',
colour: '='
},
templateUrl: 'views/directives/tag-item.html',
link: function (scope/*, element, attrs*/) {
if (!scope.value) {
return;
}
if (_.isString(scope.value)) {
scope.tag = scope.value;
scope.bgColor = scope.colour ||
TaxonomyCacheSrv.getColour(scope.value) ||
TaxonomyCacheSrv.getColour('_freetags_:' + scope.value) ||
TagSrv.tagsDefaultColour ||
'#000000';
} else {
scope.tag = _.without([
scope.value.namespace,
':',
scope.value.predicate,
scope.value.value ? ("=\"" + scope.value.value + "\"") : null
], null).join('');
scope.bgColor = scope.value.colour ||
scope.colour ||
TagSrv.tagsDefaultColour ||
'#000000';
}
scope.$watch('colour', function (value) {
if (!value) {
return;
}
scope.bgColor = value;
});
scope.$watch('value', function (value) {
if (!value) {
return;
}
if (_.isString(value)) {
scope.tag = value;
} else {
scope.tag = _.without([
value.namespace,
':',
value.predicate,
value.value ? ("=\"" + value.value + "\"") : null
], null).join('');
}
});
}
};
});
})();
```
|
```c++
/**
@file
@brief Matrix Exponentiation.
The problem can be solved with DP but constraints are high.
<br/>\f$a_i = b_i\f$ (for \f$i <= k\f$)
<br/>\f$a_i = c_1 a_{i-1} + c_2 a_{i-2} + ... + c_k a_{i-k}\f$ (for \f$i > k\f$)
<br/>Taking the example of Fibonacci series, \f$k=2\f$
<br/>\f$b_1 = 1,\; b_2=1\f$
<br/>\f$c_1 = 1,\; c_2=1\f$
<br/>\f$a = \begin{bmatrix}0& 1& 1& 2& \ldots\end{bmatrix}\f$
<br/>This way you can find the \f$10^{18}\f$ fibonacci number%MOD.
I have given a general way to use it. The program takes the input of B and C
matrix.
Steps for Matrix Expo
1. Create vector F1 : which is the copy of B.
2. Create transpose matrix (Learn more about it on the internet)
3. Perform \f$T^{n-1}\f$ [transpose matrix to the power n-1]
4. Multiply with F to get the last matrix of size (1\f$\times\f$k).
The first element of this matrix is the required result.
*/
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::vector;
/*! shorthand definition for `int64_t` */
#define ll int64_t
/*! shorthand definition for `std::endl` */
#define endl std::endl
/*! shorthand definition for `int64_t` */
#define pb push_back
#define MOD 1000000007
/** global variable mat_size
* @todo @stepfencurryxiao add documetnation
*/
ll mat_size;
/** global vector variables used in the ::ans function.
* @todo @stepfencurryxiao add documetnation
*/
vector<ll> fib_b, fib_c;
/** To multiply 2 matrices
* \param [in] A matrix 1 of size (m\f$\times\f$n)
* \param [in] B \p matrix 2 of size (p\f$\times\f$q)\n\note \f$p=n\f$
* \result matrix of dimension (m\f$\times\f$q)
*/
vector<vector<ll>> multiply(const vector<vector<ll>> &A,
const vector<vector<ll>> &B) {
vector<vector<ll>> C(mat_size + 1, vector<ll>(mat_size + 1));
for (ll i = 1; i <= mat_size; i++) {
for (ll j = 1; j <= mat_size; j++) {
for (ll z = 1; z <= mat_size; z++) {
C[i][j] = (C[i][j] + (A[i][z] * B[z][j]) % MOD) % MOD;
}
}
}
return C;
}
/** computing integer power of a matrix using recursive multiplication.
* @note A must be a square matrix for this algorithm.
* \param [in] A base matrix
* \param [in] p exponent
* \return matrix of same dimension as A
*/
vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
if (p == 1)
return A;
if (p % 2 == 1) {
return multiply(A, power(A, p - 1));
} else {
vector<vector<ll>> X = power(A, p / 2);
return multiply(X, X);
}
}
/*! Wrapper for Fibonacci
* \param[in] n \f$n^\text{th}\f$ Fibonacci number
* \return \f$n^\text{th}\f$ Fibonacci number
*/
ll ans(ll n) {
if (n == 0)
return 0;
if (n <= mat_size)
return fib_b[n - 1];
// F1
vector<ll> F1(mat_size + 1);
for (ll i = 1; i <= mat_size; i++) F1[i] = fib_b[i - 1];
// Transpose matrix
vector<vector<ll>> T(mat_size + 1, vector<ll>(mat_size + 1));
for (ll i = 1; i <= mat_size; i++) {
for (ll j = 1; j <= mat_size; j++) {
if (i < mat_size) {
if (j == i + 1)
T[i][j] = 1;
else
T[i][j] = 0;
continue;
}
T[i][j] = fib_c[mat_size - j];
}
}
// T^n-1
T = power(T, n - 1);
// T*F1
ll res = 0;
for (ll i = 1; i <= mat_size; i++) {
res = (res + (T[1][i] * F1[i]) % MOD) % MOD;
}
return res;
}
/** Main function */
int main() {
cin.tie(0);
cout.tie(0);
ll t;
cin >> t;
ll i, j, x;
while (t--) {
cin >> mat_size;
for (i = 0; i < mat_size; i++) {
cin >> x;
fib_b.pb(x);
}
for (i = 0; i < mat_size; i++) {
cin >> x;
fib_c.pb(x);
}
cin >> x;
cout << ans(x) << endl;
fib_b.clear();
fib_c.clear();
}
return 0;
}
```
|
Inioluwa Deborah Raji (born ) is a Nigerian-Canadian computer scientist and activist who works on algorithmic bias, AI accountability, and algorithmic auditing. Raji has previously worked with Joy Buolamwini, Timnit Gebru, and the Algorithmic Justice League on researching gender and racial bias in facial recognition technology. She has also worked with Google’s Ethical AI team and been a research fellow at the Partnership on AI and AI Now Institute at New York University working on how to operationalize ethical considerations in machine learning engineering practice. A current Mozilla fellow, she has been recognized by MIT Technology Review and Forbes as one of the world's top young innovators.
Early life and education
Raji was born in Port Harcourt, Nigeria and moved to Mississauga, Ontario when she was four years old. Eventually her family moved to Ottawa, Canada. She studied Engineering Science at the University of Toronto, graduating in 2019. In 2015, she founded Project Include, a nonprofit providing increased student access to engineering education, mentorship, and resources in low income and immigrant communities in the Greater Toronto Area.
Career and research
Raji worked with Joy Buolamwini at the MIT Media Lab and Algorithmic Justice League, where she audited commercial facial recognition technologies from Microsoft, Amazon, IBM, Face++, and Kairos. They found that these technologies were significantly less accurate for darker-skinned women than for white men. With support from other top AI researchers and increased public pressure and campaigning, their work led IBM and Amazon to agree to support facial recognition regulation and later halt the sale of their product to police for at least a year. Raji also interned at machine learning startup Clarifai, where she worked on a computer vision model for flagging images.
She participated in a research mentorship program at Google and worked with their Ethical AI team on creating model cards, a documentation framework for more transparent machine learning model reporting. She also co-led the development of internal auditing practices at Google. Her contributions at Google were separately presented and published at the AAAI conference and ACM Conference on Fairness, Accountability, and Transparency.
In 2019, Raji was a summer research fellow at The Partnership on AI working on setting industry machine learning transparency standards and benchmarking norms. Raji was a Tech Fellow at the AI Now Institute worked on algorithmic and AI auditing. Currently, she is a fellow at the Mozilla Foundation researching algorithmic auditing and evaluation.
Raji's work on bias in facial recognition systems has been highlighted in the 2020 documentary Coded Bias directed by Shalini Kantayya.
Selected awards
2019 Venture Beat AI Innovations Award in category AI for Good (received with Joy Buolamwini and Timnit Gebru)
2020 MIT Technology Review 35 Under 35 Innovator Award
2020 EFF Pioneer Award (received with Buolamwini and Gebru)
2021 Forbes 30 Under 30 Award in Enterprise Technology
2021 100 Brilliant Women in AI Ethics Hall of Fame Honoree
2023 Time magazine 100 Most Influential People in AI
References
Living people
1990s births
Artificial intelligence researchers
University of Toronto alumni
Mozilla people
Canadian computer scientists
People from Mississauga
Scientists from Ontario
Machine learning researchers
MIT Media Lab
Facial recognition software
Canadian women computer scientists
Computer vision researchers
Black Canadian scientists
Black Canadian women
Nigerian emigrants to Canada
|
Archiac () is a commune in the Charente-Maritime department in the Nouvelle-Aquitaine region of southwestern France.
The inhabitants of the commune are known as Archiacais or Archiacaises.
Geography
Archiac is located in the south of the department of Charente Maritime in the historic region of Saintonge some 20 km south of Cognac, 15 km north-west of Barbezieux-Saint-Hilaire and 15 km north-east of Jonzac. The village has the status of a town and is located at the intersection of two main highways: the D699 from Arthenac in the south-west to Ambleville in the north-east; and the D731 from Cierzac in the north-west which continues south-east from the village. The north-eastern border of the commune is also the border between Charente-Maritime and Charente departments. Other access roads include the D149 which is a short-cut connection between the D699 and the D733 west of the village and the D152 which goes south from the village to Saint-Maigrin. There are also the hamlets of La Grue and Saint-Pierre north-east of the village. Apart from some wooded areas near the village the commune is entirely farmland.
Neighbouring communes and villages
History
In the reign of Charlemagne Archiac was the seat of a viguerie.
Upon the removal of Emma, the wife of the lord of Cognac, by the lord of Barbezieux in the 11th century, the Lord of Archiac gave them asylum: the castle was attacked, taken, and burnt.
In 1219 the Lord of Archiac was Guillaume d'Archiac. During the Hundred Years War the castle was taken and retaken then became a den of Anglo-Gascon thieves before being taken and demolished.
In 1609 the Barony of Archiac was raised to a marquisate.
It was forbidden for the Protestant ministers Jacques Fountaines and Jean Hoummeau to preach and the temple was demolished in 1673.
Heraldry
Administration
List of successive mayors
Demography
In 2017 the commune had 772 inhabitants. Arthenac was part of the Archiac commune until they were separated in 1831; the population data given in the table and graph below for 1821 and earlier include the commune of Arthenac.
Distribution of age groups
The population of the town is older than the departmental average.
Percentage distribution of age groups in Archiac and Charente-Maritime Department in 2017
Source: INSEE
Sites and monuments
The Parish Church of Saint-Pierre has a fragment of a statue from the Middle Ages depicting a mitred head which is registered as an historical object.
A dolmen near Lavaure
A chateau from the 9th century, repaired in the 11th century but now disappeared. It included the chapels of Our Lady and Saint-Martin.
The House of the Vine and Fragrances
Notable people linked to the commune
Cardinal Simon d'Archiac (14th century), born in Archiac
See also
Communes of the Charente-Maritime department
References
External links
Archiac on the National Geographic Institute website
Archiac on Géoportail, National Geographic Institute (IGN) website
Archiac on the 1750 Cassini Map
Communes of Charente-Maritime
Arrondissement of Jonzac
|
```javascript
/*
For licensing, see LICENSE.md or path_to_url
*/
CKEDITOR.plugins.setLang("widget","ug",{move:" ",label:"%1 widget"});
```
|
Henneberg is a village and a former municipality in the district Schmalkalden-Meiningen, in Thuringia, Germany. Since 1 January 2019, it is part of the town Meiningen. It was the origin of the medieval House of Henneberg.
References
Former municipalities in Thuringia
Schmalkalden-Meiningen
Duchy of Saxe-Meiningen
|
```go
// Package jaeger allows converting model.Trace to/from jaeger.thrift model.
package jaeger
```
|
Wólka Bagnowska is a village in the administrative district of Gmina Mrągowo, within Mrągowo County, Warmian-Masurian Voivodeship, in northern Poland. It lies approximately south-west of Mrągowo and east of the regional capital Olsztyn.
References
Villages in Mrągowo County
|
```yaml
# Do not edit. Data is from res/country/metadata and path_to_url
atmOperators: [Caixa Geral de Depsitos, Euronet, Crdito Agrcola, Multibanco, Santander Totta, SIBS, Montepio, Millennium bcp, Novo Banco, Banco Santander, Millennium BCP, Euronet Worldwide, Santander, MB Multibanco, Banco BPI, ATMExpress, BPI, Millennium, EuroBic, CGD, Branco BPI, ATM, Caixa Agrcola, Bankinter, ATM Express, multibanco, Banco Montepio, Millenium bcp, Millenium, Caixa de Crdito Agrcola, CCAM, BES, Crdito Agricola, Cashzone, Banco Popular, Banco CTT, Abanca, crdito agrcola, bankinter, Western Union, SIBS Multibanco, Mind the Coin, Deutsche Bank, Credit Agricole, Caixa Agricola, Barclays, Banif, BCP Millenium, ActivoBank]
chargingStationOperators: [EDP Comercial, Galp Power, Powerdot, Atlante, KLC Servios, Wowplug, Tesla, Galp Geste, Repsol, Iberdrola, Prio.E, Mobiletric, EDP, Sonae, Helexia II, MobiSmart, Maksu Services, Porsche, EV Power, Mota Engil II, Moon, Charging Together, Loul Concelho Global, E-Plug, Hexagonal Ocean, Generation Journey, Ucharge, EMEL, EcoInside, powercharge, GreenCharge, Ionity, High Green Power, Evaz Energy, Cepsa, Bluecharge, Renault, Nissan, CapWatt, Luzigs, Evio, DTE, DPC-Privado, Mobi.E, Circuitos Energy Solutions, Neureifen, NRG, Cargga Inteligente, guas de Portugal, Cascais Proxima]
clothesContainerOperators: [Ultriplo, Ultriplo Lda, Humana Portugal, H Sarah Trading, Wippytex, Projeto Amigo, Fundao o Sculo, FILTEX & reciclagem, Cmara Municipal de Lisboa, Critas Diocesana de Lisboa, Critas, utriplo, Sarah Trading, ResiNorte]
defaultSpeedLimitHasUrbanOrRural: true
hasAdvisoryCycleLane: false
hasAdvisorySpeedLimitSign: true
hasSlowZone: true
mobileCountryCode: 268
noParkingLineStyle: dashed yellow
noStoppingLineStyle: yellow
officialLanguages: [pt]
orchardProduces: [olive, grape, chestnut, almond, orange, tomato, apple, pear, walnut, fig, peach, kiwi, blueberry, avocado, plum]
parcelLockerBrand: [Locky CTT, Locky]
popularReligions: [christian, jewish, muslim]
postboxesHaveCollectionTimes: true
slowZoneLabelPosition: top
slowZoneLabelText: zona
```
|
"Forbidden Fruit" is the third episode of the eighth season of the anthology television series American Horror Story. It aired on September 26, 2018, on the cable network FX. The episode was written by Manny Coto, and directed by Loni Peristere.
Plot
Langdon unveils his true demonic form to Mallory, and she makes flames shoot from a fireplace. Venable confides to Mead that she has not been selected to move on to the Sanctuary and Mead suggests they kill everyone.
Brock navigates a nuclear wasteland and guns down a cannibalistic tribe. He sees a horse-drawn carriage pass by. The carriage delivers apples to Outpost 3, and Venable decides to inject them with venom. Brock infiltrates Outpost 3 and attends Venable's Halloween masquerade ball. Coco, presuming Brock to be Langdon in costume, seduces him back to her bedroom. Brock then reveals himself to Coco and stabs her in the forehead.
The Outpost 3 guests bob for poisonous apples. Venable instructs everyone to wait to eat simultaneously. The guests comply and concurrently succumb to the poison. Venable and Mead confront Langdon, and Venable proclaims that they will be making the selections. Mead attempts to shoot Langdon but finds herself turning the gun on Venable against her will and shooting her, under the order of Langdon. Langdon reveals that he created Mead and that she was modeled after a caregiver from his childhood, which consoles her. Later, Cordelia Goode, Madison Montgomery, and Myrtle Snow descend upon Outpost 3 and Cordelia resurrects Mallory, Dinah, and Coco.
Reception
"Forbidden Fruit" was watched by 1.95 million people during its original broadcast, and gained a 0.9 ratings share among adults aged 18–49.
The episode has been critically acclaimed, with most of the critics praising the cliffhanger. On the review aggregator Rotten Tomatoes, "Forbidden Fruit" holds a 100% approval rating, based on 18 reviews with an average rating of 8.10/10. The critical consensus reads, ""Forbidden Fruit" pushes Apocalypse forward, delivering on the gore, the glee, and most importantly, the girls."
Ron Hogan of Den of Geek gave the episode a 4.5/5, saying, "So far, aside from a mention of genetic perfection, there hasn't been much of a tie-in to the world of the witches (or to the ghosts, for the matter, aside from Michael Langdon's presence). However, that connection was made more openly this week, after a solid episode which featured some very impressive visual trickery from director Loni Peristere. From the cold opening to the surprise at the end, 'Forbidden Fruit' is one of the most impressive editorial feats of the entire series, let alone this season."
Kat Rosenfield from Entertainment Weekly gave the episode a B+. She particularly praised the ball scenes, saying that they are "a serious mashup of various fairytale tropes: poisoned apples, a masquerade ball, and even a Cinderella figure yearning for greater things in the background", and also appreciated all the different twists of the episode. Finally, she enjoyed the cliffhanger with the Coven witches. Vultures Ziwe Fumudoh gave the episode a 5 out of 5, with a positive review. Much like Rosenfield, she particularly praised the death scene of all Outpost 3 inhabitants, commenting that "I have never been so disgusted and so entertained in my life", and also liked the revelation about Mead's and Langdon's relationship. Finally, she really enjoyed the arrival of the witches, and the cliffhanger of the episode.
Matt Fowler of IGN gave the episode a 6.8 out of 10, with a mixed to positive review. He said, "Once the music switched from Bread to Rolling Stones, and the Coven ladies majestically swooped in, things felt infused with more energy. There was a welcome supernatural lightness in those final moments that seemed to coat all the previous ugliness and stuffiness with a silver sheen. That's not to say the season's about to get exponentially better, but it was a very welcome shift from the Lazy Susan of aggravation these past few weeks have offered up."
References
External links
2018 American television episodes
American Horror Story: Apocalypse episodes
Halloween television episodes
Television episodes about mass murder
Poisoning in fiction
|
The following is a list of current records for Apollo asteroids.
Discovery records
1st Discovered: 1862 Apollo (1932)
Size records
Largest: 1866 Sisyphus
Smallest: 2008 TC3 (destroyed in Earth's atmosphere), 2003 SQ222
Orbit element records
Smallest Perihelion: 2004 FN8
Smallest Semi-Major Axis:
Smallest Aphelion: 1991 VG
Largest Perihelion:
Largest Semi-Major Axis: 1999 XS35
Largest Aphelion: 1999 XS35
Lowest Inclination: (152685) 1998 MZ
Highest Inclination: (5496) 1973 NA
Lowest Eccentricity: 1991 VG
Highest Eccentricity:
External links
List of Apollo minor planets
Asteroid records
|
```go
package libvirt
import (
"context"
"fmt"
"log"
"testing"
libvirt "github.com/digitalocean/go-libvirt"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
)
func TestAccLibvirtCloudInit_CreateCloudInitDiskAndUpdate(t *testing.T) {
var volume libvirt.StorageVol
randomResourceName := acctest.RandStringFromCharSet(10, acctest.CharSetAlpha)
randomPoolName := acctest.RandStringFromCharSet(10, acctest.CharSetAlpha)
randomPoolPath := "/tmp/terraform-provider-libvirt-pool-" + randomPoolName
// this structs are contents values we expect.
expectedContents := Expected{UserData: "#cloud-config", NetworkConfig: "network:", MetaData: "instance-id: bamboo"}
expectedContents2 := Expected{UserData: "#cloud-config2", NetworkConfig: "network2:", MetaData: "instance-id: bamboo2"}
expectedContentsEmpty := Expected{UserData: "#cloud-config2", NetworkConfig: "", MetaData: ""}
randomIsoName := acctest.RandStringFromCharSet(10, acctest.CharSetAlpha) + ".iso"
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: func(s *terraform.State) error {
return nil
},
Steps: []resource.TestStep{
{
Config: fmt.Sprintf(`
resource "libvirt_pool" "%s" {
name = "%s"
type = "dir"
path = "%s"
}
resource "libvirt_cloudinit_disk" "%s" {
name = "%s"
user_data = "#cloud-config"
meta_data = "instance-id: bamboo"
network_config = "network:"
pool = "${libvirt_pool.%s.name}"
}`, randomPoolName, randomPoolName, randomPoolPath, randomResourceName, randomIsoName, randomPoolName),
Check: resource.ComposeTestCheckFunc(
resource.TestCheckResourceAttr(
"libvirt_cloudinit_disk."+randomResourceName, "name", randomIsoName),
testAccCheckCloudInitVolumeExists("libvirt_cloudinit_disk."+randomResourceName, &volume),
expectedContents.testAccCheckCloudInitDiskFilesContent("libvirt_cloudinit_disk."+randomResourceName),
),
},
{
Config: fmt.Sprintf(`
resource "libvirt_pool" "%s" {
name = "%s"
type = "dir"
path = "%s"
}
resource "libvirt_cloudinit_disk" "%s" {
name = "%s"
user_data = "#cloud-config2"
meta_data = "instance-id: bamboo2"
network_config = "network2:"
pool = "${libvirt_pool.%s.name}"
}`, randomPoolName, randomPoolName, randomPoolPath, randomResourceName, randomIsoName, randomPoolName),
Check: resource.ComposeTestCheckFunc(
resource.TestCheckResourceAttr(
"libvirt_cloudinit_disk."+randomResourceName, "name", randomIsoName),
testAccCheckCloudInitVolumeExists("libvirt_cloudinit_disk."+randomResourceName, &volume),
expectedContents2.testAccCheckCloudInitDiskFilesContent("libvirt_cloudinit_disk."+randomResourceName),
),
},
{
Config: fmt.Sprintf(`
resource "libvirt_pool" "%s" {
name = "%s"
type = "dir"
path = "%s"
}
resource "libvirt_cloudinit_disk" "%s" {
name = "%s"
user_data = "#cloud-config2"
pool = "${libvirt_pool.%s.name}"
}`, randomPoolName, randomPoolName, randomPoolPath, randomResourceName, randomIsoName, randomPoolName),
Check: resource.ComposeTestCheckFunc(
resource.TestCheckResourceAttr(
"libvirt_cloudinit_disk."+randomResourceName, "name", randomIsoName),
testAccCheckCloudInitVolumeExists("libvirt_cloudinit_disk."+randomResourceName, &volume),
expectedContentsEmpty.testAccCheckCloudInitDiskFilesContent("libvirt_cloudinit_disk."+randomResourceName),
),
},
// when we apply 2 times with same conf, we should not have a diff. See bug:
// path_to_url
{
Config: fmt.Sprintf(`
resource "libvirt_pool" "%s" {
name = "%s"
type = "dir"
path = "%s"
}
resource "libvirt_cloudinit_disk" "%s" {
name = "%s"
user_data = "#cloud-config4"
pool = "${libvirt_pool.%s.name}"
}`, randomPoolName, randomPoolName, randomPoolPath, randomResourceName, randomIsoName, randomPoolName),
ExpectNonEmptyPlan: true,
PlanOnly: true,
Check: resource.ComposeTestCheckFunc(
resource.TestCheckResourceAttr(
"libvirt_cloudinit_disk."+randomResourceName, "name", randomIsoName),
testAccCheckCloudInitVolumeExists("libvirt_cloudinit_disk."+randomResourceName, &volume),
expectedContentsEmpty.testAccCheckCloudInitDiskFilesContent("libvirt_cloudinit_disk."+randomResourceName),
),
},
},
})
}
// The destroy function should always handle the case where the resource might already be destroyed
// (manually, for example). If the resource is already destroyed, this should not return an error.
// This allows Terraform users to manually delete resources without breaking Terraform.
// This test should fail without a proper "Exists" implementation.
func TestAccLibvirtCloudInit_ManuallyDestroyed(t *testing.T) {
var volume libvirt.StorageVol
randomResourceName := acctest.RandStringFromCharSet(10, acctest.CharSetAlpha)
randomPoolName := acctest.RandStringFromCharSet(10, acctest.CharSetAlpha)
randomPoolPath := "/tmp/terraform-provider-libvirt-pool-" + randomPoolName
testAccCheckLibvirtCloudInitConfigBasic := fmt.Sprintf(`
resource "libvirt_pool" "%s" {
name = "%s"
type = "dir"
path = "%s"
}
resource "libvirt_cloudinit_disk" "%s" {
name = "%s"
pool = "${libvirt_pool.%s.name}"
user_data = "#cloud-config\nssh_authorized_keys: []\n"
}`, randomPoolName, randomPoolName, randomPoolPath, randomResourceName, randomResourceName, randomPoolName)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: func(s *terraform.State) error {
return nil
},
Steps: []resource.TestStep{
{
Config: testAccCheckLibvirtCloudInitConfigBasic,
Check: resource.ComposeTestCheckFunc(
testAccCheckCloudInitVolumeExists("libvirt_cloudinit_disk."+randomResourceName, &volume),
),
},
{
Config: testAccCheckLibvirtCloudInitConfigBasic,
Destroy: true,
PreConfig: func() {
client := testAccProvider.Meta().(*Client)
if volume.Key == "" {
t.Fatalf("Key is blank")
}
if err := volumeDelete(context.Background(), client, volume.Key); err != nil {
t.Fatal(err)
}
},
},
},
})
}
func testAccCheckCloudInitVolumeExists(volumeName string, volume *libvirt.StorageVol) resource.TestCheckFunc {
return func(state *terraform.State) error {
virConn := testAccProvider.Meta().(*Client).libvirt
rs, err := getResourceFromTerraformState(volumeName, state)
if err != nil {
return err
}
cikey, err := getCloudInitVolumeKeyFromTerraformID(rs.Primary.ID)
if err != nil {
return err
}
retrievedVol, err := virConn.StorageVolLookupByKey(cikey)
if err != nil {
return err
}
if retrievedVol.Key == "" {
return fmt.Errorf("UUID is blank")
}
if retrievedVol.Key != cikey {
log.Printf("[DEBUG]: retrievedVol.Key is: %s \ncloudinit key is %s", retrievedVol.Key, cikey)
return fmt.Errorf("Resource ID and cloudinit volume key does not match")
}
*volume = retrievedVol
return nil
}
}
// this is helper method for test expected values.
type Expected struct {
UserData, NetworkConfig, MetaData string
}
func (expected *Expected) testAccCheckCloudInitDiskFilesContent(volumeName string) resource.TestCheckFunc {
return func(state *terraform.State) error {
virConn := testAccProvider.Meta().(*Client).libvirt
rs, err := getResourceFromTerraformState(volumeName, state)
if err != nil {
return err
}
cloudInitDiskDef, err := newCloudInitDefFromRemoteISO(context.Background(), virConn, rs.Primary.ID)
if err != nil {
return err
}
if cloudInitDiskDef.MetaData != expected.MetaData {
return fmt.Errorf("metadata '%s' content differs from expected Metadata %s", cloudInitDiskDef.MetaData, expected.MetaData)
}
if cloudInitDiskDef.UserData != expected.UserData {
return fmt.Errorf("userdata '%s' content differs from expected UserData %s", cloudInitDiskDef.UserData, expected.UserData)
}
if cloudInitDiskDef.NetworkConfig != expected.NetworkConfig {
return fmt.Errorf("networkconfig '%s' content differs from expected NetworkConfigData %s", cloudInitDiskDef.NetworkConfig, expected.NetworkConfig)
}
return nil
}
}
```
|
```c++
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
//
// Multipolygon DP simplification example from the mailing list discussion
// about the DP algorithm issue:
// path_to_url
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/ring.hpp>
#include <boost/geometry/geometries/multi_polygon.hpp>
#include <boost/foreach.hpp>
int main()
{
typedef boost::geometry::model::d2::point_xy<double> point_xy;
typedef boost::geometry::model::polygon<point_xy > polygon;
typedef boost::geometry::model::ring<point_xy > ring;
typedef boost::geometry::model::multi_polygon<polygon > multi_polygon;
multi_polygon original_1;
multi_polygon simplified_1;
// Values between 0..1 and simplified with 1/2048
boost::geometry::read_wkt("MULTIPOLYGON(((0.561648 1,1 1,1 0,0.468083 0,0.52758 0.00800554,0.599683 0.0280924,0.601611 0.265374,0.622693 0.316765,0.69507 0.357497,0.695623 0.429711,0.655111 0.502298,0.696467 0.543147,0.840712 0.593546,0.882583 0.66546,0.852357 0.748213,0.84264 0.789567,0.832667 0.841202,0.832667 0.841202,0.740538 0.873004,0.617349 0.905045,0.566576 0.977697,0.561648 1)),((0 0.801979,0.0308575 0.786234,0.0705513 0.631135,0.141616 0.527248,0.233985 0.505872,0.264777 0.526263,0.336631 0.505009,0.356603 0.422321,0.355803 0.350038,0.375252 0.205364,0.415206 0.0709182,0.45479 0,0 0,0 0,0 0.801979)))", original_1);
std::cout << "Original: \n" << boost::geometry::num_points(original_1) << " points.\n\n";
boost::geometry::simplify(original_1, simplified_1, 1.0 / 2048.0);
std::cout << "Polygon with values 0..1 and simplified with 1.0 / 2048.0 \n"
<< "Result: \n" << boost::geometry::wkt(simplified_1) << "\n" << boost::geometry::num_points(simplified_1) << " points.\n\n";
// Multiply every points from original_1 by 2047
multi_polygon original_2(original_1);
BOOST_FOREACH(polygon& p, original_2)
{
BOOST_FOREACH(point_xy& pt, p.outer())
{
pt.x(pt.x() * 2047.0);
pt.y(pt.y() * 2047.0);
}
BOOST_FOREACH(ring& r, p.inners())
{
BOOST_FOREACH(point_xy& pt, r)
{
pt.x(pt.x() * 2047.0);
pt.y(pt.y() * 2047.0);
}
}
}
multi_polygon simplified_2;
boost::geometry::simplify(original_2, simplified_2, 1.0);
std::cout << "Same values but multiplied by 2047.0 and simplified with 1.0\n"
<< "Result: \n" << boost::geometry::wkt(simplified_2) << "\n" << boost::geometry::num_points(simplified_2) << " points.\n";
return 0;
}
```
|
Kevin Foyle (born 19 June 1962, in Hammersmith) was an English cricketer. He was a right-handed batsman and leg-break bowler who played for Wiltshire.
Foyle, who played in the Second XI Championship for Leicestershire and then Derbyshire between 1983 and 1986, played in the Minor Counties Championship for Wiltshire between 1988 and 1994. Foyle made his debut List A appearance for the team against Essex in 1988, and made two further appearances in the competition, in 1990 and 1993.
In the three innings he batted, he scored 22 runs, including a top score of 16 runs.
External links
Kevin Foyle at Cricket Archive
1962 births
Living people
English cricketers
Wiltshire cricketers
Cricketers from Hammersmith
Wiltshire cricket captains
|
Franke Sloothaak (born 2 February 1958 in Heerenveen, the Netherlands) is a German show jumping champion, Olympic champion from 1988 and 1996.
Olympic Record
Sloothaak competed for West Germany at the 1984 Summer Olympics in Los Angeles, where he received a bronze medal in team jumping with Farmer, and at the 1988 Summer Olympics in Seoul, where the team received a gold medal.
He participated for Germany at the 1996 Summer Olympics in Atlanta, where he won a gold medal in Team Jumping, together with Lars Nieberg, Ulrich Kirchhoff and Ludger Beerbaum.
Sloothaak still holds the world record for the indoor Puissance. In June 1991, Sloothaak jumped a record-breaking 2.40 m (7 ft 10 in) in Chaudfontaine, Belgium on the horse Optiebeurs Golo.
References
1958 births
Living people
Olympic gold medalists for Germany
Olympic gold medalists for West Germany
Olympic bronze medalists for West Germany
Equestrians at the 1984 Summer Olympics
Equestrians at the 1988 Summer Olympics
Equestrians at the 1992 Summer Olympics
Equestrians at the 1996 Summer Olympics
Olympic equestrians for West Germany
Olympic equestrians for Germany
German male equestrians
Dutch emigrants to Germany
Sportspeople from Heerenveen
Olympic medalists in equestrian
Medalists at the 1996 Summer Olympics
Medalists at the 1988 Summer Olympics
Medalists at the 1984 Summer Olympics
|
```java
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.thingsboard.server.queue.provider;
import jakarta.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.stereotype.Component;
import org.thingsboard.server.gen.transport.TransportProtos;
import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceMsg;
import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
import org.thingsboard.server.queue.TbQueueAdmin;
import org.thingsboard.server.queue.TbQueueConsumer;
import org.thingsboard.server.queue.TbQueueProducer;
import org.thingsboard.server.queue.TbQueueRequestTemplate;
import org.thingsboard.server.queue.azure.servicebus.TbServiceBusAdmin;
import org.thingsboard.server.queue.azure.servicebus.TbServiceBusConsumerTemplate;
import org.thingsboard.server.queue.azure.servicebus.TbServiceBusProducerTemplate;
import org.thingsboard.server.queue.azure.servicebus.TbServiceBusQueueConfigs;
import org.thingsboard.server.queue.azure.servicebus.TbServiceBusSettings;
import org.thingsboard.server.queue.common.DefaultTbQueueRequestTemplate;
import org.thingsboard.server.queue.common.TbProtoQueueMsg;
import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;
import org.thingsboard.server.queue.discovery.TopicService;
import org.thingsboard.server.queue.settings.TbQueueCoreSettings;
import org.thingsboard.server.queue.settings.TbQueueRuleEngineSettings;
import org.thingsboard.server.queue.settings.TbQueueTransportApiSettings;
import org.thingsboard.server.queue.settings.TbQueueTransportNotificationSettings;
@Component
@ConditionalOnExpression("'${queue.type:null}'=='service-bus' && (('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true') || '${service.type:null}'=='tb-transport')")
@Slf4j
public class ServiceBusTransportQueueFactory implements TbTransportQueueFactory {
private final TbQueueTransportApiSettings transportApiSettings;
private final TbQueueTransportNotificationSettings transportNotificationSettings;
private final TbServiceBusSettings serviceBusSettings;
private final TbServiceInfoProvider serviceInfoProvider;
private final TbQueueCoreSettings coreSettings;
private final TbQueueRuleEngineSettings ruleEngineSettings;
private final TopicService topicService;
private final TbQueueAdmin coreAdmin;
private final TbQueueAdmin transportApiAdmin;
private final TbQueueAdmin notificationAdmin;
private final TbQueueAdmin ruleEngineAdmin;
public ServiceBusTransportQueueFactory(TbQueueTransportApiSettings transportApiSettings,
TbQueueTransportNotificationSettings transportNotificationSettings,
TbServiceBusSettings serviceBusSettings,
TbQueueRuleEngineSettings ruleEngineSettings,
TbServiceInfoProvider serviceInfoProvider,
TbQueueCoreSettings coreSettings,
TbServiceBusQueueConfigs serviceBusQueueConfigs,
TopicService topicService) {
this.transportApiSettings = transportApiSettings;
this.transportNotificationSettings = transportNotificationSettings;
this.serviceBusSettings = serviceBusSettings;
this.serviceInfoProvider = serviceInfoProvider;
this.coreSettings = coreSettings;
this.ruleEngineSettings = ruleEngineSettings;
this.topicService = topicService;
this.coreAdmin = new TbServiceBusAdmin(serviceBusSettings, serviceBusQueueConfigs.getCoreConfigs());
this.transportApiAdmin = new TbServiceBusAdmin(serviceBusSettings, serviceBusQueueConfigs.getTransportApiConfigs());
this.notificationAdmin = new TbServiceBusAdmin(serviceBusSettings, serviceBusQueueConfigs.getNotificationsConfigs());
this.ruleEngineAdmin = new TbServiceBusAdmin(serviceBusSettings, serviceBusQueueConfigs.getRuleEngineConfigs());
}
@Override
public TbQueueRequestTemplate<TbProtoQueueMsg<TransportApiRequestMsg>, TbProtoQueueMsg<TransportApiResponseMsg>> createTransportApiRequestTemplate() {
TbQueueProducer<TbProtoQueueMsg<TransportApiRequestMsg>> producerTemplate =
new TbServiceBusProducerTemplate<>(transportApiAdmin, serviceBusSettings, topicService.buildTopicName(transportApiSettings.getRequestsTopic()));
TbQueueConsumer<TbProtoQueueMsg<TransportApiResponseMsg>> consumerTemplate =
new TbServiceBusConsumerTemplate<>(transportApiAdmin, serviceBusSettings,
topicService.buildTopicName(transportApiSettings.getResponsesTopic() + "." + serviceInfoProvider.getServiceId()),
msg -> new TbProtoQueueMsg<>(msg.getKey(), TransportApiResponseMsg.parseFrom(msg.getData()), msg.getHeaders()));
DefaultTbQueueRequestTemplate.DefaultTbQueueRequestTemplateBuilder
<TbProtoQueueMsg<TransportApiRequestMsg>, TbProtoQueueMsg<TransportApiResponseMsg>> templateBuilder = DefaultTbQueueRequestTemplate.builder();
templateBuilder.queueAdmin(transportApiAdmin);
templateBuilder.requestTemplate(producerTemplate);
templateBuilder.responseTemplate(consumerTemplate);
templateBuilder.maxPendingRequests(transportApiSettings.getMaxPendingRequests());
templateBuilder.maxRequestTimeout(transportApiSettings.getMaxRequestsTimeout());
templateBuilder.pollInterval(transportApiSettings.getResponsePollInterval());
return templateBuilder.build();
}
@Override
public TbQueueProducer<TbProtoQueueMsg<ToRuleEngineMsg>> createRuleEngineMsgProducer() {
return new TbServiceBusProducerTemplate<>(ruleEngineAdmin, serviceBusSettings, topicService.buildTopicName(ruleEngineSettings.getTopic()));
}
@Override
public TbQueueProducer<TbProtoQueueMsg<ToCoreMsg>> createTbCoreMsgProducer() {
return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, topicService.buildTopicName(coreSettings.getTopic()));
}
@Override
public TbQueueProducer<TbProtoQueueMsg<ToCoreNotificationMsg>> createTbCoreNotificationsMsgProducer() {
return new TbServiceBusProducerTemplate<>(notificationAdmin, serviceBusSettings, topicService.buildTopicName(coreSettings.getTopic()));
}
@Override
public TbQueueConsumer<TbProtoQueueMsg<ToTransportMsg>> createTransportNotificationsConsumer() {
return new TbServiceBusConsumerTemplate<>(notificationAdmin, serviceBusSettings,
topicService.buildTopicName(transportNotificationSettings.getNotificationsTopic() + "." + serviceInfoProvider.getServiceId()),
msg -> new TbProtoQueueMsg<>(msg.getKey(), ToTransportMsg.parseFrom(msg.getData()), msg.getHeaders()));
}
@Override
public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, topicService.buildTopicName(coreSettings.getUsageStatsTopic()));
}
@Override
public TbQueueProducer<TbProtoQueueMsg<TransportProtos.ToHousekeeperServiceMsg>> createHousekeeperMsgProducer() {
return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, topicService.buildTopicName(coreSettings.getHousekeeperTopic()));
}
@PreDestroy
private void destroy() {
if (coreAdmin != null) {
coreAdmin.destroy();
}
if (transportApiAdmin != null) {
transportApiAdmin.destroy();
}
if (notificationAdmin != null) {
notificationAdmin.destroy();
}
if (ruleEngineAdmin != null) {
ruleEngineAdmin.destroy();
}
}
}
```
|
```go
// Code generated by smithy-go-codegen DO NOT EDIT.
package ec2
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Associates an Identity and Access Management (IAM) role with an Certificate
// Manager (ACM) certificate. This enables the certificate to be used by the ACM
// for Nitro Enclaves application inside an enclave. For more information, see [Certificate Manager for Nitro Enclaves]in
// the Amazon Web Services Nitro Enclaves User Guide.
//
// When the IAM role is associated with the ACM certificate, the certificate,
// certificate chain, and encrypted private key are placed in an Amazon S3 location
// that only the associated IAM role can access. The private key of the certificate
// is encrypted with an Amazon Web Services managed key that has an attached
// attestation-based key policy.
//
// To enable the IAM role to access the Amazon S3 object, you must grant it
// permission to call s3:GetObject on the Amazon S3 bucket returned by the
// command. To enable the IAM role to access the KMS key, you must grant it
// permission to call kms:Decrypt on the KMS key returned by the command. For more
// information, see [Grant the role permission to access the certificate and encryption key]in the Amazon Web Services Nitro Enclaves User Guide.
//
// [Certificate Manager for Nitro Enclaves]: path_to_url
// [Grant the role permission to access the certificate and encryption key]: path_to_url#add-policy
func (c *Client) AssociateEnclaveCertificateIamRole(ctx context.Context, params *AssociateEnclaveCertificateIamRoleInput, optFns ...func(*Options)) (*AssociateEnclaveCertificateIamRoleOutput, error) {
if params == nil {
params = &AssociateEnclaveCertificateIamRoleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssociateEnclaveCertificateIamRole", params, optFns, c.addOperationAssociateEnclaveCertificateIamRoleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssociateEnclaveCertificateIamRoleOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssociateEnclaveCertificateIamRoleInput struct {
// The ARN of the ACM certificate with which to associate the IAM role.
//
// This member is required.
CertificateArn *string
// The ARN of the IAM role to associate with the ACM certificate. You can
// associate up to 16 IAM roles with an ACM certificate.
//
// This member is required.
RoleArn *string
// Checks whether you have the required permissions for the action, without
// actually making the request, and provides an error response. If you have the
// required permissions, the error response is DryRunOperation . Otherwise, it is
// UnauthorizedOperation .
DryRun *bool
noSmithyDocumentSerde
}
type AssociateEnclaveCertificateIamRoleOutput struct {
// The name of the Amazon S3 bucket to which the certificate was uploaded.
CertificateS3BucketName *string
// The Amazon S3 object key where the certificate, certificate chain, and
// encrypted private key bundle are stored. The object key is formatted as follows:
// role_arn / certificate_arn .
CertificateS3ObjectKey *string
// The ID of the KMS key used to encrypt the private key of the certificate.
EncryptionKmsKeyId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssociateEnclaveCertificateIamRoleMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsEc2query_serializeOpAssociateEnclaveCertificateIamRole{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "AssociateEnclaveCertificateIamRole"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addTimeOffsetBuild(stack, c); err != nil {
return err
}
if err = addUserAgentRetryMode(stack, options); err != nil {
return err
}
if err = addOpAssociateEnclaveCertificateIamRoleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(your_sha256_hashe(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
func your_sha256_hashe(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "AssociateEnclaveCertificateIamRole",
}
}
```
|
```yaml
# Each section from every release note are combined when the
# CHANGELOG.rst is rendered. So the text needs to be worded so that
# it does not depend on any information only available in another
# section. This may mean repeating some details, but each section
# must be readable independently of the other.
#
# Each section note must be formatted as reStructuredText.
---
features:
- |
Exposed additional *experimental* configuration for OTLP metrics
translation via ``experimental.otlp.metrics``.
```
|
Season 1880–81 was the fourth in which Hibernian competed at a Scottish national level, entering the Scottish Cup for the fourth time.
Overview
Hibs reached the third round of the Scottish Cup, losing 5–3 to Edinburgh derby rivals Hearts. The match was played in the Powderhall area of Edinburgh.
Results
All results are written with Hibs' score first.
Scottish Cup
See also
List of Hibernian F.C. seasons
References
External links
Results For Season 1880/1881 in All Competitions, www.ihibs.co.uk
Hibernian F.C. seasons
Hibernian
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var isFunction = require( '@stdlib/assert/is-function' );
var Buffer = require( '@stdlib/buffer/ctor' );
var version = require( './node_version.js' );
// MAIN //
var bool = isFunction( Buffer.from ) && version >= 5;
// EXPORTS //
module.exports = bool;
```
|
```java
package com.ctrip.xpipe.redis.proxy.tunnel;
/**
* @author chen.zhu
* <p>
* Oct 31, 2018
*/
public interface TunnelEventHandler {
void onEstablished();
void onBackendClose();
void onFrontendClose();
void onClosing();
void onClosed();
}
```
|
Toshiyuki Tsuru (都留 稔幸) is an anime director known for his work on the feature film Naruto the Movie 3: The Animal Riot of Crescent Moon Island.
He also directed the anime series Gungrave.
Filmography
References
External links
Living people
Japanese film directors
Year of birth missing (living people)
|
```c
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <pthread.h>
#define MAX_STRING 100
#define EXP_TABLE_SIZE 1000
#define MAX_EXP 6
#define MAX_SENTENCE_LENGTH 1000
#define MAX_CODE_LENGTH 40
const int vocab_hash_size = 30000000; // Maximum 30 * 0.7 = 21M words in the vocabulary
typedef float real; // Precision of float numbers
struct vocab_word {
long long cn;
int *point;
char *word, *code, codelen;
};
char train_file[MAX_STRING], output_file[MAX_STRING];
char save_vocab_file[MAX_STRING], read_vocab_file[MAX_STRING];
struct vocab_word *vocab;
int binary = 0, cbow = 1, debug_mode = 2, window = 5, min_count = 5, num_threads = 12, min_reduce = 1;
int *vocab_hash;
long long vocab_max_size = 1000, vocab_size = 0, layer1_size = 100;
long long train_words = 0, word_count_actual = 0, iter = 5, file_size = 0, classes = 0;
real alpha = 0.025, starting_alpha, sample = 1e-3;
real *syn0, *syn1, *syn1neg, *expTable;
clock_t start;
int hs = 0, negative = 5;
const int table_size = 1e8;
int *table;
void InitUnigramTable() {
int a, i;
long long train_words_pow = 0;
real d1, power = 0.75;
table = (int *)malloc(table_size * sizeof(int));
for (a = 0; a < vocab_size; a++) train_words_pow += pow(vocab[a].cn, power);
i = 0;
d1 = pow(vocab[i].cn, power) / (real)train_words_pow;
for (a = 0; a < table_size; a++) {
table[a] = i;
if (a / (real)table_size > d1) {
i++;
d1 += pow(vocab[i].cn, power) / (real)train_words_pow;
}
if (i >= vocab_size) i = vocab_size - 1;
}
}
// Reads a single word from a file, assuming space + tab + EOL to be word boundaries
void ReadWord(char *word, FILE *fin) {
int a = 0, ch;
while (!feof(fin)) {
ch = fgetc(fin);
if (ch == 13) continue;
if ((ch == ' ') || (ch == '\t') || (ch == '\n')) {
if (a > 0) {
if (ch == '\n') ungetc(ch, fin);
break;
}
if (ch == '\n') {
strcpy(word, (char *)"</s>");
return;
} else continue;
}
word[a] = ch;
a++;
if (a >= MAX_STRING - 1) a--; // Truncate too long words
}
word[a] = 0;
}
// Returns hash value of a word
int GetWordHash(char *word) {
unsigned long long a, hash = 0;
for (a = 0; a < strlen(word); a++) hash = hash * 257 + word[a];
hash = hash % vocab_hash_size;
return hash;
}
// Returns position of a word in the vocabulary; if the word is not found, returns -1
int SearchVocab(char *word) {
unsigned int hash = GetWordHash(word);
while (1) {
if (vocab_hash[hash] == -1) return -1;
if (!strcmp(word, vocab[vocab_hash[hash]].word)) return vocab_hash[hash];
hash = (hash + 1) % vocab_hash_size;
}
return -1;
}
// Reads a word and returns its index in the vocabulary
int ReadWordIndex(FILE *fin) {
char word[MAX_STRING];
ReadWord(word, fin);
if (feof(fin)) return -1;
return SearchVocab(word);
}
// Adds a word to the vocabulary
int AddWordToVocab(char *word) {
unsigned int hash, length = strlen(word) + 1;
if (length > MAX_STRING) length = MAX_STRING;
vocab[vocab_size].word = (char *)calloc(length, sizeof(char));
strcpy(vocab[vocab_size].word, word);
vocab[vocab_size].cn = 0;
vocab_size++;
// Reallocate memory if needed
if (vocab_size + 2 >= vocab_max_size) {
vocab_max_size += 1000;
vocab = (struct vocab_word *)realloc(vocab, vocab_max_size * sizeof(struct vocab_word));
}
hash = GetWordHash(word);
while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
vocab_hash[hash] = vocab_size - 1;
return vocab_size - 1;
}
// Used later for sorting by word counts
int VocabCompare(const void *a, const void *b) {
return ((struct vocab_word *)b)->cn - ((struct vocab_word *)a)->cn;
}
// Sorts the vocabulary by frequency using word counts
void SortVocab() {
int a, size;
unsigned int hash;
// Sort the vocabulary and keep </s> at the first position
qsort(&vocab[1], vocab_size - 1, sizeof(struct vocab_word), VocabCompare);
for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
size = vocab_size;
train_words = 0;
for (a = 0; a < size; a++) {
// Words occuring less than min_count times will be discarded from the vocab
if ((vocab[a].cn < min_count) && (a != 0)) {
vocab_size--;
free(vocab[a].word);
} else {
// Hash will be re-computed, as after the sorting it is not actual
hash=GetWordHash(vocab[a].word);
while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
vocab_hash[hash] = a;
train_words += vocab[a].cn;
}
}
vocab = (struct vocab_word *)realloc(vocab, (vocab_size + 1) * sizeof(struct vocab_word));
// Allocate memory for the binary tree construction
for (a = 0; a < vocab_size; a++) {
vocab[a].code = (char *)calloc(MAX_CODE_LENGTH, sizeof(char));
vocab[a].point = (int *)calloc(MAX_CODE_LENGTH, sizeof(int));
}
}
// Reduces the vocabulary by removing infrequent tokens
void ReduceVocab() {
int a, b = 0;
unsigned int hash;
for (a = 0; a < vocab_size; a++) if (vocab[a].cn > min_reduce) {
vocab[b].cn = vocab[a].cn;
vocab[b].word = vocab[a].word;
b++;
} else free(vocab[a].word);
vocab_size = b;
for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
for (a = 0; a < vocab_size; a++) {
// Hash will be re-computed, as it is not actual
hash = GetWordHash(vocab[a].word);
while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
vocab_hash[hash] = a;
}
fflush(stdout);
min_reduce++;
}
// Create binary Huffman tree using the word counts
// Frequent words will have short uniqe binary codes
void CreateBinaryTree() {
long long a, b, i, min1i, min2i, pos1, pos2, point[MAX_CODE_LENGTH];
char code[MAX_CODE_LENGTH];
long long *count = (long long *)calloc(vocab_size * 2 + 1, sizeof(long long));
long long *binary = (long long *)calloc(vocab_size * 2 + 1, sizeof(long long));
long long *parent_node = (long long *)calloc(vocab_size * 2 + 1, sizeof(long long));
for (a = 0; a < vocab_size; a++) count[a] = vocab[a].cn;
for (a = vocab_size; a < vocab_size * 2; a++) count[a] = 1e15;
pos1 = vocab_size - 1;
pos2 = vocab_size;
// Following algorithm constructs the Huffman tree by adding one node at a time
for (a = 0; a < vocab_size - 1; a++) {
// First, find two smallest nodes 'min1, min2'
if (pos1 >= 0) {
if (count[pos1] < count[pos2]) {
min1i = pos1;
pos1--;
} else {
min1i = pos2;
pos2++;
}
} else {
min1i = pos2;
pos2++;
}
if (pos1 >= 0) {
if (count[pos1] < count[pos2]) {
min2i = pos1;
pos1--;
} else {
min2i = pos2;
pos2++;
}
} else {
min2i = pos2;
pos2++;
}
count[vocab_size + a] = count[min1i] + count[min2i];
parent_node[min1i] = vocab_size + a;
parent_node[min2i] = vocab_size + a;
binary[min2i] = 1;
}
// Now assign binary code to each vocabulary word
for (a = 0; a < vocab_size; a++) {
b = a;
i = 0;
while (1) {
code[i] = binary[b];
point[i] = b;
i++;
b = parent_node[b];
if (b == vocab_size * 2 - 2) break;
}
vocab[a].codelen = i;
vocab[a].point[0] = vocab_size - 2;
for (b = 0; b < i; b++) {
vocab[a].code[i - b - 1] = code[b];
vocab[a].point[i - b] = point[b] - vocab_size;
}
}
free(count);
free(binary);
free(parent_node);
}
void LearnVocabFromTrainFile() {
char word[MAX_STRING];
FILE *fin;
long long a, i;
for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
fin = fopen(train_file, "rb");
if (fin == NULL) {
printf("ERROR: training data file not found!\n");
exit(1);
}
vocab_size = 0;
AddWordToVocab((char *)"</s>");
while (1) {
ReadWord(word, fin);
if (feof(fin)) break;
train_words++;
if ((debug_mode > 1) && (train_words % 100000 == 0)) {
printf("%lldK%c", train_words / 1000, 13);
fflush(stdout);
}
i = SearchVocab(word);
if (i == -1) {
a = AddWordToVocab(word);
vocab[a].cn = 1;
} else vocab[i].cn++;
if (vocab_size > vocab_hash_size * 0.7) ReduceVocab();
}
SortVocab();
if (debug_mode > 0) {
printf("Vocab size: %lld\n", vocab_size);
printf("Words in train file: %lld\n", train_words);
}
file_size = ftell(fin);
fclose(fin);
}
void SaveVocab() {
long long i;
FILE *fo = fopen(save_vocab_file, "wb");
for (i = 0; i < vocab_size; i++) fprintf(fo, "%s %lld\n", vocab[i].word, vocab[i].cn);
fclose(fo);
}
void ReadVocab() {
long long a, i = 0;
char c;
char word[MAX_STRING];
FILE *fin = fopen(read_vocab_file, "rb");
if (fin == NULL) {
printf("Vocabulary file not found\n");
exit(1);
}
for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
vocab_size = 0;
while (1) {
ReadWord(word, fin);
if (feof(fin)) break;
a = AddWordToVocab(word);
fscanf(fin, "%lld%c", &vocab[a].cn, &c);
i++;
}
SortVocab();
if (debug_mode > 0) {
printf("Vocab size: %lld\n", vocab_size);
printf("Words in train file: %lld\n", train_words);
}
fin = fopen(train_file, "rb");
if (fin == NULL) {
printf("ERROR: training data file not found!\n");
exit(1);
}
fseek(fin, 0, SEEK_END);
file_size = ftell(fin);
fclose(fin);
}
void InitNet() {
long long a, b;
unsigned long long next_random = 1;
a = posix_memalign((void **)&syn0, 128, (long long)vocab_size * layer1_size * sizeof(real));
if (syn0 == NULL) {printf("Memory allocation failed\n"); exit(1);}
if (hs) {
a = posix_memalign((void **)&syn1, 128, (long long)vocab_size * layer1_size * sizeof(real));
if (syn1 == NULL) {printf("Memory allocation failed\n"); exit(1);}
for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++)
syn1[a * layer1_size + b] = 0;
}
if (negative>0) {
a = posix_memalign((void **)&syn1neg, 128, (long long)vocab_size * layer1_size * sizeof(real));
if (syn1neg == NULL) {printf("Memory allocation failed\n"); exit(1);}
for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++)
syn1neg[a * layer1_size + b] = 0;
}
for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++) {
next_random = next_random * (unsigned long long)25214903917 + 11;
syn0[a * layer1_size + b] = (((next_random & 0xFFFF) / (real)65536) - 0.5) / layer1_size;
}
CreateBinaryTree();
}
void *TrainModelThread(void *id) {
long long a, b, d, cw, word, last_word, sentence_length = 0, sentence_position = 0;
long long word_count = 0, last_word_count = 0, sen[MAX_SENTENCE_LENGTH + 1];
long long l1, l2, c, target, label, local_iter = iter;
unsigned long long next_random = (long long)id;
real f, g;
clock_t now;
real *neu1 = (real *)calloc(layer1_size, sizeof(real));
real *neu1e = (real *)calloc(layer1_size, sizeof(real));
FILE *fi = fopen(train_file, "rb");
fseek(fi, file_size / (long long)num_threads * (long long)id, SEEK_SET);
while (1) {
if (word_count - last_word_count > 10000) {
word_count_actual += word_count - last_word_count;
last_word_count = word_count;
if ((debug_mode > 1)) {
now=clock();
printf("%cAlpha: %f Progress: %.2f%% Words/thread/sec: %.2fk ", 13, alpha,
word_count_actual / (real)(iter * train_words + 1) * 100,
word_count_actual / ((real)(now - start + 1) / (real)CLOCKS_PER_SEC * 1000));
fflush(stdout);
}
alpha = starting_alpha * (1 - word_count_actual / (real)(iter * train_words + 1));
if (alpha < starting_alpha * 0.0001) alpha = starting_alpha * 0.0001;
}
if (sentence_length == 0) {
while (1) {
word = ReadWordIndex(fi);
if (feof(fi)) break;
if (word == -1) continue;
word_count++;
if (word == 0) break;
// The subsampling randomly discards frequent words while keeping the ranking same
if (sample > 0) {
real ran = (sqrt(vocab[word].cn / (sample * train_words)) + 1) * (sample * train_words) / vocab[word].cn;
next_random = next_random * (unsigned long long)25214903917 + 11;
if (ran < (next_random & 0xFFFF) / (real)65536) continue;
}
sen[sentence_length] = word;
sentence_length++;
if (sentence_length >= MAX_SENTENCE_LENGTH) break;
}
sentence_position = 0;
}
if (feof(fi) || (word_count > train_words / num_threads)) {
word_count_actual += word_count - last_word_count;
local_iter--;
if (local_iter == 0) break;
word_count = 0;
last_word_count = 0;
sentence_length = 0;
fseek(fi, file_size / (long long)num_threads * (long long)id, SEEK_SET);
continue;
}
word = sen[sentence_position];
if (word == -1) continue;
for (c = 0; c < layer1_size; c++) neu1[c] = 0;
for (c = 0; c < layer1_size; c++) neu1e[c] = 0;
next_random = next_random * (unsigned long long)25214903917 + 11;
b = next_random % window;
if (cbow) { //train the cbow architecture
// in -> hidden
cw = 0;
for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
c = sentence_position - window + a;
if (c < 0) continue;
if (c >= sentence_length) continue;
last_word = sen[c];
if (last_word == -1) continue;
for (c = 0; c < layer1_size; c++) neu1[c] += syn0[c + last_word * layer1_size];
cw++;
}
if (cw) {
for (c = 0; c < layer1_size; c++) neu1[c] /= cw;
if (hs) for (d = 0; d < vocab[word].codelen; d++) {
f = 0;
l2 = vocab[word].point[d] * layer1_size;
// Propagate hidden -> output
for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1[c + l2];
if (f <= -MAX_EXP) continue;
else if (f >= MAX_EXP) continue;
else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
// 'g' is the gradient multiplied by the learning rate
g = (1 - vocab[word].code[d] - f) * alpha;
// Propagate errors output -> hidden
for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
// Learn weights hidden -> output
for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * neu1[c];
}
// NEGATIVE SAMPLING
if (negative > 0) for (d = 0; d < negative + 1; d++) {
if (d == 0) {
target = word;
label = 1;
} else {
next_random = next_random * (unsigned long long)25214903917 + 11;
target = table[(next_random >> 16) % table_size];
if (target == 0) target = next_random % (vocab_size - 1) + 1;
if (target == word) continue;
label = 0;
}
l2 = target * layer1_size;
f = 0;
for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1neg[c + l2];
if (f > MAX_EXP) g = (label - 1) * alpha;
else if (f < -MAX_EXP) g = (label - 0) * alpha;
else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * neu1[c];
}
// hidden -> in
for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
c = sentence_position - window + a;
if (c < 0) continue;
if (c >= sentence_length) continue;
last_word = sen[c];
if (last_word == -1) continue;
for (c = 0; c < layer1_size; c++) syn0[c + last_word * layer1_size] += neu1e[c];
}
}
} else { //train skip-gram
for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
c = sentence_position - window + a;
if (c < 0) continue;
if (c >= sentence_length) continue;
last_word = sen[c];
if (last_word == -1) continue;
l1 = last_word * layer1_size;
for (c = 0; c < layer1_size; c++) neu1e[c] = 0;
// HIERARCHICAL SOFTMAX
if (hs) for (d = 0; d < vocab[word].codelen; d++) {
f = 0;
l2 = vocab[word].point[d] * layer1_size;
// Propagate hidden -> output
for (c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1[c + l2];
if (f <= -MAX_EXP) continue;
else if (f >= MAX_EXP) continue;
else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
// 'g' is the gradient multiplied by the learning rate
g = (1 - vocab[word].code[d] - f) * alpha;
// Propagate errors output -> hidden
for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
// Learn weights hidden -> output
for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * syn0[c + l1];
}
// NEGATIVE SAMPLING
if (negative > 0) for (d = 0; d < negative + 1; d++) {
if (d == 0) {
target = word;
label = 1;
} else {
next_random = next_random * (unsigned long long)25214903917 + 11;
target = table[(next_random >> 16) % table_size];
if (target == 0) target = next_random % (vocab_size - 1) + 1;
if (target == word) continue;
label = 0;
}
l2 = target * layer1_size;
f = 0;
for (c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1neg[c + l2];
if (f > MAX_EXP) g = (label - 1) * alpha;
else if (f < -MAX_EXP) g = (label - 0) * alpha;
else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * syn0[c + l1];
}
// Learn weights input -> hidden
for (c = 0; c < layer1_size; c++) syn0[c + l1] += neu1e[c];
}
}
sentence_position++;
if (sentence_position >= sentence_length) {
sentence_length = 0;
continue;
}
}
fclose(fi);
free(neu1);
free(neu1e);
pthread_exit(NULL);
}
void TrainModel() {
long a, b, c, d;
FILE *fo;
pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
printf("Starting training using file %s\n", train_file);
starting_alpha = alpha;
if (read_vocab_file[0] != 0) ReadVocab(); else LearnVocabFromTrainFile();
if (save_vocab_file[0] != 0) SaveVocab();
if (output_file[0] == 0) return;
InitNet();
if (negative > 0) InitUnigramTable();
start = clock();
for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, TrainModelThread, (void *)a);
for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
fo = fopen(output_file, "wb");
if (classes == 0) {
// Save the word vectors
fprintf(fo, "%lld %lld\n", vocab_size, layer1_size);
for (a = 0; a < vocab_size; a++) {
fprintf(fo, "%s ", vocab[a].word);
if (binary) for (b = 0; b < layer1_size; b++) fwrite(&syn0[a * layer1_size + b], sizeof(real), 1, fo);
else for (b = 0; b < layer1_size; b++) fprintf(fo, "%lf ", syn0[a * layer1_size + b]);
fprintf(fo, "\n");
}
} else {
// Run K-means on the word vectors
int clcn = classes, iter = 10, closeid;
int *centcn = (int *)malloc(classes * sizeof(int));
int *cl = (int *)calloc(vocab_size, sizeof(int));
real closev, x;
real *cent = (real *)calloc(classes * layer1_size, sizeof(real));
for (a = 0; a < vocab_size; a++) cl[a] = a % clcn;
for (a = 0; a < iter; a++) {
for (b = 0; b < clcn * layer1_size; b++) cent[b] = 0;
for (b = 0; b < clcn; b++) centcn[b] = 1;
for (c = 0; c < vocab_size; c++) {
for (d = 0; d < layer1_size; d++) cent[layer1_size * cl[c] + d] += syn0[c * layer1_size + d];
centcn[cl[c]]++;
}
for (b = 0; b < clcn; b++) {
closev = 0;
for (c = 0; c < layer1_size; c++) {
cent[layer1_size * b + c] /= centcn[b];
closev += cent[layer1_size * b + c] * cent[layer1_size * b + c];
}
closev = sqrt(closev);
for (c = 0; c < layer1_size; c++) cent[layer1_size * b + c] /= closev;
}
for (c = 0; c < vocab_size; c++) {
closev = -10;
closeid = 0;
for (d = 0; d < clcn; d++) {
x = 0;
for (b = 0; b < layer1_size; b++) x += cent[layer1_size * d + b] * syn0[c * layer1_size + b];
if (x > closev) {
closev = x;
closeid = d;
}
}
cl[c] = closeid;
}
}
// Save the K-means classes
for (a = 0; a < vocab_size; a++) fprintf(fo, "%s %d\n", vocab[a].word, cl[a]);
free(centcn);
free(cent);
free(cl);
}
fclose(fo);
}
int ArgPos(char *str, int argc, char **argv) {
int a;
for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
if (a == argc - 1) {
printf("Argument missing for %s\n", str);
exit(1);
}
return a;
}
return -1;
}
int main(int argc, char **argv) {
int i;
if (argc == 1) {
printf("WORD VECTOR estimation toolkit v 0.1c\n\n");
printf("Options:\n");
printf("Parameters for training:\n");
printf("\t-train <file>\n");
printf("\t\tUse text data from <file> to train the model\n");
printf("\t-output <file>\n");
printf("\t\tUse <file> to save the resulting word vectors / word clusters\n");
printf("\t-size <int>\n");
printf("\t\tSet size of word vectors; default is 100\n");
printf("\t-window <int>\n");
printf("\t\tSet max skip length between words; default is 5\n");
printf("\t-sample <float>\n");
printf("\t\tSet threshold for occurrence of words. Those that appear with higher frequency in the training data\n");
printf("\t\twill be randomly down-sampled; default is 1e-3, useful range is (0, 1e-5)\n");
printf("\t-hs <int>\n");
printf("\t\tUse Hierarchical Softmax; default is 0 (not used)\n");
printf("\t-negative <int>\n");
printf("\t\tNumber of negative examples; default is 5, common values are 3 - 10 (0 = not used)\n");
printf("\t-threads <int>\n");
printf("\t\tUse <int> threads (default 12)\n");
printf("\t-iter <int>\n");
printf("\t\tRun more training iterations (default 5)\n");
printf("\t-min-count <int>\n");
printf("\t\tThis will discard words that appear less than <int> times; default is 5\n");
printf("\t-alpha <float>\n");
printf("\t\tSet the starting learning rate; default is 0.025 for skip-gram and 0.05 for CBOW\n");
printf("\t-classes <int>\n");
printf("\t\tOutput word classes rather than word vectors; default number of classes is 0 (vectors are written)\n");
printf("\t-debug <int>\n");
printf("\t\tSet the debug mode (default = 2 = more info during training)\n");
printf("\t-binary <int>\n");
printf("\t\tSave the resulting vectors in binary moded; default is 0 (off)\n");
printf("\t-save-vocab <file>\n");
printf("\t\tThe vocabulary will be saved to <file>\n");
printf("\t-read-vocab <file>\n");
printf("\t\tThe vocabulary will be read from <file>, not constructed from the training data\n");
printf("\t-cbow <int>\n");
printf("\t\tUse the continuous bag of words model; default is 1 (use 0 for skip-gram model)\n");
printf("\nExamples:\n");
printf("./word2vec -train data.txt -output vec.txt -size 200 -window 5 -sample 1e-4 -negative 5 -hs 0 -binary 0 -cbow 1 -iter 3\n\n");
return 0;
}
output_file[0] = 0;
save_vocab_file[0] = 0;
read_vocab_file[0] = 0;
if ((i = ArgPos((char *)"-size", argc, argv)) > 0) layer1_size = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-train", argc, argv)) > 0) strcpy(train_file, argv[i + 1]);
if ((i = ArgPos((char *)"-save-vocab", argc, argv)) > 0) strcpy(save_vocab_file, argv[i + 1]);
if ((i = ArgPos((char *)"-read-vocab", argc, argv)) > 0) strcpy(read_vocab_file, argv[i + 1]);
if ((i = ArgPos((char *)"-debug", argc, argv)) > 0) debug_mode = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-binary", argc, argv)) > 0) binary = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-cbow", argc, argv)) > 0) cbow = atoi(argv[i + 1]);
if (cbow) alpha = 0.05;
if ((i = ArgPos((char *)"-alpha", argc, argv)) > 0) alpha = atof(argv[i + 1]);
if ((i = ArgPos((char *)"-output", argc, argv)) > 0) strcpy(output_file, argv[i + 1]);
if ((i = ArgPos((char *)"-window", argc, argv)) > 0) window = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-sample", argc, argv)) > 0) sample = atof(argv[i + 1]);
if ((i = ArgPos((char *)"-hs", argc, argv)) > 0) hs = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-negative", argc, argv)) > 0) negative = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-threads", argc, argv)) > 0) num_threads = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-iter", argc, argv)) > 0) iter = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-min-count", argc, argv)) > 0) min_count = atoi(argv[i + 1]);
if ((i = ArgPos((char *)"-classes", argc, argv)) > 0) classes = atoi(argv[i + 1]);
vocab = (struct vocab_word *)calloc(vocab_max_size, sizeof(struct vocab_word));
vocab_hash = (int *)calloc(vocab_hash_size, sizeof(int));
expTable = (real *)malloc((EXP_TABLE_SIZE + 1) * sizeof(real));
for (i = 0; i < EXP_TABLE_SIZE; i++) {
expTable[i] = exp((i / (real)EXP_TABLE_SIZE * 2 - 1) * MAX_EXP); // Precompute the exp() table
expTable[i] = expTable[i] / (expTable[i] + 1); // Precompute f(x) = x / (x + 1)
}
TrainModel();
return 0;
}
```
|
Korey Dean Hall (born August 5, 1983) is a former fullback in the National Football League (NFL). He was selected by the Green Bay Packers in the sixth round in the 2007 NFL Draft, the 191st overall pick, and went on to win Super Bowl XLV with the team over the Pittsburgh Steelers. He played college football for Boise State and high school football in Glenns Ferry, Idaho.
Hall was also a member of the New Orleans Saints and Arizona Cardinals.
Early years
Born in Mountain Home, Idaho, Hall grew up in nearby Glenns Ferry and played high school football at Glenns Ferry High School in Idaho. He played both linebacker and running back for the Pilots and was named the Class 2A Player of the Year in 2001.
College career
Hall played at Boise State University where he was a three-time 1st team All-Western Athletic Conference (WAC) linebacker and two-time WAC Special Teams player of the year and WAC Defensive player of the year. He majored in construction management while at Boise State.
Professional career
Green Bay Packers
Hall was selected by the Green Bay Packers in the sixth round of the 2007 NFL Draft, the 191st overall pick. The Packers moved him to fullback with the hope that he would make an impact on special teams.
Hall scored his first and only NFL touchdown on a one-yard pass from quarterback Aaron Rodgers on September 8, 2008, in a Monday night game against the Minnesota Vikings. It was Rodgers' first career touchdown as a starter in the NFL.
During Hall's fourth and final season in Green Bay, the Packers made the playoffs as a wild card team and won four straight games on the road, including Super Bowl XLV. He had one reception for two yards in the Super Bowl.
New Orleans Saints
On July 29, 2011, Hall joined the New Orleans Saints.
Arizona Cardinals
Hall signed with the Arizona Cardinals on September 25, 2012. However, three days later, he was moved to the reserve/retired list.
Post-NFL life
Hall is now a construction manager in Boise, Idaho.
References
External links
Green Bay Packers: bio
Boise State Broncos: bio
1983 births
Living people
People from Glenns Ferry, Idaho
Players of American football from Idaho
American football fullbacks
American football linebackers
Boise State Broncos football players
Green Bay Packers players
New Orleans Saints players
Arizona Cardinals players
People from Mountain Home, Idaho
|
The Llandrindod Wells Deanery is a Roman Catholic deanery in the Diocese of Menevia that covers several churches in Powys and the surrounding area. In the early 2010s, the Aberystwyth Deanery was dissolved and the churches in Aberystwyth and Aberaeron became part of the Llandrindod Wells Deanery.
The dean is centred at Our Lady of Ransom and the Holy Souls Church in Llandrindod Wells.
Churches
Our Lady of the Angels and St Winefride, Aberystwyth
Holy Cross Church, Aberaeron - served from Aberystwyth
St Michael, Brecon
St Joseph, Hay-on-Wye
Our Lady of Ransom and the Holy Souls, Llandrindod Wells
Christ the King, Builth Wells - served from Llandrindod Wells
St Francis of Assisi Church, Rhayader
Assumption of Our Lady and St Therese, Presteigne - served from Rhayader
Our Lady of Perpetual Succour and St Nicholas, Knighton - served from Rhayader
Gallery
References
External links
Diocese of Menevia site
Our Lady of the Angels and St Winefride Parish site
Roman Catholic Deaneries in the Diocese of Menevia
Llandrindod Wells
|
```prolog
#
# Test checking options of pg_rewind.
#
use strict;
use warnings;
use TestLib;
use Test::More tests => 12;
program_help_ok('pg_rewind');
program_version_ok('pg_rewind');
program_options_handling_ok('pg_rewind');
my $primary_pgdata = TestLib::tempdir;
my $standby_pgdata = TestLib::tempdir;
command_fails(
[
'pg_rewind', '--debug',
'--target-pgdata', $primary_pgdata,
'--source-pgdata', $standby_pgdata,
'extra_arg1'
],
'too many arguments');
command_fails([ 'pg_rewind', '--target-pgdata', $primary_pgdata ],
'no source specified');
command_fails(
[
'pg_rewind', '--debug',
'--target-pgdata', $primary_pgdata,
'--source-pgdata', $standby_pgdata,
'--source-server', 'incorrect_source'
],
'both remote and local sources specified');
command_fails(
[
'pg_rewind', '--debug',
'--target-pgdata', $primary_pgdata,
'--source-pgdata', $standby_pgdata,
'--write-recovery-conf'
],
'no local source with --write-recovery-conf');
```
|
```javascript
const {Strategy} = require("passport-discord");
passport.use(
new Strategy(
{
clientID: "id",
clientSecret: "secret",
callbackURL: "callbackURL"
},
(accessToken, refreshToken, profile, cb) => {
authService.findOrCreate({discordId: profile.id}, cb);
}
)
);
```
|
```xml
import {
BladeController,
createBladeController,
createDefaultPluginPool,
PluginPool,
} from '@tweakpane/core';
import * as assert from 'assert';
import {describe, it} from 'mocha';
import {
createEmptyBladeController,
createLabeledValueBladeController,
createTestWindow,
} from '../../misc/test-util.js';
import {ListBladeApi} from './api/list.js';
import {ListBladeParams, ListBladePlugin} from './plugin.js';
function createPluginPool(): PluginPool {
const pool = createDefaultPluginPool();
pool.register('test', ListBladePlugin);
return pool;
}
describe(ListBladePlugin.id, () => {
[
{},
{
view: 'list',
},
{
value: 123,
view: 'list',
},
{
options: {foo: 1},
view: 'list',
},
{
value: 123,
options: 'invalid',
view: 'list',
},
].forEach((params) => {
context(`when ${JSON.stringify(params)}`, () => {
it('should not create API', () => {
const doc = createTestWindow().document;
const api = createBladeController(ListBladePlugin, {
document: doc,
params: params,
});
assert.strictEqual(api, null);
});
});
});
[
{
value: 0,
options: [],
view: 'list',
},
].forEach((params) => {
context(`when ${JSON.stringify(params)}`, () => {
it('should create API', () => {
const doc = createTestWindow().document;
const api = createBladeController(ListBladePlugin, {
document: doc,
params: params,
});
assert.notStrictEqual(api, null);
});
});
});
[
(doc: Document) => createEmptyBladeController(doc),
(doc: Document) => createLabeledValueBladeController(doc),
].forEach((createController) => {
it('should not create API', () => {
const doc = createTestWindow().document;
const c = createController(doc) as BladeController;
const api = ListBladePlugin.api({
controller: c,
pool: createPluginPool(),
});
assert.strictEqual(api, null);
});
});
it('should apply initial params', () => {
const doc = createTestWindow().document;
const bc = createBladeController(ListBladePlugin, {
document: doc,
params: {
label: 'hello',
options: {
foo: 1,
bar: 2,
},
value: 123,
view: 'list',
} as ListBladeParams<number>,
}) as BladeController;
const pool = createPluginPool();
const api = pool.createApi(bc) as ListBladeApi<number>;
assert.strictEqual(api.value, 123);
assert.deepStrictEqual(api.options[0], {text: 'foo', value: 1});
assert.deepStrictEqual(api.options[1], {text: 'bar', value: 2});
assert.strictEqual(
api.controller.view.element.querySelector('.tp-lblv_l')?.textContent,
'hello',
);
});
it('should support complex value', () => {
const doc = createTestWindow().document;
const bc = createBladeController(ListBladePlugin, {
document: doc,
params: {
label: 'hello',
options: [
{text: 'foo', value: {id: 'foo'}},
{text: 'bar', value: {id: 'bar'}},
],
value: {id: 'foo'},
view: 'list',
} as ListBladeParams<{id: string}>,
}) as BladeController;
const pool = createPluginPool();
const api = pool.createApi(bc) as ListBladeApi<{id: string}>;
const selectElem = api.controller.valueController.view.selectElement;
assert.strictEqual(
(selectElem.querySelector('option') as HTMLOptionElement).value,
'foo',
);
assert.strictEqual(
(selectElem.querySelector('option:nth-child(2)') as HTMLOptionElement)
.value,
'bar',
);
});
});
```
|
Dhatav is a Village in Roha Taluka in Raigad district in the state of Maharashtra, India. Dhatav connected through Mumbai & Pune through Mumbai Goa Highway in kolad
Demographics
India census, Dhatau had a population of 5035. Males constitute 56% of the population and females 44%. Dhatau has an average literacy rate of 72%, higher than the national average of 59.5%: male literacy is 78% and, female literacy is 65%. In Dhatau, 14% of the population is under 6 years of age.
References
Cities and towns in Raigad district
|
```python
import docker
import os
import time
from compose.container import Container
from compose.config.config import ConfigDetails
from compose.config.config import ConfigFile
from compose.config.config import load
from compose.project import Project
from compose.cli.docker_client import docker_client
from compose.config.environment import Environment
from compose.container import Container
import json
import subprocess
def build_image(image_name, dockerfile_dir):
print("Building image %s from %s" % (image_name, dockerfile_dir))
client = docker.from_env(assert_hostname=False)
output = client.build(dockerfile_dir, rm=True, tag=image_name)
response = "".join([" %s" % (line,) for line in output])
print(response)
def image_exists(image_name):
client = docker.from_env(assert_hostname=False)
tags = [t for image in client.images() for t in image['RepoTags']]
return "%s:%s" % (image_name, "latest") in tags
def pull_image(image_name):
client = docker.from_env(assert_hostname=False)
if not image_exists(image_name):
client.pull(image_name)
def run_docker_command(timeout=None, **kwargs):
pull_image(kwargs["image"])
client = docker.from_env(assert_hostname=False)
kwargs["labels"] = {"io.confluent.docker.testing": "true"}
container = TestContainer.create(client, **kwargs)
container.start()
container.wait(timeout)
logs = container.logs()
print "Running command %s: %s" % (kwargs["command"], logs)
container.shutdown()
return logs
def path_exists_in_image(image, path):
print "Checking for %s in %s" % (path, image)
cmd = "bash -c '[ ! -e %s ] || echo success' " % (path,)
output = run_docker_command(image=image, command=cmd)
return "success" in output
def executable_exists_in_image(image, path):
print "Checking for %s in %s" % (path, image)
cmd = "bash -c '[ ! -x %s ] || echo success' " % (path,)
output = run_docker_command(image=image, command=cmd)
return "success" in output
def run_command_on_host(command):
logs = run_docker_command(
image="busybox",
command=command,
host_config={'NetworkMode': 'host', 'Binds': ['/tmp:/tmp']})
print "Running command %s: %s" % (command, logs)
return logs
class TestContainer(Container):
def state(self):
return self.inspect_container["State"]
def status(self):
return self.state()["Status"]
def shutdown(self):
self.stop()
self.remove()
def execute(self, command):
eid = self.create_exec(command)
return self.start_exec(eid)
def wait(self, timeout):
return self.client.wait(self.id, timeout)
class TestCluster():
def __init__(self, name, working_dir, config_file):
config_file_path = os.path.join(working_dir, config_file)
cfg_file = ConfigFile.from_filename(config_file_path)
c = ConfigDetails(working_dir, [cfg_file],)
self.cd = load(c)
self.name = name
def get_project(self):
# Dont reuse the client to fix this bug : path_to_url
client = docker_client(Environment())
project = Project.from_config(self.name, self.cd, client)
return project
def start(self):
self.get_project().up()
def is_running(self):
state = [container.is_running for container in self.get_project().containers()]
return all(state) and len(state) > 0
def is_service_running(self, service_name):
return self.get_container(service_name).is_running
def shutdown(self):
project = self.get_project()
project.stop()
project.remove_stopped()
def get_container(self, service_name, stopped=False):
return self.get_project().get_service(service_name).get_container()
def exit_code(self, service_name):
containers = self.get_project().containers([service_name], stopped=True)
return containers[0].exit_code
def wait(self, service_name, timeout):
container = self.get_project().containers([service_name], stopped=True)
if container[0].is_running:
return self.get_project().client.wait(container[0].id, timeout)
def run_command_on_service(self, service_name, command):
return self.run_command(command, self.get_container(service_name))
def service_logs(self, service_name, stopped=False):
if stopped:
containers = self.get_project().containers([service_name], stopped=True)
print(containers[0].logs())
return containers[0].logs()
else:
return self.get_container(service_name).logs()
def run_command(self, command, container):
print "Running %s on %s :" % (command, container)
eid = container.create_exec(command)
output = container.start_exec(eid)
print "\n%s " % output
return output
def run_command_on_all(self, command):
results = {}
for container in self.get_project().containers():
results[container.name_without_project] = self.run_command(command, container)
return results
class TestMachine():
def __init__(self, machine_name):
self.machine_name = machine_name
# Ensure docker-machine is installed
subprocess.check_call("type docker-machine", shell=True)
# Ensure the machine is ready.
assert self.status() == "Running"
def run_cmd(self, cmd):
output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
return output
def status(self):
cmd = "docker-machine status %s " % self.machine_name
return self.run_cmd(cmd).strip()
def get_internal_ip(self, nw_interface="eth0"):
cmd = "docker-machine ssh %s /sbin/ifconfig %s | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'" % (self.machine_name, nw_interface)
return self.run_cmd(cmd)
def scp_to_machine(self, local_path, machine_path, recursive=True):
if recursive:
recursive_flag = "-r"
cmd = "docker-machine scp %s %s %s:%s" % (recursive_flag, local_path, self.machine_name, machine_path)
return self.run_cmd(cmd)
def ssh(self, command):
cmd = "docker-machine ssh %s %s" % (self.machine_name, command)
return self.run_cmd(cmd)
```
|
Goriely is a surname. Notable people with the surname include:
Alain Goriely, Belgian mathematician
Anne Goriely, British geneticist
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var valueOf = require( './valueof.js' ); // eslint-disable-line stdlib/no-redeclare
// MAIN //
/**
* Attempts to extract a string value.
*
* @private
* @param {*} value - value to test
* @returns {boolean} boolean indicating if a string can be extracted
*/
function test( value ) {
try {
valueOf.call( value );
return true;
} catch ( err ) { // eslint-disable-line no-unused-vars
return false;
}
}
// EXPORTS //
module.exports = test;
```
|
```javascript
Globbing in Node
Deleting Files and Folders
Using `gulp-mocha`
External Configuration Files
Automating Workflow with Gulp
```
|
```objective-c
//
//
// path_to_url
//
#ifndef PXR_IMAGING_HIO_OPENVDB_TEXTURE_DATA_H
#define PXR_IMAGING_HIO_OPENVDB_TEXTURE_DATA_H
/// \file hioOpenVDB/vdbTextureData.h
#include "pxr/pxr.h"
#include "pxr/imaging/hio/api.h"
#include "pxr/imaging/hio/fieldTextureData.h"
#include "pxr/base/gf/bbox3d.h"
#include <memory>
PXR_NAMESPACE_OPEN_SCOPE
class HioOpenVDB_TextureData_DenseGridHolderBase;
/// \class HioOpenVDB_TextureData
///
/// Implements HioFieldTextureData to read grid with given name from
/// OpenVDB file at given path.
///
class HioOpenVDB_TextureData final : public HioFieldTextureData
{
public:
using Base = HioFieldTextureData;
HioOpenVDB_TextureData(std::string const & filePath,
std::string const & gridName,
size_t targetMemory);
~HioOpenVDB_TextureData() override;
const GfBBox3d &GetBoundingBox() const override;
int ResizedWidth() const override;
int ResizedHeight() const override;
int ResizedDepth() const override;
HioFormat GetFormat() const override;
bool Read() override;
bool HasRawBuffer() const override;
unsigned char const * GetRawBuffer() const override;
private:
const std::string _filePath;
const std::string _gridName;
const size_t _targetMemory;
int _resizedWidth, _resizedHeight, _resizedDepth;
HioFormat _format;
GfBBox3d _boundingBox;
std::unique_ptr<HioOpenVDB_TextureData_DenseGridHolderBase> _denseGrid;
};
PXR_NAMESPACE_CLOSE_SCOPE
#endif
```
|
The Utah Transit Authority Police Public Safety Department is the law enforcement arm of the Utah Transit Authority (UTA) transit district in northern Utah, United States, with headquarters in Murray. UTA is a public transit district government agency made up of the participating municipalities, counties, and the State of Utah. The UTA Police Department is responsible for law enforcement services, crime investigations, crime prevention, and public safety throughout the light rail, commuter rail and bus transit systems, within the UTA transit district.
UTA governance
In 1969, the Utah State Legislature passed the Utah Public Transit District Act, which allows individual communities to address transportation needs by forming local transit districts.
UTA was founded in March 1970 when the cities of Murray, Salt Lake City, and Sandy voted to form a transit district. Today, UTA's service area is over and covers seven counties: Box Elder, Davis, Salt Lake, Summit, Tooele, Utah, and Weber.
Until 2018 UTA was governed by a 15-member part-time Board of Trustees. These Trustees Trustees were appointed by the city and county governments that fund UTA with a local option sales tax.
Local-elected officials may have also served on the UTA Board, and one seat was reserved for a member of the State Transportation Commission, which is part of the Utah Department of Transportation. The President of the Senate, Speaker of the House and Governor of the State of Utah each appointed one seat as well.
In 2018 due to alleged corruption issues the Utah State Legislature passed a bill organizing UTA with a full-time 3-member board appointed by the Utah State Governor. The Board continually directs agency staff to improve public transit along the Wasatch Front. Board members work with their appointing local representatives to direct UTA so the agency can best meet the needs of individual communities.
History
UTA originally contracted with a private company for security services. In 2003, after several attempts, UTA took control of security services and created the UTA Public Safety Department. The UTA security officers were given the title of Transit Public Safety Officers and they were primarily tasked with conducting fare enforcement and observing and reporting crime to local, county, and state law enforcement agencies. Local municipalities, counties, and state police agencies within the transit district were originally responsible for responding to calls for police services throughout the transit system. In 2006, the Utah State Legislature passed a bill, which granted multi-county transit districts the authority to hire and employ police officers to provide law enforcement services. As of June 2021 UTA is the only multi-county transit district in Utah. In 2006, UTA created the UTA Police Department and the Transit Police Officers were granted state certification as law enforcement officers.
Training
UTA Transit Police Officers are certified as law enforcement officers by the Utah Department of Public Safety Peace Officer Standards and Training (POST), and they are required to attend state certified police academies. In addition to completing state police academies, the UTA Transit Police Officers (like all other law enforcement officers in the State of Utah) must receive a minimum of 40 hours of continuous in service training annually, which usually includes legal and policy training, medical and first responder training, firearms and weapons training, defensive tactics, and use of force training.
Jurisdiction
The UTA Police Department's jurisdiction is UTA transit district property and resources, which includes UTA buildings, maintenance and service centers, train stations, bus stops, Park and Ride lots, and any UTA equipment or vehicle. The UTA transit police jurisdiction is also extended onto the right of way of train tracks and twenty feet in and around any UTA property or vehicle. The UTA transit district has a large jurisdiction, from Utah County on the south to Box Elder County on the north and from Tooele County on the west to Summit County on the east, with Salt Lake, Davis, and Weber counties in the middle. Although neither Summit County, nor any municipality therein, is a participant in the UTA transit district, UTA transit vehicles do provide service to Park City through a special arrangement with Park City and Summit County.
Laws and procedures
The UTA transit district is governed by the UTA Board of Trustees, who are appointed to the board by the cities, counties, and the state. The Board of Trustees enact ordinances, just as municipal and county councils enact municipal or county codes. UTA ordinances are primarily enforced by Transit Police Officers, although they can also be enforced by other law enforcement agencies. Violators of UTA ordinances, can be issued civil or criminal citations depending on the violation. UTA civil citations, such as fare evasion, are not criminal and are reviewed and administered by a UTA civil administrator. Criminal charges filed by the UTA Police Department are reviewed and administered by the justice court, district court, or federal court in which the offense occurred. Transit Police Officers have the legal authority as law enforcement officers of the State of Utah, to enforce municipal, county, state, and federal laws outside of their jurisdiction.
Department command
The Utah Transit Authority Police Department is managed by the Public Safety Manager who is appointed to the position by the UTA General Manager and the board of trustees. The command structure is made up of the Public Safety Manager, captains, lieutenants, sergeants and officers. The UTA Police Department has sworn law enforcement officers and non-sworn support personnel, which includes dispatchers, office personnel, and security officers.
In 2011 UTA considered the possibility of combining its Public Safety Department with the Unified Police Department of Greater Salt Lake (which is headed by the Salt Lake County Sheriff).
Police services
The UTA Transit Police Officers are assigned patrol vehicles, and the department mandates a beat system for them. UTA Transit Police Officers routinely patrol trains, buses, all UTA stations, and UTA rail right-of-ways, as well as conduct fare enforcement. Transit police officers also respond to calls for police services throughout the transit system.
Contact information
The UTA Police Department's main headquarters is near the Murray Central Station, which is located at 127 West Vine Street in Murray City. There are several UTA police sub-stations throughout the transit system. The UTA Police Dispatch Center can be contacted by dialing 801-287-EYES (3937) or 911. The UTA Police Department administration, investigations and civil administrator's offices can be contacted at 801-287-2601.
See also
list of law enforcement agencies in Utah
References
External links
Utah Transit Authority
Transit police departments of the United States
Specialist police departments of Utah
|
```swift
import Apollo
import Combine
import Foundation
import ReactiveSwift
class MockGraphQLClient: ApolloClientType {
// MARK: - Base Properties
var client: ApolloClient {
let url = URL(string: "path_to_url")!
return ApolloClient(url: url)
}
static let shared = MockGraphQLClient()
// MARK: Public functions
/// Placeholder implementation because protocol definition used in `Service`
public func fetch<Query: GraphQLQuery>(query _: Query) -> SignalProducer<Query.Data, ErrorEnvelope> {
.init(value: Query.Data(unsafeResultMap: [:]))
}
/// Placeholder implementation because protocol definition used in `Service`
public func perform<Mutation: GraphQLMutation>(
mutation _: Mutation
) -> SignalProducer<Mutation.Data, ErrorEnvelope> {
.init(value: Mutation.Data(unsafeResultMap: [:]))
}
}
/** Implementation of optional `fetch` and `perform` with `result` useful for mocking data.
*/
extension ApolloClientType {
public func fetchWithResult<Query: GraphQLQuery, Data: Decodable>(
query _: Query,
result: Result<Data, ErrorEnvelope>?
) -> SignalProducer<Data, ErrorEnvelope> {
producer(for: result)
}
public func performWithResult<Mutation: GraphQLMutation, Data: Decodable>(
mutation _: Mutation,
result: Result<Data, ErrorEnvelope>?
) -> SignalProducer<Data, ErrorEnvelope> {
producer(for: result)
}
public func fetchWithResult<Query: GraphQLQuery, Data: Decodable>(
query _: Query,
result: Result<Data, ErrorEnvelope>?
) -> AnyPublisher<Data, ErrorEnvelope> {
return producer(for: result)
}
public func performWithResult<Mutation: GraphQLMutation, Data: Decodable>(
mutation _: Mutation,
result: Result<Data, ErrorEnvelope>?
) -> AnyPublisher<Data, ErrorEnvelope> {
return producer(for: result)
}
public func data<Data: Decodable>(from producer: SignalProducer<Data, ErrorEnvelope>) -> Data? {
switch producer.first() {
case let .success(data):
return data
default:
return nil
}
}
public func error<Data: Decodable>(from producer: SignalProducer<Data, ErrorEnvelope>)
-> ErrorEnvelope? {
switch producer.first() {
case let .failure(errorEnvelope):
return errorEnvelope
default:
return nil
}
}
}
private func producer<T, E>(for property: Result<T, E>?) -> SignalProducer<T, E> {
guard let result = property else { return .empty }
switch result {
case let .success(value): return .init(value: value)
case let .failure(error): return .init(error: error)
}
}
private func producer<T, E>(for property: Result<T, E>?) -> AnyPublisher<T, E> {
switch property {
case let .success(data): return CurrentValueSubject(data).eraseToAnyPublisher()
case let .failure(error): return Fail(error: error).eraseToAnyPublisher()
case .none: return Empty(completeImmediately: false).eraseToAnyPublisher()
}
}
private extension Result {
var value: Success? {
switch self {
case let .success(value): return value
case .failure: return nil
}
}
var error: Failure? {
switch self {
case .success: return nil
case let .failure(error): return error
}
}
}
public final class MockApolloQuery: GraphQLQuery {
public let operationDefinition: String = ""
public let operationName: String = "OperationName"
public let operationIdentifier: String? = "operation-identifier"
public init() {}
public var variables: GraphQLMap? {
return [:]
}
public struct Data: GraphQLSelectionSet {
public static let possibleTypes: [String] = ["Query"]
public static var selections: [GraphQLSelection] {
return []
}
public private(set) var resultMap: ResultMap
public init(unsafeResultMap: ResultMap) {
self.resultMap = unsafeResultMap
}
}
}
```
|
The final 14 episodes of Columbo were produced sporadically as a series of specials, spanning 13 years from 1990 to 2003. These episodes have since been released on DVD in several regions as "season 10". Two of the episodes, "No Time to Die" and "Undercover", were based on 87th Precinct novels by Ed McBain and thus do not follow the usual Columbo format.
Episodes
References
Columbo 10
1990 American television seasons
1991 American television seasons
1992 American television seasons
1993 American television seasons
1994 American television seasons
1995 American television seasons
1997 American television seasons
1998 American television seasons
2000 American television seasons
2003 American television seasons
|
```shell
## compare_shells: dash bash mksh
#### Incomplete Function
## code: foo()
## status: 2
## BUG mksh status: 0
#### Incomplete Function 2
## code: foo() {
## status: 2
## OK mksh status: 1
#### Bad function
## code: foo(ls)
## status: 2
## OK mksh status: 1
#### Unbraced function body.
# dash allows this, but bash does not. The POSIX grammar might not allow
# this? Because a function body needs a compound command.
# function_body : compound_command
# | compound_command redirect_list /* Apply rule 9 */
## code: one_line() ls; one_line;
## status: 0
## OK bash/osh status: 2
#### Function with spaces, to see if ( and ) are separate tokens.
# NOTE: Newline after ( is not OK.
fun ( ) { echo in-func; }; fun
## stdout: in-func
#### subshell function
# bash allows this.
i=0
j=0
inc() { i=$((i+5)); }
inc_subshell() ( j=$((j+5)); )
inc
inc_subshell
echo $i $j
## stdout: 5 0
#### Hard case, function with } token in it
rbrace() { echo }; }; rbrace
## stdout: }
#### . in function name
# bash accepts; dash doesn't
func-name.ext ( ) { echo func-name.ext; }
func-name.ext
## stdout: func-name.ext
## OK dash status: 2
## OK dash stdout-json: ""
#### = in function name
# WOW, bash is so lenient. foo=bar is a command, I suppose. I think I'm doing
# to disallow this one.
func-name=ext ( ) { echo func-name=ext; }
func-name=ext
## stdout: func-name=ext
## OK dash status: 2
## OK dash stdout-json: ""
## OK mksh status: 1
## OK mksh stdout-json: ""
#### Function name with $
$foo-bar() { ls ; }
## status: 2
## OK bash/mksh status: 1
#### Function name with command sub
foo-$(echo hi)() { ls ; }
## status: 2
## OK bash/mksh status: 1
#### Function name with !
# bash allows this; dash doesn't.
foo!bar() { ls ; }
## status: 0
## OK dash status: 2
#### Function name with -
# bash allows this; dash doesn't.
foo-bar() { ls ; }
## status: 0
## OK dash status: 2
#### Break after ) is OK.
# newline is always a token in "normal" state.
echo hi; fun ( )
{ echo in-func; }
fun
## STDOUT:
hi
in-func
## END
#### Nested definition
# A function definition is a command, so it can be nested
fun() {
nested_func() { echo nested; }
nested_func
}
fun
## stdout: nested
```
|
```javascript
'use strict';
const { series, src, dest } = require('gulp');
const sass = require('gulp-sass');
const autoprefixer = require('gulp-autoprefixer');
const cssmin = require('gulp-cssmin');
function compile() {
return src('./src/*.scss')
.pipe(sass.sync())
.pipe(autoprefixer({
browsers: ['ie > 9', 'last 2 versions'],
cascade: false
}))
.pipe(cssmin())
.pipe(dest('./lib'));
}
function copyfont() {
return src('./src/fonts/**')
.pipe(cssmin())
.pipe(dest('./lib/fonts'));
}
exports.build = series(compile, copyfont);
```
|
Vincent Martel Deconchy (21 January 1768 – 26 August 1823) commanded a French brigade in Spain and Italy during the Napoleonic Wars. He joined the army in 1792 during the French Revolution and fought in several battles in the north. After being part of the force occupying the Batavian Republic, he gained promotion for heroism at the Battle of Castricum in 1799. He served as an aide-de-camp during the battles of Marengo and the Mincio in 1800.
Deconchy fought in several actions during the War of the Third Coalition. Transferred to Spain, he was acting commander of a light infantry regiment in the VI Corps for a time before being elevated to colonel in September 1810. He participated in the 1810 French invasion of Portugal and led his regiment at Redinha during the retreat. He was promoted general officer in February 1813 and fought against the Spanish guerillas. In August 1813 he transferred to Italy where he led a brigade in the army of Eugène de Beauharnais until the end of the fighting in 1814. He stayed in favor with the Bourbons and was elevated to the rank of lieutenant general in 1821. He led a division in the 1823 French intervention in Spain and died during the blockade of Pamplona.
Portugal
In September 1810, Deconchy commanded 36 officers and 1,678 rank and file of the 1st and 2nd Battalions of the 25th Light Infantry. The unit was part of Martial Bardet de Maison-Rouge's brigade in Julien Augustin Joseph Mermet's division of Marshal Michel Ney's VI Corps.
Spain
In the summer of 1813, Deconchy led a brigade of the Army of the North consisting of two battalions of the 64th Line Infantry Regiment, one battalion of the 22nd Line, four companies of the 34th Line and two companies of the 1st Line. With his 2,000-man brigade, Deconchy joined the 16,000 troops under Maximilien Sébastien Foy who were evacuating the northern coast of Spain due to the British victory at the Battle of Vitoria. After he received news of Vitoria, Foy waited at Bergara for his forces to join him before marching off at top speed for the French frontier. A column led by Sir Thomas Graham attempted to cut Foy off, but was foiled at the Battle of Tolosa on 26 June. During that action, Deconchy's brigade held the walls of the town and easily repelled two attacks by the 1st King's German Legion Light Battalion under Christian Friedrich Wilhelm von Ompteda. At sunset, Foy issued orders to withdraw and Deconchy's men got away just as the Allies smashed down the town gates with cannon fire. As he fell back toward France, Foy sent Deconchy's brigade and every artillerist he could spare to defend San Sebastián which was commanded by Louis Emmanuel Rey. The new troops replaced the previous unreliable garrison of gendarmes and recruits which were sent off as an escort for a large column of refugees.
Notes
References
1768 births
1823 deaths
French generals
French military personnel of the French Revolutionary Wars
French military personnel of the Napoleonic Wars
People from Oise
Hundred Thousand Sons of Saint Louis
|
James Ramlall, also known as Bhai (26 January 1935 – 19 December 2018), was a Surinamese poet.
Biography
Bhai was born in the former district Suriname. After getting his teaching degree, he became a teacher at an elementary school in Harmelen, Netherlands. After three years of teaching, he decided to become a student. First he studied Dutch language and literature, and pedagogy. Later he went on to study Indian philosophy and religion, and wrote his doctoral thesis on "The Problem of Being in Heidegger and Sankara".
When Bhai returned to his native Suriname, he became Assistant Director of Culture and later Director of Culture of the Surinamese Ministry of Education and Culture, and showed himself very active in the cultural world. He founded the conference center "Caribbean Centre" in Lelydorp.
Bhai wrote poetry mainly in Dutch, but some was in Hindi, which was published in the magazine Soela. The poetry can be described as philosophical and meditative. The pseudonym which used was 'Bhai' meaning brother, and brotherhood is a theme found throughout his poetry. The Dutch work was bundled into Vindu (Hindi for: Secret, 1982) from which the concrete-imaging of his earlier poetry completely disappeared. For this bundle, Bhai received the Literature Prize of Suriname 1980-1982. Since then he turned to poetry, although he sporadically wrote for De Ware Tijd Literair.
In 2003, Bhai received the Gaanman Gazon Matodja Award. He died on 19 December 2018 at the age of 83.
See also
Surinamese literature
References
Sources
Michiel van Kempen, Een geschiedenis van de Surinaamse literatuur. Breda: De Geus, 2003, deel II, pp. 814–816.
Michiel van Kempen, Surinaamse schrijvers en dichters (Amsterdam: De Arbeiderspers, 1989).
External links
Bhai at Digital Library for Dutch Literature (in Dutch)
1935 births
2018 deaths
Hindi-language poets
Surinamese poets
Surinamese Hindus
Surinamese people of Indian descent
|
The George Carlin Show is an American sitcom that aired Sunday at 9:30 pm on the Fox network from January 1994 to July 1995. It was created by Sam Simon, who executive produced the show jointly with the show's namesake, comedian George Carlin. On the show, Carlin played a New York City taxicab driver.
Synopsis
The action was centered on George O'Grady (George Carlin), a taxicab driver living in New York City. Most of the scenes took place in The Moylan Tavern, owned and run by bartender Jack Donahue (Anthony Starke), who had inherited the establishment from his father. The setting's real-life basis was the actual, now-defunct Moylan Tavern, a bar that existed during Carlin's childhood on Broadway between La Salle Street and Tiemann Place in the Morningside Heights neighborhood, and owned by the grandparents of film critic and author Maitland McDonagh. As Carlin recalled in 1994, "It was where I saw Oswald shot. It was where I headed during the [1965] blackout. The Moylan is where I came of age." The name of the show's bartender character, Jack Donahue, was taken from that of real-life owner Jimmy Donahue, who bought the bar from the original owners. The set itself, however, resembled another upper-Broadway bar, Carlin said: "Cannon's—where my father used to drink."
Cast
Main
George Carlin as George O'Grady, a New York city cabdriver and regular patron of The Moylan Tavern
Alex Rocco as Harry Rossetti, George's best friend, an ex-con bookie
Paige French as Sydney Paris, waitress at The Moylan, and aspiring model/actress
Anthony Starke as Jack Donahue, bartender/owner of The Moylan
Christopher Rich as Dr. Neil Beck, a plastic surgeon who is quite unlike the blue-collar Moylan regulars
Mike Hagerty as Frank MacNamara, a working-class Moylan's regular
Recurring
The following characters appeared in at least 5 episodes:
Susan Sullivan as Kathleen Rachowski, a pet-shop owner and George's girlfriend
Phil LaMarr as Bob Brown, a friend of George's during season 1
Matt Landers as Larry Pinkerton, an ex-cop who lives in George's building and hangs out with George at The Moylan
Iqbal Theba as Inzamamulhaq Siddiqui, a fellow cabdriver of George's
Note that while Sullivan appeared in publicity cast photos, she appeared in only 7 episodes, receiving "Special Guest Star" billing in the closing credits.
Episodes
Season 1 (1994)
Season 2 (1994–95)
George Carlin's criticism
Carlin noted on his website:
He later elaborated in his posthumously published autobiography Last Words:
He went on to speak in the book of not enjoying the committee-style writer's room, which he felt alienated anyone who was not a professional television writer.
Simon in 2013 addressed Carlin's comments, saying:
Reception
The show received an approval rating of 88% on review aggregator Rotten Tomatoes, based on eight reviews.
Todd Everett of Variety, gave the show a positive review, saying: "The Moylan Tavern -- and Carlin's aging hipster character translates well to the sitcom stage. This is the comic without much of the acid that frequently flows in his standup routines. It's a half hour that's easy to take, and Carlin fans won't be disappointed."
David Hiltbrand of People Magazine, also gave a positive review of the show, saying: "The sitcom’s flavor is somewhat bland, with just a whiff of desperation about it. But the mix of characters is likable, and how many Fox shows can you say that about?”
References
External links
1990s American sitcoms
1990s American workplace comedy television series
1994 American television series debuts
1995 American television series endings
English-language television shows
Fox Broadcasting Company original programming
Television shows set in New York City
Television series by Warner Bros. Television Studios
George Carlin
|
La Cygne (pronounced ) is a city in Linn County, Kansas, United States, and situated along the Marais des Cygnes River. As of the 2020 census, the population of the city was 1,050. The city is named after the Marais des Cygnes River which is a French translation of an Osage appellation meaning "marsh of the swans".
History
La Cygne was founded in 1869 as soon as the people were assured of the building of a track for the Missouri River, Ft. Scott & Gulf Railroad. A town company was organized and purchased of land, but had only laid out as a town site. La Cygne was incorporated on January 14, 1870, and a board of trustees was appointed. In the fall of that year the town had grown so that it had inhabitants enough to organize as a city of the third class, and F. A. Foote was elected the first mayor. The first school was taught in 1869 in Cady's hall. It was a private subscription school and was kept open until 1870, when the public school house was built. It was a commodious two-story brick building containing the graded and high schools. The Methodist church organized in 1870 and soon after built a house of worship. The Presbyterian church was organized the same year but had no building for a year afterward.
At an early date La Cygne became a manufacturing point. A flour mill was built in 1870; a bank was started in 1871; the La Cygne organ factory was another early commercial enterprise, but it did not flourish. In 1881 a coal mine was opened, after which it became an important point for the industry. The first newspaper in the town was the Weekly Journal, which first appeared in June 1870.
The suspicious death of Alonzo Brooks in 2004 was featured in the fourth episode "No Ride Home" of the fifteenth season of Unsolved Mysteries TV series in 2020.
Geography
La Cygne is situated on the east bank of the Marais des Cygnes River and only a few miles southwest of the city of Linn Valley. It is four miles (6 km) west of U.S. Route 69 on K-152; La Cygne Lake is east of US-69. A track for BNSF Railway passes through the city. According to the United States Census Bureau, the city has a total area of , of which, is land and is water.
Climate
The climate in this area is characterized by hot, humid summers and generally mild to cool winters. According to the Köppen Climate Classification system, La Cygne has a humid subtropical climate, abbreviated "Cfa" on climate maps.
Demographics
2010 census
As of the census of 2010, there were 1,149 people, 454 households, and 303 families residing in the city. The population density was . There were 517 housing units at an average density of . The racial makeup of the city was 97.3% White, 0.6% African American, 0.9% Native American, 0.2% Asian, 0.1% from other races, and 1.0% from two or more races. Hispanic or Latino of any race were 1.7% of the population.
There were 454 households, of which 34.8% had children under the age of 18 living with them, 49.8% were married couples living together, 10.4% had a female householder with no husband present, 6.6% had a male householder with no wife present, and 33.3% were non-families. 29.3% of all households were made up of individuals, and 16.7% had someone living alone who was 65 years of age or older. The average household size was 2.53 and the average family size was 3.08.
The median age in the city was 37 years. 28.6% of residents were under the age of 18; 6.4% were between the ages of 18 and 24; 23.5% were from 25 to 44; 24.3% were from 45 to 64; and 17.1% were 65 years of age or older. The gender makeup of the city was 47.3% male and 52.7% female.
2000 census
As of the 2000 census, there were 1,115 people, 459 households, and 294 families residing in the city. The population density was . There were 507 housing units at an average density of . The racial makeup of the city was 96.68% White, 1.43% Native American, 0.27% Black or African American, 0.27% Asian, 0.27% from other races, and 1.08% from two or more races. Hispanic or Latino of any race were 0.72% of the population.
There were 459 households, out of which 31.8% had children under the age of 18 living with them, 53.4% were married couples living together, 7.4% had a female householder with no husband present, and 35.9% were non-families. 30.9% of all households were made up of individuals, and 18.1% had someone living alone who was 65 years of age or older. The average household size was 2.38 and the average family size was 3.00.
In the city, the population was spread out, with 26.3% under the age of 18, 6.8% from 18 to 24, 27.7% from 25 to 44, 21.8% from 45 to 64, and 17.4% who were 65 years of age or older. The median age was 37 years. For every 100 females, there were 89.0 males. For every 100 females age 18 and over, there were 83.1 males.
The median income for a household in the city was $34,479, and the median income for a family was $44,118. Males had a median income of $30,900 versus $19,803 for females. The per capita income for the city was $15,880. About 5.0% of families and 9.2% of the population were below the poverty line, including 4.9% of those under age 18 and 23.4% of those age 65 or over.
Education
The community is served by Prairie View USD 362 public school district with four schools serving more than 1,000 students. The four schools located in the school district are:
La Cygne Elementary School, grades PreK–5
Parker Elementary School, grades PreK-5
Prairie View Middle School, grades 6–8
Prairie View High School, grades 9–12
The Prairie View High School mascot is Prairie View Buffalos. Prior to school unification, the La Cygne High School mascot was La Cygne Indians.
Notable people
Alonzo Brooks (1980-2004), victim of a suspected homicide. He was visiting from Gardner.
John Robinson (born 1943), serial killer, con man, embezzler, kidnapper, forger
References
Further reading
External links
City of La Cygne
La Cygne - Directory of Public Officials
La Cygne city map, KDOT
Cities in Kansas
Cities in Linn County, Kansas
1869 establishments in Kansas
|
Economy and Society: An Outline of Interpretive Sociology (1921; ; or simply Economy and Society) is a book by political economist and sociologist Max Weber, published posthumously in Germany by his wife Marianne. Alongside The Protestant Ethic and the Spirit of Capitalism (1905), it is considered to be one of Weber's most important works. Extremely broad in scope, the book covers numerous themes including religion, economics, politics, public administration, and sociology. A complete translation of the work was not published in English until 1968.
In 1998, the International Sociological Association listed this work as the most important sociological book of the 20th century.
Quotes
Sociology
Sociology…is a science concerning itself with the interpretive understanding of social action and thereby with a causal explanation of its course and consequences. We shall speak of "action" insofar as the acting individual attaches a subjective meaning to his behavior.
Ideal types (pure types)
For the purposes of a typological scientific analysis it is convenient to treat all irrational, affectually determined elements of behavior as factors of deviation from a conceptually pure type of rational action. For example a panic on the stock exchange can be most conveniently analysed by attempting to determine first what the course of action would have been if it had not been influenced by irrational affects; it is then possible to introduce the irrational components as accounting for the observed deviations from this hypothetical course...Only in this way is it possible to assess the causal significance of irrational factors as accounting for the deviation of this type. The construction of a purely rational course of action in such cases serves the sociologist as a type (ideal type) which has the merit of clear understandability and lack of ambiguity. By comparison with this it is possible to understand the ways in which actual action is influenced by irrational factors of all sorts, such as affects and errors, in that they account for the deviation from the line of conduct which would be expected on hypothesis that the action were purely rational.
Concepts
State violence
Much like in other works, Weber makes it a point to mention the state's role in legitimizing and perpetuating violence. Weber writes that legal norms exist when they are kept through “...normally directly physical, means of coercion of the political community”. This legal norm can extend into further arms of the government and the public as described when Weber writes, “In the case of certain events occurring there is general agreement that certain organs of the community can be expected to go into official action, and the very expectation of such action is apt to induce conformity with the commands derived from the generally accepted interpretation of that legal norm….
Orientations of social action
Social action, like all action, may be oriented in four ways:
Instrumentally rational (): action "determined by expectations as to the behavior of objects in the environment and of other human beings; these expectations are used as "conditions" or "means" for the attainment of the actor's own rationally pursued and calculated ends."
Value-rational (): action "determined by a conscious belief in the value for its own sake of some ethical, aesthetic, religious, or other form of behavior, independently of its prospects of success."
Affectual (especially emotional): action "determined by the actor's specific affects and feeling states."
Traditional: action "determined by ingrained habituation."
Religion
In part 2, chapter VI, Weber distinguishes three ideal types of religious activity:
World-flying mysticism;
World-rejecting asceticism; and
Inner-worldly asceticism.
He also separated magic as pre-religious activity.
References
External links
Weber, Max. 1922. Economy and Society, 2 v. Description.
Camic, Charles, Philip S. Gorski, and David M. Trubek, ed. 2005. Max Weber's Economy and Society: A Critical Companion. Stanford University Press. .
1922 non-fiction books
Books about organizations
Economics books
Works by Max Weber
Social sciences books
|
```yaml
comment: Export all Incident, Context and Widget data into Json format output.
commonfields:
id: HealthCheckExportSummary
version: -1
dockerimage: demisto/python3:3.10.14.100715
enabled: true
name: HealthCheckExportSummary
runas: DBotWeakRole
script: ''
scripttarget: 0
subtype: python3
tags: []
type: python
fromversion: 6.0.0
tests:
- No tests (auto formatted)
```
|
```objective-c
//
//
// path_to_url
//
#ifndef PXR_IMAGING_HD_VERSION_H
#define PXR_IMAGING_HD_VERSION_H
// 18 -> 19: Add support for SceneDelegate surface shaders.
// 19 -> 20: RenderPass constructor takes RenderIndex. RasterState class.
// 20 -> 21: Add HdSceneDelegate::IsEnabled().
// 21 -> 22: split HdRasterState out of HdRenderPass and renamed to HdRenderPassState.
// HdEngine::Draw API change.
// 22 -> 23: remove ID render API
// 23 -> 24: GetPathForInstanceIndex returns absolute instance index.
// 24 -> 25: move simpleLightingShader to Hdx.
// 25 -> 26: move camera and light to Hdx.
// 26 -> 27: move drawTarget to Hdx.
// 27 -> 28: switch render index Sprim to take a typeId.
// 28 -> 29: cameras only support matrices.
// 29 -> 30: added IDRenderColor decode and direct Rprim path fetching.
// 30 -> 31: added pre-chained buffer sources
// 31 -> 32: renamed HdShader{Param} to HdMaterial{Param}
// 32 -> 33: Deleted GetPathForInstanceIndex; added GetScenePrimPath.
// 32 -> 34: Added HdInstancerContext to GetScenePrimPath.
// 34 -> 35: HdRepr is using std::unique_ptr<HdDrawItem>
// 35 -> 36: InsertRprim/InsertInstancer no longer take instancerId,
// HdSceneDelegate now has GetInstancerId
// 36 -> 37: Renamed HdRprim::_SetMaterialId to SetMaterialId. It no longer
// takes changeTracker.
// 37 -> 38: Removed Bprim garbage collection API from HdChangeTracker and
// HdResourceRegistry.
// 38 -> 39: Removed garbage collection API from HdChangeTracker and
// HdResourceRegistry.
// Added HdSceneDelegate::GetInstancerPrototypes.
// 39 -> 40: Removed Bind and Unbind API from HdRenderPassState.
// 40 -> 41: Renamed HdDelegate::GetMaterialNeworkselector() to
// GetMaterialRenderContexts(). It now returns a TfTokenVector.
// 41 -> 42: Removed GetMaterialTag() from HdRenderIndex.
// 42 -> 43: Removed HdCamera pulling on view and projection matrix.
// 43 -> 44: Replaced HdCamera::GetProjectionMatrix with
// HdComputeProjectionMatrix.
// 44 -> 45: Added HdSceneDelegate::GetScenePrimPaths.
// 45 -> 46: New signatures for HdRendererPlugin::IsSupported and
// HdRendererPluginRegistry::GetDefaultPluginId
// 46 -> 47: Adding HdRenderDelegate::GetRenderSettingsNamespaces()
// 47 -> 48: New signature for HdRenderIndex::InsertSceneIndex: added optional
// argument needsPrefixing
// 48 -> 49: Moved HdExtCompCpuComputation, Hd_ExtCompInputSource,
// Hd_CompExtCompInputSource, and Hd_SceneExtCompInputSource to hdSt.
// 49 -> 50: Added HdModelDrawMode struct and getter API to HdSceneDelegate.
// 50 -> 51: HdMaterialBindingSchema became HdMaterialBindingsSchema which uses
// the new HdMaterialBindingSchema.
// 51 -> 52: Added lens distortion, focus, and split diopter parameters to
// HdCamera.
// 52 -> 53: Changing dirty bits of HdCoordSys.
// 53 -> 54: Introducing HdFlattenedDataSourceProvider to make
// HdFlatteningSceneIndex modular.
// 54 -> 55: Introduce API in HdRenderDelegate to aid in transitioning
// render delegates to a Hydra 2.0 world.
// 55 -> 56: Adds hydra-namespaced internal instancer primvars
// 56 -> 57: Changing SetOverrideWindowPolicy to std::optional on
// HdRenderPassState, HdxPickFromRenderBufferTaskParams,
// HdxTaskController and UsdImagingGLEngine.
// 57 -> 58: Introducing hdsi/version.h
// 58 -> 59: HdGeomSubsetsSchema::GetIds() renamed to
// HdGeomSubsetsSchema::GetGeomSubsetNames().
// 59 -> 60: Introduced HdRenderDelegate::GetCapabilities().
// 60 -> 61: Adding HdPrimvarSchema::GetFlattenedPrimvarValue().
// Note that in an upcoming change,
// HdPrimvarSchema::GetPrimvarValue() might change and
// simply return the data source source at primvarValue.
// 61 -> 62: Remove 'bindingStrength' from HdMaterialBindingSchema.
// 62 -> 63: HdMaterialSchema::GetMaterialNetwork,
// HdMaterialNetwork::GetNodes, GetTerminals,
// HdMaterialNode::GetParameters, GetInputConnections
// return Hydra schemas instead of just container data sources.
// schemaTypeDefs.h replaces vectorSchemaTypeDefs.h.
// 63 -> 64: Adding disableDepthOfField to HdRenderSettings::RenderProduct
// 64 -> 65: Introduce HdCollectionPredicateLibrary and
// HdCollectionExpressionEvaluator for path expression evaluation on
// scene index prims.
// 65 -> 66: Make HdSchema::_GetTypedDataSource and getters in generated
// hydra schemas const.
// 66 -> 67: Removes legacy internal instancer primvar names and the
// TfEnvSetting for using them (see 56).
// 67 -> 68: Adds HdSceneDelegate::SampleFOO with startTime and endTime.
// 68 -> 69: Removes HdGeomSubsetsSchema. Geom subsets are now represented
// in Hydra as child prims of their parent geometry.
// 69 -> 70: Add dirty bit translation for light filter prims in backend
// emulation.
// 70 -> 71: Add virtual HdRenderDelegate::IsParallelSyncEnabled.
//
#define HD_API_VERSION 71
// 1 -> 2: SimpleLighting -> FallbackLighting
#define HD_SHADER_API 2
#endif // PXR_IMAGING_HD_VERSION_H
```
|
This article is about the particular significance of the year 1779 to Wales and its people.
Incumbents
Lord Lieutenant of Anglesey - Sir Nicholas Bayly, 2nd Baronet
Lord Lieutenant of Brecknockshire and Monmouthshire – Charles Morgan of Dderw
Lord Lieutenant of Caernarvonshire - Thomas Wynn
Lord Lieutenant of Cardiganshire – Wilmot Vaughan, 1st Earl of Lisburne
Lord Lieutenant of Carmarthenshire – George Rice (until 3 August) Thomas Johnes (from 7 September)
Lord Lieutenant of Denbighshire - Richard Myddelton
Lord Lieutenant of Flintshire - Sir Roger Mostyn, 5th Baronet
Lord Lieutenant of Glamorgan – John Stuart, Lord Mountstuart
Lord Lieutenant of Merionethshire - Sir Watkin Williams-Wynn, 4th Baronet
Lord Lieutenant of Montgomeryshire – George Herbert, 2nd Earl of Powis
Lord Lieutenant of Pembrokeshire – Sir Hugh Owen, 5th Baronet
Lord Lieutenant of Radnorshire – Edward Harley, 4th Earl of Oxford and Earl Mortimer
Bishop of Bangor – John Moore
Bishop of Llandaff – Shute Barrington
Bishop of St Asaph – Jonathan Shipley
Bishop of St Davids – James Yorke (until 2 August); John Warren (from 19 September)
Events
February - Ship's surgeon David Samwell witnesses the death of Captain James Cook in Hawaii.
June - Valentine Morris, governor of St Vincent, negotiates unfavourable surrender terms with the French.
unknown dates
New bridges are built over the River Wye at Builth Wells and River Towy at Llandeilo.
Haverfordwest prison is built on the site of the former castle.
Baptist Assembly at Glynceiriog.
Robert Jones, Calvinistic Methodist exhorter, preaches in London.
Arts and literature
New books
David William - Joy in the Tents of Zion (English edition)
Music
Richard Morris creates a list of "Henwau Mesurau Cerdd Dafod a Thant a arferir yn gyffredinol gan y Prydyddion a'r Telynorion yng Nghymru.
Births
14 March - William Ormsby-Gore, politician (died 1860)
24 August - Charles Norris, artist (died 1858)
Deaths
June/July - Hugh Williams, Anglican clergyman and writer
3 August - George Rice, Lord Lieutenant and MP for Carmarthenshire, 55
9 August - Morgan Rhys, hymn-writer, 63
11 December - "Madam" Bridget Bevan, philanthropist, 81
December - Richard Morris, collector of folk songs, 76date unknown'' - Edward Jones, composer, 49/50
References
Wales
Wales
1779 in Europe
1770s in Wales
|
```smalltalk
/*****************************************************************************
*
* ReoGrid - .NET
* path_to_url
*
* ReoGrid MIT
*
*
*
*
* path_to_url
*
****************************************************************************/
using System;
using System.Windows.Forms;
namespace unvell.ReoGrid.Demo.Scripts
{
/// <summary>
///
/// </summary>
public partial class LoadScriptDocDemo : UserControl
{
public LoadScriptDocDemo()
{
InitializeComponent();
// get first worksheet instance
var sheet = reoGridControl.Worksheets[0];
// load tepmlate from RGF file.
// RGF file is a file format that contains worksheet information,
// such as data, styles, borders, formula and etc, RGF file can
// be saved and loaded by ReoGrid and ReoGridEditor.
//
// path_to_url
//
sheet.LoadRGF("_Templates\\RGF\\change_colors.rgf");
// hide sheet tab control
reoGridControl.SetSettings(WorkbookSettings.View_ShowSheetTabControl, false);
// hide row header and column header
sheet.SetSettings(WorksheetSettings.View_ShowHeaders, false);
// set entire worksheet read-only
sheet.SetSettings(WorksheetSettings.Edit_Readonly, true);
reoScriptEditorControl1.Text = reoGridControl.Script;
}
private void btnRun_Click(object sender, EventArgs e)
{
reoGridControl.RunScript();
}
private void btnStop_Click(object sender, EventArgs e)
{
reoGridControl.Srm.ForceStop();
}
}
}
```
|
```ruby
# frozen_string_literal: true
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
require "support/coverage"
::RSpec.configure do |configuration|
configuration.color = true
configuration.disable_monkey_patching!
configuration.expect_with :rspec do |expect_configuration|
expect_configuration.include_chain_clauses_in_custom_matcher_descriptions = true
expect_configuration.max_formatted_output_length = nil
end
configuration.fail_fast = false
configuration.mock_with :rspec do |mocks|
mocks.verify_doubled_constant_names = true
mocks.verify_partial_doubles = true
end
configuration.profile_examples = 10
end
module RSpec
module Mocks
# This is a patch to work around an issue that is fixed by rspec-mocks 3.12.2.
# SEE: path_to_url
class VerifyingMethodDouble
ruby2_keywords :proxy_method_invoked if respond_to?(:ruby2_keywords, true)
end
end
end
```
|
```java
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package io.pravega.common.util;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import io.pravega.test.common.AssertExtensions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import lombok.Data;
import lombok.val;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
/**
* Unit tests for the CollectionHelpers class.
*/
public class CollectionHelpersTests {
/**
* Tests the binarySearch() method on a List.
*/
@Test
public void testBinarySearchList() {
int maxSize = 100;
int skip = 3;
ArrayList<Integer> list = new ArrayList<>();
for (int size = 0; size < maxSize; size++) {
int maxSearchElement = (list.size() + 1) * skip;
for (AtomicInteger search = new AtomicInteger(-1); search.incrementAndGet() < maxSearchElement; ) {
int expectedIndex = list.indexOf(search.get());
int actualIndex = CollectionHelpers.binarySearch(list, i -> Integer.compare(search.get(), i));
Assert.assertEquals("Unexpected result for search = " + search + " for list of size " + list.size(), expectedIndex, actualIndex);
}
// Add an element.
list.add(maxSearchElement);
}
}
@Test
public void testSearchGLB() {
List<TestElement> list = Lists.newArrayList(new TestElement(10L), new TestElement(30L), new TestElement(75L),
new TestElement(100L), new TestElement(152L), new TestElement(200L), new TestElement(400L), new TestElement(700L));
int index = CollectionHelpers.findGreatestLowerBound(list, x -> Long.compare(0L, x.getElement()));
assertEquals(index, -1);
index = CollectionHelpers.findGreatestLowerBound(list, x -> Long.compare(29, x.getElement()));
assertEquals(index, 0);
index = CollectionHelpers.findGreatestLowerBound(list, x -> Long.compare(100L, x.getElement()));
assertEquals(index, 3);
index = CollectionHelpers.findGreatestLowerBound(list, x -> Long.compare(Long.MAX_VALUE, x.getElement()));
assertEquals(index, 7);
}
/**
* Tests the filterOut method.
*/
@Test
public void testFilterOut() {
int size = 100;
val collection = createCollection(0, size);
val emptyRemoveResult = CollectionHelpers.filterOut(collection, Collections.emptySet());
AssertExtensions.assertContainsSameElements("Unexpected result with empty toExclude.", collection, emptyRemoveResult);
val noMatchResult = CollectionHelpers.filterOut(collection, Collections.singleton(size + 1));
AssertExtensions.assertContainsSameElements("Unexpected result with no-match toExclude.", collection, noMatchResult);
for (int i = 0; i < size; i++) {
val toExclude = createCollection(0, i);
val expectedResult = createCollection(i, size);
val filterResult = CollectionHelpers.filterOut(collection, toExclude);
AssertExtensions.assertContainsSameElements("Unexpected result from filterOut for i = " + i, expectedResult, filterResult);
}
}
/**
* Tests the joinSets() method.
*/
@Test
public void testJoinSets() {
AssertExtensions.<Integer>assertContainsSameElements("Empty set.", Collections.emptySet(),
CollectionHelpers.joinSets(Collections.emptySet(), Collections.emptySet()));
AssertExtensions.assertContainsSameElements("Empty+non-empty.", Sets.newHashSet(1, 2, 3),
CollectionHelpers.joinSets(Collections.emptySet(), Sets.newHashSet(1, 2, 3)));
AssertExtensions.assertContainsSameElements("Non-empty+empty.", Sets.newHashSet(1, 2, 3),
CollectionHelpers.joinSets(Sets.newHashSet(1, 2, 3), Collections.emptySet()));
AssertExtensions.assertContainsSameElements("Non-empty+non-empty.", Sets.newHashSet(1, 2, 3),
CollectionHelpers.joinSets(Sets.newHashSet(1, 3), Sets.newHashSet(2)));
AssertExtensions.assertContainsSameElements("Non-empty+non-empty(duplicates).", Arrays.asList(1, 2, 2, 3),
CollectionHelpers.joinSets(Sets.newHashSet(1, 2), Sets.newHashSet(2, 3)));
}
/**
* Tests the joinCollections() method.
*/
@Test
public void testJoinCollections() {
AssertExtensions.assertContainsSameElements("Empty set.", Collections.<Integer>emptySet(),
CollectionHelpers.joinCollections(Collections.<Integer>emptySet(), i -> i, Collections.<Integer>emptySet(), i -> i));
AssertExtensions.assertContainsSameElements("Empty+non-empty.", Arrays.asList(1, 2, 3),
CollectionHelpers.joinCollections(Collections.<Integer>emptySet(), i -> i, Arrays.asList("1", "2", "3"), Integer::parseInt));
AssertExtensions.assertContainsSameElements("Non-empty+empty.", Arrays.asList(1, 2, 3),
CollectionHelpers.joinCollections(Arrays.asList("1", "2", "3"), Integer::parseInt, Collections.<Integer>emptySet(), i -> i));
AssertExtensions.assertContainsSameElements("Non-empty+non-empty.", Arrays.asList(1, 2, 3),
CollectionHelpers.joinCollections(Arrays.asList("1", "3"), Integer::parseInt, Arrays.asList("2"), Integer::parseInt));
val c = CollectionHelpers.joinCollections(Arrays.asList("1", "2"), Integer::parseInt, Arrays.asList("2", "3"), Integer::parseInt);
AssertExtensions.assertContainsSameElements("Non-empty+non-empty(duplicates).", Arrays.asList(1, 2, 2, 3), c);
// Now test the iterator.
val copy = new ArrayList<Integer>(c);
AssertExtensions.assertContainsSameElements("Non-empty+non-empty(duplicates, copy).", c, copy);
}
private Collection<Integer> createCollection(int from, int upTo) {
Collection<Integer> collection = new HashSet<>(upTo - from);
for (int i = from; i < upTo; i++) {
collection.add(i);
}
return collection;
}
@Data
private static class TestElement {
private final long element;
}
}
```
|
Hypoptopoma thoracatum is a species of catfish in the family Loricariidae. It is native to South America, where it is known from the Amazon River basin. The species feeds on algae and reaches 8 cm (3.1 inches) in total length.
References
Hypoptopomatini
Fish described in 1868
|
```smalltalk
using System.Reflection;
using UnityEngine;
using UnityEditor.Graphing;
using UnityEditor.ShaderGraph.Drawing.Controls;
namespace UnityEditor.ShaderGraph
{
public enum HueMode
{
Degrees,
Normalized
};
[Title("Artistic", "Adjustment", "Hue")]
public class HueNode : CodeFunctionNode
{
public HueNode()
{
name = "Hue";
}
public override string documentationURL
{
get { return "path_to_url"; }
}
[SerializeField]
private HueMode m_HueMode = HueMode.Degrees;
[EnumControl("Range")]
public HueMode hueMode
{
get { return m_HueMode; }
set
{
if (m_HueMode == value)
return;
m_HueMode = value;
Dirty(ModificationScope.Graph);
}
}
protected override MethodInfo GetFunctionToConvert()
{
switch (m_HueMode)
{
case HueMode.Normalized:
return GetType().GetMethod("Unity_Hue_Normalized", BindingFlags.Static | BindingFlags.NonPublic);
default:
return GetType().GetMethod("Unity_Hue_Degrees", BindingFlags.Static | BindingFlags.NonPublic);
}
}
static string Unity_Hue_Degrees(
[Slot(0, Binding.None)] Vector3 In,
[Slot(1, Binding.None)] Vector1 Offset,
[Slot(2, Binding.None)] out Vector3 Out)
{
Out = Vector3.zero;
return
@"
{
// RGB to HSV
{precision}4 K = {precision}4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
{precision}4 P = lerp({precision}4(In.bg, K.wz), {precision}4(In.gb, K.xy), step(In.b, In.g));
{precision}4 Q = lerp({precision}4(P.xyw, In.r), {precision}4(In.r, P.yzx), step(P.x, In.r));
{precision} D = Q.x - min(Q.w, Q.y);
{precision} E = 1e-10;
{precision}3 hsv = {precision}3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);
{precision} hue = hsv.x + Offset / 360;
hsv.x = (hue < 0)
? hue + 1
: (hue > 1)
? hue - 1
: hue;
// HSV to RGB
{precision}4 K2 = {precision}4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
{precision}3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
Out = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);
}";
}
static string Unity_Hue_Normalized(
[Slot(0, Binding.None)] Vector3 In,
[Slot(1, Binding.None, 0.5f, 0.5f, 0.5f, 0.5f)] Vector1 Offset,
[Slot(2, Binding.None)] out Vector3 Out)
{
Out = Vector3.zero;
return
@"
{
// RGB to HSV
{precision}4 K = {precision}4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
{precision}4 P = lerp({precision}4(In.bg, K.wz), {precision}4(In.gb, K.xy), step(In.b, In.g));
{precision}4 Q = lerp({precision}4(P.xyw, In.r), {precision}4(In.r, P.yzx), step(P.x, In.r));
{precision} D = Q.x - min(Q.w, Q.y);
{precision} E = 1e-10;
{precision}3 hsv = {precision}3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);
{precision} hue = hsv.x + Offset;
hsv.x = (hue < 0)
? hue + 1
: (hue > 1)
? hue - 1
: hue;
// HSV to RGB
{precision}4 K2 = {precision}4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
{precision}3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
Out = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);
}";
}
}
}
```
|
Pyatnitskoye Shosse () is a Moscow Metro station in the Mitino District, North-Western Administrative Okrug, Moscow, Russia. It is the northwestern terminus of the Arbatsko-Pokrovskaya Line. The station is located under the intersection of Pyatnitskoye Highway and Mitinskaya street.
The station was opened on 28 December 2012.
The mail hall of the station is curved, there are only five such stations in the Moscow Metro: Alexandrovsky sad, Kutuzovskaya, Mezdunarodnaya and Zyablikovo.
References
Moscow Metro stations
Railway stations in Russia opened in 2012
Arbatsko-Pokrovskaya Line
Railway stations located underground in Russia
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.beam.examples.complete.game;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.apache.avro.reflect.Nullable;
import org.apache.beam.examples.complete.game.utils.WriteToText;
import org.apache.beam.sdk.Pipeline;
import org.apache.beam.sdk.coders.DefaultCoder;
import org.apache.beam.sdk.extensions.avro.coders.AvroCoder;
import org.apache.beam.sdk.io.TextIO;
import org.apache.beam.sdk.metrics.Counter;
import org.apache.beam.sdk.metrics.Metrics;
import org.apache.beam.sdk.options.Default;
import org.apache.beam.sdk.options.Description;
import org.apache.beam.sdk.options.PipelineOptions;
import org.apache.beam.sdk.options.PipelineOptionsFactory;
import org.apache.beam.sdk.options.Validation;
import org.apache.beam.sdk.transforms.DoFn;
import org.apache.beam.sdk.transforms.MapElements;
import org.apache.beam.sdk.transforms.PTransform;
import org.apache.beam.sdk.transforms.ParDo;
import org.apache.beam.sdk.transforms.Sum;
import org.apache.beam.sdk.values.KV;
import org.apache.beam.sdk.values.PCollection;
import org.apache.beam.sdk.values.TypeDescriptors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* This class is the first in a series of four pipelines that tell a story in a 'gaming' domain.
* Concepts: batch processing, reading input from text files, writing output to text files, using
* standalone DoFns, use of the sum per key transform, and use of Java 8 lambda syntax.
*
* <p>In this gaming scenario, many users play, as members of different teams, over the course of a
* day, and their actions are logged for processing. Some of the logged game events may be late-
* arriving, if users play on mobile devices and go transiently offline for a period.
*
* <p>This pipeline does batch processing of data collected from gaming events. It calculates the
* sum of scores per user, over an entire batch of gaming data (collected, say, for each day). The
* batch processing will not include any late data that arrives after the day's cutoff point.
*
* <p>To execute this pipeline, specify the pipeline configuration like this:
*
* <pre>{@code
* --tempLocation=YOUR_TEMP_DIRECTORY
* --runner=YOUR_RUNNER
* --output=YOUR_OUTPUT_DIRECTORY
* (possibly options specific to your runner or permissions for your temp/output locations)
* }</pre>
*
* <p>Optionally include the --input argument to specify a batch input file. See the --input default
* value for example batch data file, or use {@code injector.Injector} to generate your own batch
* data.
*/
@SuppressWarnings({
"nullness" // TODO(path_to_url
})
public class UserScore {
/** Class to hold info about a game event. */
@DefaultCoder(AvroCoder.class)
static class GameActionInfo {
@Nullable String user;
@Nullable String team;
@Nullable Integer score;
@Nullable Long timestamp;
public GameActionInfo() {}
public GameActionInfo(String user, String team, Integer score, Long timestamp) {
this.user = user;
this.team = team;
this.score = score;
this.timestamp = timestamp;
}
public String getUser() {
return this.user;
}
public String getTeam() {
return this.team;
}
public Integer getScore() {
return this.score;
}
public Long getTimestamp() {
return this.timestamp;
}
public String getKey(String keyname) {
if ("team".equals(keyname)) {
return this.team;
} else { // return username as default
return this.user;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || o.getClass() != this.getClass()) {
return false;
}
GameActionInfo gameActionInfo = (GameActionInfo) o;
if (!this.getUser().equals(gameActionInfo.getUser())) {
return false;
}
if (!this.getTeam().equals(gameActionInfo.getTeam())) {
return false;
}
if (!this.getScore().equals(gameActionInfo.getScore())) {
return false;
}
return this.getTimestamp().equals(gameActionInfo.getTimestamp());
}
@Override
public int hashCode() {
return Objects.hash(user, team, score, timestamp);
}
}
/**
* Parses the raw game event info into GameActionInfo objects. Each event line has the following
* format: username,teamname,score,timestamp_in_ms,readable_time e.g.:
* user2_AsparagusPig,AsparagusPig,10,1445230923951,2015-11-02 09:09:28.224 The human-readable
* time string is not used here.
*/
static class ParseEventFn extends DoFn<String, GameActionInfo> {
// Log and count parse errors.
private static final Logger LOG = LoggerFactory.getLogger(ParseEventFn.class);
private final Counter numParseErrors = Metrics.counter("main", "ParseErrors");
@ProcessElement
public void processElement(ProcessContext c) {
String[] components = c.element().split(",", -1);
try {
String user = components[0].trim();
String team = components[1].trim();
Integer score = Integer.parseInt(components[2].trim());
Long timestamp = Long.parseLong(components[3].trim());
GameActionInfo gInfo = new GameActionInfo(user, team, score, timestamp);
c.output(gInfo);
} catch (ArrayIndexOutOfBoundsException | NumberFormatException e) {
numParseErrors.inc();
LOG.info("Parse error on " + c.element() + ", " + e.getMessage());
}
}
}
/**
* A transform to extract key/score information from GameActionInfo, and sum the scores. The
* constructor arg determines whether 'team' or 'user' info is extracted.
*/
// [START DocInclude_USExtractXform]
public static class ExtractAndSumScore
extends PTransform<PCollection<GameActionInfo>, PCollection<KV<String, Integer>>> {
private final String field;
ExtractAndSumScore(String field) {
this.field = field;
}
@Override
public PCollection<KV<String, Integer>> expand(PCollection<GameActionInfo> gameInfo) {
return gameInfo
.apply(
MapElements.into(
TypeDescriptors.kvs(TypeDescriptors.strings(), TypeDescriptors.integers()))
.via((GameActionInfo gInfo) -> KV.of(gInfo.getKey(field), gInfo.getScore())))
.apply(Sum.integersPerKey());
}
}
// [END DocInclude_USExtractXform]
/** Options supported by {@link UserScore}. */
public interface Options extends PipelineOptions {
@Description("Path to the data file(s) containing game data.")
/* The default maps to two large Google Cloud Storage files (each ~12GB) holding two subsequent
day's worth (roughly) of data.
Note: You may want to use a small sample dataset to test it locally/quickly : gs://apache-beam-samples/game/small/gaming_data.csv
You can also download it via the command line gsutil cp gs://apache-beam-samples/game/small/gaming_data.csv ./destination_folder/gaming_data.csv */
@Default.String("gs://apache-beam-samples/game/gaming_data*.csv")
String getInput();
void setInput(String value);
// Set this required option to specify where to write the output.
@Description("Path of the file to write to.")
@Validation.Required
String getOutput();
void setOutput(String value);
}
/**
* Create a map of information that describes how to write pipeline output to text. This map is
* passed to the {@link WriteToText} constructor to write user score sums.
*/
protected static Map<String, WriteToText.FieldFn<KV<String, Integer>>> configureOutput() {
Map<String, WriteToText.FieldFn<KV<String, Integer>>> config = new HashMap<>();
config.put("user", (c, w) -> c.element().getKey());
config.put("total_score", (c, w) -> c.element().getValue());
return config;
}
/** Run a batch pipeline. */
// [START DocInclude_USMain]
public static void main(String[] args) throws Exception {
// Begin constructing a pipeline configured by commandline flags.
Options options = PipelineOptionsFactory.fromArgs(args).withValidation().as(Options.class);
Pipeline pipeline = Pipeline.create(options);
// Read events from a text file and parse them.
pipeline
.apply(TextIO.read().from(options.getInput()))
.apply("ParseGameEvent", ParDo.of(new ParseEventFn()))
// Extract and sum username/score pairs from the event data.
.apply("ExtractUserScore", new ExtractAndSumScore("user"))
.apply(
"WriteUserScoreSums", new WriteToText<>(options.getOutput(), configureOutput(), false));
// Run the batch pipeline.
pipeline.run().waitUntilFinish();
}
// [END DocInclude_USMain]
}
```
|
Oceanobacillus profundus is a gram positive, rod shaped, halophilic bacteria of the family Bacillaceae. Oceanobacillus profundus was isolated from the surface of a sediment core sample of the Tsushima Basin of the Sea of Japan, Korea, and from marine sponge of Saint Martin's island of the Bay of Bengal, Bangladesh. The type strain is CL-MP28T (=KCCM 42318T=DSM 18246T). Sponge associated Oceanobacillus profundus strain CS 9 was highly salt tolarent.
References
Bacillaceae
Gram-positive bacteria
Bacteria genera
|
```c++
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_matrix_integer
/// @file glm/gtc/matrix_integer.hpp
/// @date 2011-01-20 / 2011-06-05
/// @author Christophe Riccio
///
/// @see core (dependence)
///
/// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer
/// @ingroup gtc
///
/// Defines a number of matrices with integer types.
/// <glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTC_matrix_integer
#define GLM_GTC_matrix_integer GLM_VERSION
// Dependency:
#include "../glm.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTC_matrix_integer extension included")
#endif
namespace glm
{
/// @addtogroup gtc_matrix_integer
/// @{
/// High-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<highp_int> highp_imat2;
/// High-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<highp_int> highp_imat3;
/// High-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<highp_int> highp_imat4;
/// High-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<highp_int> highp_imat2x2;
/// High-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<highp_int> highp_imat2x3;
/// High-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<highp_int> highp_imat2x4;
/// High-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<highp_int> highp_imat3x2;
/// High-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<highp_int> highp_imat3x3;
/// High-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<highp_int> highp_imat3x4;
/// High-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<highp_int> highp_imat4x2;
/// High-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<highp_int> highp_imat4x3;
/// High-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<highp_int> highp_imat4x4;
/// Medium-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<mediump_int> mediump_imat2;
/// Medium-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<mediump_int> mediump_imat3;
/// Medium-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<mediump_int> mediump_imat4;
/// Medium-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<mediump_int> mediump_imat2x2;
/// Medium-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<mediump_int> mediump_imat2x3;
/// Medium-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<mediump_int> mediump_imat2x4;
/// Medium-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<mediump_int> mediump_imat3x2;
/// Medium-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<mediump_int> mediump_imat3x3;
/// Medium-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<mediump_int> mediump_imat3x4;
/// Medium-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<mediump_int> mediump_imat4x2;
/// Medium-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<mediump_int> mediump_imat4x3;
/// Medium-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<mediump_int> mediump_imat4x4;
/// Low-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<lowp_int> lowp_imat2;
/// Low-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<lowp_int> lowp_imat3;
/// Low-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<lowp_int> lowp_imat4;
/// Low-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<lowp_int> lowp_imat2x2;
/// Low-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<lowp_int> lowp_imat2x3;
/// Low-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<lowp_int> lowp_imat2x4;
/// Low-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<lowp_int> lowp_imat3x2;
/// Low-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<lowp_int> lowp_imat3x3;
/// Low-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<lowp_int> lowp_imat3x4;
/// Low-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<lowp_int> lowp_imat4x2;
/// Low-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<lowp_int> lowp_imat4x3;
/// Low-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<lowp_int> lowp_imat4x4;
/// High-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<highp_uint> highp_umat2;
/// High-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<highp_uint> highp_umat3;
/// High-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<highp_uint> highp_umat4;
/// High-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<highp_uint> highp_umat2x2;
/// High-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<highp_uint> highp_umat2x3;
/// High-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<highp_uint> highp_umat2x4;
/// High-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<highp_uint> highp_umat3x2;
/// High-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<highp_uint> highp_umat3x3;
/// High-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<highp_uint> highp_umat3x4;
/// High-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<highp_uint> highp_umat4x2;
/// High-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<highp_uint> highp_umat4x3;
/// High-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<highp_uint> highp_umat4x4;
/// Medium-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<mediump_uint> mediump_umat2;
/// Medium-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<mediump_uint> mediump_umat3;
/// Medium-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<mediump_uint> mediump_umat4;
/// Medium-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<mediump_uint> mediump_umat2x2;
/// Medium-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<mediump_uint> mediump_umat2x3;
/// Medium-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<mediump_uint> mediump_umat2x4;
/// Medium-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<mediump_uint> mediump_umat3x2;
/// Medium-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<mediump_uint> mediump_umat3x3;
/// Medium-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<mediump_uint> mediump_umat3x4;
/// Medium-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<mediump_uint> mediump_umat4x2;
/// Medium-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<mediump_uint> mediump_umat4x3;
/// Medium-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<mediump_uint> mediump_umat4x4;
/// Low-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<lowp_uint> lowp_umat2;
/// Low-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<lowp_uint> lowp_umat3;
/// Low-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<lowp_uint> lowp_umat4;
/// Low-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<lowp_uint> lowp_umat2x2;
/// Low-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<lowp_uint> lowp_umat2x3;
/// Low-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<lowp_uint> lowp_umat2x4;
/// Low-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<lowp_uint> lowp_umat3x2;
/// Low-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<lowp_uint> lowp_umat3x3;
/// Low-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<lowp_uint> lowp_umat3x4;
/// Low-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<lowp_uint> lowp_umat4x2;
/// Low-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<lowp_uint> lowp_umat4x3;
/// Low-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<lowp_uint> lowp_umat4x4;
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_imat2 imat2;
typedef highp_imat3 imat3;
typedef highp_imat4 imat4;
typedef highp_imat2x2 imat2x2;
typedef highp_imat2x3 imat2x3;
typedef highp_imat2x4 imat2x4;
typedef highp_imat3x2 imat3x2;
typedef highp_imat3x3 imat3x3;
typedef highp_imat3x4 imat3x4;
typedef highp_imat4x2 imat4x2;
typedef highp_imat4x3 imat4x3;
typedef highp_imat4x4 imat4x4;
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_imat2 imat2;
typedef lowp_imat3 imat3;
typedef lowp_imat4 imat4;
typedef lowp_imat2x2 imat2x2;
typedef lowp_imat2x3 imat2x3;
typedef lowp_imat2x4 imat2x4;
typedef lowp_imat3x2 imat3x2;
typedef lowp_imat3x3 imat3x3;
typedef lowp_imat3x4 imat3x4;
typedef lowp_imat4x2 imat4x2;
typedef lowp_imat4x3 imat4x3;
typedef lowp_imat4x4 imat4x4;
#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
/// Signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat2 imat2;
/// Signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat3 imat3;
/// Signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat4 imat4;
/// Signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat2x2 imat2x2;
/// Signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat2x3 imat2x3;
/// Signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat2x4 imat2x4;
/// Signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat3x2 imat3x2;
/// Signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat3x3 imat3x3;
/// Signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat3x4 imat3x4;
/// Signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat4x2 imat4x2;
/// Signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat4x3 imat4x3;
/// Signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_imat4x4 imat4x4;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef highp_umat2 umat2;
typedef highp_umat3 umat3;
typedef highp_umat4 umat4;
typedef highp_umat2x2 umat2x2;
typedef highp_umat2x3 umat2x3;
typedef highp_umat2x4 umat2x4;
typedef highp_umat3x2 umat3x2;
typedef highp_umat3x3 umat3x3;
typedef highp_umat3x4 umat3x4;
typedef highp_umat4x2 umat4x2;
typedef highp_umat4x3 umat4x3;
typedef highp_umat4x4 umat4x4;
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_umat2 umat2;
typedef lowp_umat3 umat3;
typedef lowp_umat4 umat4;
typedef lowp_umat2x2 umat2x2;
typedef lowp_umat2x3 umat2x3;
typedef lowp_umat2x4 umat2x4;
typedef lowp_umat3x2 umat3x2;
typedef lowp_umat3x3 umat3x3;
typedef lowp_umat3x4 umat3x4;
typedef lowp_umat4x2 umat4x2;
typedef lowp_umat4x3 umat4x3;
typedef lowp_umat4x4 umat4x4;
#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
/// Unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat2 umat2;
/// Unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat3 umat3;
/// Unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat4 umat4;
/// Unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat2x2 umat2x2;
/// Unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat2x3 umat2x3;
/// Unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat2x4 umat2x4;
/// Unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat3x2 umat3x2;
/// Unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat3x3 umat3x3;
/// Unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat3x4 umat3x4;
/// Unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat4x2 umat4x2;
/// Unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat4x3 umat4x3;
/// Unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mediump_umat4x4 umat4x4;
#endif//GLM_PRECISION
/// @}
}//namespace glm
#endif//GLM_GTC_matrix_integer
```
|
```css
Vertical centering fluid blocks
Use `float` to allow an element to be placed to the left or right of the container
Clearfix for layouts
Vertically-center anything
Equal width table cells
```
|
```javascript
Computed property names in object literals
Creating promises
Generators as iterators in ES6
Modules in ES6
ES6 Generator Transpiler
```
|
```go
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/quic-go/quic-go (interfaces: StreamI)
//
// Generated by this command:
//
// mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_internal_test.go github.com/quic-go/quic-go StreamI
//
// Package quic is a generated GoMock package.
package quic
import (
context "context"
reflect "reflect"
time "time"
ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
protocol "github.com/quic-go/quic-go/internal/protocol"
qerr "github.com/quic-go/quic-go/internal/qerr"
wire "github.com/quic-go/quic-go/internal/wire"
gomock "go.uber.org/mock/gomock"
)
// MockStreamI is a mock of StreamI interface.
type MockStreamI struct {
ctrl *gomock.Controller
recorder *MockStreamIMockRecorder
}
// MockStreamIMockRecorder is the mock recorder for MockStreamI.
type MockStreamIMockRecorder struct {
mock *MockStreamI
}
// NewMockStreamI creates a new mock instance.
func NewMockStreamI(ctrl *gomock.Controller) *MockStreamI {
mock := &MockStreamI{ctrl: ctrl}
mock.recorder = &MockStreamIMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
return m.recorder
}
// CancelRead mocks base method.
func (m *MockStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}
// CancelRead indicates an expected call of CancelRead.
func (mr *MockStreamIMockRecorder) CancelRead(arg0 any) *MockStreamICancelReadCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStreamI)(nil).CancelRead), arg0)
return &MockStreamICancelReadCall{Call: call}
}
// MockStreamICancelReadCall wrap *gomock.Call
type MockStreamICancelReadCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamICancelReadCall) Return() *MockStreamICancelReadCall {
c.Call = c.Call.Return()
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// CancelWrite mocks base method.
func (m *MockStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}
// CancelWrite indicates an expected call of CancelWrite.
func (mr *MockStreamIMockRecorder) CancelWrite(arg0 any) *MockStreamICancelWriteCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStreamI)(nil).CancelWrite), arg0)
return &MockStreamICancelWriteCall{Call: call}
}
// MockStreamICancelWriteCall wrap *gomock.Call
type MockStreamICancelWriteCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamICancelWriteCall) Return() *MockStreamICancelWriteCall {
c.Call = c.Call.Return()
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Close mocks base method.
func (m *MockStreamI) Close() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close")
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockStreamIMockRecorder) Close() *MockStreamICloseCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamI)(nil).Close))
return &MockStreamICloseCall{Call: call}
}
// MockStreamICloseCall wrap *gomock.Call
type MockStreamICloseCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamICloseCall) Return(arg0 error) *MockStreamICloseCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamICloseCall) Do(f func() error) *MockStreamICloseCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamICloseCall) DoAndReturn(f func() error) *MockStreamICloseCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Context mocks base method.
func (m *MockStreamI) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockStreamIMockRecorder) Context() *MockStreamIContextCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStreamI)(nil).Context))
return &MockStreamIContextCall{Call: call}
}
// MockStreamIContextCall wrap *gomock.Call
type MockStreamIContextCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIContextCall) Return(arg0 context.Context) *MockStreamIContextCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIContextCall) Do(f func() context.Context) *MockStreamIContextCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIContextCall) DoAndReturn(f func() context.Context) *MockStreamIContextCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Read mocks base method.
func (m *MockStreamI) Read(arg0 []byte) (int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Read", arg0)
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Read indicates an expected call of Read.
func (mr *MockStreamIMockRecorder) Read(arg0 any) *MockStreamIReadCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStreamI)(nil).Read), arg0)
return &MockStreamIReadCall{Call: call}
}
// MockStreamIReadCall wrap *gomock.Call
type MockStreamIReadCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIReadCall) Return(arg0 int, arg1 error) *MockStreamIReadCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIReadCall) Do(f func([]byte) (int, error)) *MockStreamIReadCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIReadCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetDeadline mocks base method.
func (m *MockStreamI) SetDeadline(arg0 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetDeadline", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetDeadline indicates an expected call of SetDeadline.
func (mr *MockStreamIMockRecorder) SetDeadline(arg0 any) *MockStreamISetDeadlineCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStreamI)(nil).SetDeadline), arg0)
return &MockStreamISetDeadlineCall{Call: call}
}
// MockStreamISetDeadlineCall wrap *gomock.Call
type MockStreamISetDeadlineCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamISetDeadlineCall) Return(arg0 error) *MockStreamISetDeadlineCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamISetDeadlineCall) Do(f func(time.Time) error) *MockStreamISetDeadlineCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamISetDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetDeadlineCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetReadDeadline mocks base method.
func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetReadDeadline indicates an expected call of SetReadDeadline.
func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 any) *MockStreamISetReadDeadlineCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStreamI)(nil).SetReadDeadline), arg0)
return &MockStreamISetReadDeadlineCall{Call: call}
}
// MockStreamISetReadDeadlineCall wrap *gomock.Call
type MockStreamISetReadDeadlineCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamISetReadDeadlineCall) Return(arg0 error) *MockStreamISetReadDeadlineCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamISetReadDeadlineCall) Do(f func(time.Time) error) *MockStreamISetReadDeadlineCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetReadDeadlineCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetWriteDeadline mocks base method.
func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetWriteDeadline indicates an expected call of SetWriteDeadline.
func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 any) *MockStreamISetWriteDeadlineCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStreamI)(nil).SetWriteDeadline), arg0)
return &MockStreamISetWriteDeadlineCall{Call: call}
}
// MockStreamISetWriteDeadlineCall wrap *gomock.Call
type MockStreamISetWriteDeadlineCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamISetWriteDeadlineCall) Return(arg0 error) *MockStreamISetWriteDeadlineCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamISetWriteDeadlineCall) Do(f func(time.Time) error) *MockStreamISetWriteDeadlineCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetWriteDeadlineCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// StreamID mocks base method.
func (m *MockStreamI) StreamID() protocol.StreamID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StreamID")
ret0, _ := ret[0].(protocol.StreamID)
return ret0
}
// StreamID indicates an expected call of StreamID.
func (mr *MockStreamIMockRecorder) StreamID() *MockStreamIStreamIDCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStreamI)(nil).StreamID))
return &MockStreamIStreamIDCall{Call: call}
}
// MockStreamIStreamIDCall wrap *gomock.Call
type MockStreamIStreamIDCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamIStreamIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Write mocks base method.
func (m *MockStreamI) Write(arg0 []byte) (int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Write", arg0)
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Write indicates an expected call of Write.
func (mr *MockStreamIMockRecorder) Write(arg0 any) *MockStreamIWriteCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStreamI)(nil).Write), arg0)
return &MockStreamIWriteCall{Call: call}
}
// MockStreamIWriteCall wrap *gomock.Call
type MockStreamIWriteCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIWriteCall) Return(arg0 int, arg1 error) *MockStreamIWriteCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIWriteCall) Do(f func([]byte) (int, error)) *MockStreamIWriteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIWriteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// closeForShutdown mocks base method.
func (m *MockStreamI) closeForShutdown(arg0 error) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "closeForShutdown", arg0)
}
// closeForShutdown indicates an expected call of closeForShutdown.
func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 any) *MockStreamIcloseForShutdownCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockStreamI)(nil).closeForShutdown), arg0)
return &MockStreamIcloseForShutdownCall{Call: call}
}
// MockStreamIcloseForShutdownCall wrap *gomock.Call
type MockStreamIcloseForShutdownCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIcloseForShutdownCall) Return() *MockStreamIcloseForShutdownCall {
c.Call = c.Call.Return()
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIcloseForShutdownCall) Do(f func(error)) *MockStreamIcloseForShutdownCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *MockStreamIcloseForShutdownCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// handleResetStreamFrame mocks base method.
func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// handleResetStreamFrame indicates an expected call of handleResetStreamFrame.
func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 any) *MockStreamIhandleResetStreamFrameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleResetStreamFrame), arg0)
return &MockStreamIhandleResetStreamFrameCall{Call: call}
}
// MockStreamIhandleResetStreamFrameCall wrap *gomock.Call
type MockStreamIhandleResetStreamFrameCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIhandleResetStreamFrameCall) Return(arg0 error) *MockStreamIhandleResetStreamFrameCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// handleStopSendingFrame mocks base method.
func (m *MockStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "handleStopSendingFrame", arg0)
}
// handleStopSendingFrame indicates an expected call of handleStopSendingFrame.
func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 any) *MockStreamIhandleStopSendingFrameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockStreamI)(nil).handleStopSendingFrame), arg0)
return &MockStreamIhandleStopSendingFrameCall{Call: call}
}
// MockStreamIhandleStopSendingFrameCall wrap *gomock.Call
type MockStreamIhandleStopSendingFrameCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIhandleStopSendingFrameCall) Return() *MockStreamIhandleStopSendingFrameCall {
c.Call = c.Call.Return()
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// handleStreamFrame mocks base method.
func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "handleStreamFrame", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// handleStreamFrame indicates an expected call of handleStreamFrame.
func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 any) *MockStreamIhandleStreamFrameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleStreamFrame), arg0)
return &MockStreamIhandleStreamFrameCall{Call: call}
}
// MockStreamIhandleStreamFrameCall wrap *gomock.Call
type MockStreamIhandleStreamFrameCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIhandleStreamFrameCall) Return(arg0 error) *MockStreamIhandleStreamFrameCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// hasData mocks base method.
func (m *MockStreamI) hasData() bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "hasData")
ret0, _ := ret[0].(bool)
return ret0
}
// hasData indicates an expected call of hasData.
func (mr *MockStreamIMockRecorder) hasData() *MockStreamIhasDataCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockStreamI)(nil).hasData))
return &MockStreamIhasDataCall{Call: call}
}
// MockStreamIhasDataCall wrap *gomock.Call
type MockStreamIhasDataCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIhasDataCall) Return(arg0 bool) *MockStreamIhasDataCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIhasDataCall) Do(f func() bool) *MockStreamIhasDataCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIhasDataCall) DoAndReturn(f func() bool) *MockStreamIhasDataCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// popStreamFrame mocks base method.
func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount, arg1 protocol.Version) (ackhandler.StreamFrame, bool, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "popStreamFrame", arg0, arg1)
ret0, _ := ret[0].(ackhandler.StreamFrame)
ret1, _ := ret[1].(bool)
ret2, _ := ret[2].(bool)
return ret0, ret1, ret2
}
// popStreamFrame indicates an expected call of popStreamFrame.
func (mr *MockStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *MockStreamIpopStreamFrameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockStreamI)(nil).popStreamFrame), arg0, arg1)
return &MockStreamIpopStreamFrameCall{Call: call}
}
// MockStreamIpopStreamFrameCall wrap *gomock.Call
type MockStreamIpopStreamFrameCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *MockStreamIpopStreamFrameCall {
c.Call = c.Call.Return(arg0, arg1, arg2)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// updateSendWindow mocks base method.
func (m *MockStreamI) updateSendWindow(arg0 protocol.ByteCount) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "updateSendWindow", arg0)
}
// updateSendWindow indicates an expected call of updateSendWindow.
func (mr *MockStreamIMockRecorder) updateSendWindow(arg0 any) *MockStreamIupdateSendWindowCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "updateSendWindow", reflect.TypeOf((*MockStreamI)(nil).updateSendWindow), arg0)
return &MockStreamIupdateSendWindowCall{Call: call}
}
// MockStreamIupdateSendWindowCall wrap *gomock.Call
type MockStreamIupdateSendWindowCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockStreamIupdateSendWindowCall) Return() *MockStreamIupdateSendWindowCall {
c.Call = c.Call.Return()
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockStreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
```
|
Humphrey Colles (by 1510 – c. 1570), of Barton Grange (Corfe, Somerset) and Nether Stowey, Somerset, was an English lawyer, land agent and politician during the reign of Mary I. Colles served as MP for Somerset in 1554-54 and High Sheriff of Somerset in 1557–58.
References
Politicians from Somerset
English MPs 1554–1555
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package io.camunda.zeebe.model.bpmn.impl.instance;
import static io.camunda.zeebe.model.bpmn.impl.BpmnModelConstants.BPMN20_NS;
import static io.camunda.zeebe.model.bpmn.impl.BpmnModelConstants.BPMN_ATTRIBUTE_IMPORT_TYPE;
import static io.camunda.zeebe.model.bpmn.impl.BpmnModelConstants.BPMN_ATTRIBUTE_LOCATION;
import static io.camunda.zeebe.model.bpmn.impl.BpmnModelConstants.BPMN_ATTRIBUTE_NAMESPACE;
import static io.camunda.zeebe.model.bpmn.impl.BpmnModelConstants.BPMN_ELEMENT_IMPORT;
import io.camunda.zeebe.model.bpmn.instance.Import;
import org.camunda.bpm.model.xml.ModelBuilder;
import org.camunda.bpm.model.xml.impl.instance.ModelTypeInstanceContext;
import org.camunda.bpm.model.xml.type.ModelElementTypeBuilder;
import org.camunda.bpm.model.xml.type.ModelElementTypeBuilder.ModelTypeInstanceProvider;
import org.camunda.bpm.model.xml.type.attribute.Attribute;
/**
* The BPMN import element
*
* @author Daniel Meyer
* @author Sebastian Menski
*/
public class ImportImpl extends BpmnModelElementInstanceImpl implements Import {
protected static Attribute<String> namespaceAttribute;
protected static Attribute<String> locationAttribute;
protected static Attribute<String> importTypeAttribute;
public ImportImpl(final ModelTypeInstanceContext context) {
super(context);
}
public static void registerType(final ModelBuilder bpmnModelBuilder) {
final ModelElementTypeBuilder typeBuilder =
bpmnModelBuilder
.defineType(Import.class, BPMN_ELEMENT_IMPORT)
.namespaceUri(BPMN20_NS)
.instanceProvider(
new ModelTypeInstanceProvider<Import>() {
@Override
public Import newInstance(final ModelTypeInstanceContext instanceContext) {
return new ImportImpl(instanceContext);
}
});
namespaceAttribute = typeBuilder.stringAttribute(BPMN_ATTRIBUTE_NAMESPACE).required().build();
locationAttribute = typeBuilder.stringAttribute(BPMN_ATTRIBUTE_LOCATION).required().build();
importTypeAttribute =
typeBuilder.stringAttribute(BPMN_ATTRIBUTE_IMPORT_TYPE).required().build();
typeBuilder.build();
}
@Override
public String getNamespace() {
return namespaceAttribute.getValue(this);
}
@Override
public void setNamespace(final String namespace) {
namespaceAttribute.setValue(this, namespace);
}
@Override
public String getLocation() {
return locationAttribute.getValue(this);
}
@Override
public void setLocation(final String location) {
locationAttribute.setValue(this, location);
}
@Override
public String getImportType() {
return importTypeAttribute.getValue(this);
}
@Override
public void setImportType(final String importType) {
importTypeAttribute.setValue(this, importType);
}
}
```
|
```java
/*
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.rql.rule.sharding;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.DatabaseContainedTestCase;
/**
* Show default sharding strategy statement test case.
*/
public final class ShowDefaultShardingStrategyStatementTestCase extends DatabaseContainedTestCase {
}
```
|
```python
import pytest
import defusedxml.ElementTree as defused_ET
from CommonServerPython import *
ACCOUNT_NAME = "test"
BASE_URL = f'https://{ACCOUNT_NAME}.file.core.windows.net/'
SAS_TOKEN = "XXXX"
API_VERSION = "2020-10-02"
def load_xml_mock_response(file_name: str) -> str:
"""
Load one of the mock responses to be used for assertion.
Args:
file_name (str): Name of the mock response XML file to return.
"""
file_path = f'test_data/{file_name}'
top = defused_ET.parse(file_path)
return ET.tostring(top.getroot(), encoding='utf8').decode("utf-8")
def test_azure_storage_create_share_command(requests_mock):
"""
Scenario: Create new Share.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-create called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
- Ensure validation of the share name.
"""
from AzureStorageFileShare import Client, create_share_command
share_name = 'test'
url = f'{BASE_URL}{share_name}?{SAS_TOKEN}&restype=share'
requests_mock.put(url, text="")
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = create_share_command(client, {'share_name': share_name})
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'Share {share_name} successfully created.'
invalid_share_name = 'test--1'
with pytest.raises(Exception):
create_share_command(client, {'share_name': invalid_share_name})
def test_azure_storage_delete_share_command(requests_mock):
"""
Scenario: Delete Share.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-delete called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
"""
from AzureStorageFileShare import Client, delete_share_command
share_name = 'test'
url = f'{BASE_URL}{share_name}?{SAS_TOKEN}&restype=share'
requests_mock.delete(url, text="")
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = delete_share_command(client, {'share_name': share_name})
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'Share {share_name} successfully deleted.'
def test_azure_storage_list_shares_command(requests_mock):
"""
Scenario: List Shares.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-list called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure a sample value from the API matches what is generated in the context.
"""
from AzureStorageFileShare import Client, list_shares_command
url = f'{BASE_URL}?{SAS_TOKEN}&comp=list&maxresults=50'
mock_response = load_xml_mock_response('shares.xml')
requests_mock.get(url, text=mock_response)
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = list_shares_command(client, {})
assert len(result.outputs) == 2
assert result.outputs_prefix == 'AzureStorageFileShare.Share'
assert result.outputs[0].get('Name') == 'my-file-share'
assert result.outputs[1].get('Name') == 'my-share'
def test_azure_storage_list_directories_and_files_command(requests_mock):
"""
Scenario: List directories and files.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-content-list called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure a sample value from the API matches what is generated in the context.
"""
from AzureStorageFileShare import Client, list_directories_and_files_command
share_name = "test"
url = f'{BASE_URL}{share_name}?{SAS_TOKEN}&restype=directory&comp=list&include=Timestamps&maxresults=50'
mock_response = load_xml_mock_response('files.xml')
requests_mock.get(url, text=mock_response)
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = list_directories_and_files_command(client, {'share_name': share_name})
assert len(result.outputs) == 2
assert len(result.outputs.get('Content')) == 4
assert len(result.outputs.get('Content').get('Directory')) == 1
assert len(result.outputs.get('Content').get('File')) == 1
assert result.outputs_prefix == 'AzureStorageFileShare.Share'
assert result.outputs.get('Content')['File'][0].get('Name') == 'AzureStorage_image.png'
assert result.outputs.get('Name') == share_name
def test_azure_storage_create_directory_command(requests_mock):
"""
Scenario: Create directory.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-directory-create called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
- Ensure validation of the directory name.
"""
from AzureStorageFileShare import Client, create_directory_command
share_name = "test"
directory_name = "test_new_directory"
url = f'{BASE_URL}{share_name}/{directory_name}?{SAS_TOKEN}&restype=directory'
requests_mock.put(url, text='')
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = create_directory_command(client, {'share_name': share_name,
'directory_name': directory_name})
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'{directory_name} Directory successfully created in {share_name}.'
invalid_directory_name = 'test<1'
with pytest.raises(Exception):
create_directory_command(client, {'share_name': share_name,
'directory_name': invalid_directory_name})
def test_azure_storage_delete_directory_command(requests_mock):
"""
Scenario: Delete directory.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-directory-delete called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
"""
from AzureStorageFileShare import Client, delete_directory_command
share_name = "test"
directory_name = "test_new_directory"
url = f'{BASE_URL}{share_name}/{directory_name}?{SAS_TOKEN}&restype=directory'
requests_mock.delete(url, text='')
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = delete_directory_command(client, {'share_name': share_name,
'directory_name': directory_name})
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'{directory_name} Directory successfully deleted from {share_name}.'
def test_azure_storage_get_file_command(requests_mock):
"""
Scenario: Get file.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-file-get called.
Then:
- Ensure XSOAR File output.
"""
from AzureStorageFileShare import Client, get_file_command
share_name = "test"
file_name = "test_file.txt"
url = f'{BASE_URL}{share_name}/{file_name}?{SAS_TOKEN}'
with open('test_data/test_file.txt', 'rb') as text_file_mock:
requests_mock.get(url, content=text_file_mock.read())
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = get_file_command(client, {'share_name': share_name,
'file_name': file_name})
assert result['ContentsFormat'] == 'text'
assert result['Type'] == EntryType.FILE
assert result['File'] == file_name
assert len(result) == 5
def test_azure_storage_delete_file_command(requests_mock):
"""
Scenario: Delete file
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-file-delete called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
"""
from AzureStorageFileShare import Client, delete_file_command
share_name = "test"
file_name = "test_file.txt"
url = f'{BASE_URL}{share_name}/{file_name}?{SAS_TOKEN}'
requests_mock.delete(url, text='')
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = delete_file_command(client, {'share_name': share_name,
'file_name': file_name})
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'File {file_name} successfully deleted from {share_name}.'
def test_validate_characters():
"""
Test validate_characters function.
Scenarios:
- Send valid string to function.
- Send invalid string to function.
Then:
- Ensure that the output is correct (True / False).
"""
from AzureStorageFileShare import validate_characters
valida_string = "my-valid-test"
invalid_string = "my-invalid|test"
assert validate_characters(valida_string, "\"\/:|<>*?")
assert not validate_characters(invalid_string, "\"\/:|<>*?")
def test_create_file_command(requests_mock, mocker):
"""
Scenario: Create a file in Share from War room file Entry ID.
Given:
- User has provided valid credentials.
When:
- azure-storage-fileshare-file-create called.
Then:
- Ensure that the output is empty (None).
- Ensure readable output message content.
"""
mocker.patch('shutil.copy')
mocker.patch('shutil.rmtree')
mocker.patch.object(demisto, 'getFilePath', return_value={'path': 'my_local_path', 'name': 'my_file_name'})
mock_read = mocker.mock_open(read_data="XSOAR-TEST")
mocker.patch('AzureStorageFileShare.open', mock_read)
from AzureStorageFileShare import Client, create_file_command
share_name = "test"
file_entry_id = "12345"
directory_path = "xsoar/path"
file_name = "test_file.txt"
command_arguments = {"share_name": share_name, "file_entry_id": file_entry_id,
"directory_path": directory_path, "file_name": file_name}
url = f'{BASE_URL}{share_name}/{directory_path}/{file_name}?{SAS_TOKEN}'
requests_mock.put(url, text='', status_code=201)
url = f'{BASE_URL}{share_name}/{directory_path}/{file_name}?{SAS_TOKEN}&comp=range'
requests_mock.put(url, text='', status_code=201)
client = Client(server_url=BASE_URL, verify=False, proxy=False,
account_sas_token=SAS_TOKEN,
storage_account_name=ACCOUNT_NAME, api_version=API_VERSION)
result = create_file_command(client, command_arguments)
assert result.outputs is None
assert result.outputs_prefix is None
assert result.readable_output == f'File successfully created in {share_name}.'
```
|
```c++
#ifndef BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
#define BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
//
// (See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
//
// See path_to_url for documentation.
// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
// $Revision: 49267 $
#include <boost/mpl/erase_key_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
namespace boost { namespace mpl {
template< typename Tag >
struct erase_key_impl
{
template< typename Sequence, typename Key > struct apply;
};
BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, erase_key_impl)
}}
#endif // BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
```
|
Charles W. Hunt (January 2, 1864 – August 16, 1938) was an Iowa politician who served as the chair of the Federal Trade Commission from December 1, 1926 to November 30, 1927, and again from January 1, 1931 to December 31, 1931.
Born in Logan, Iowa, Hunt received an undergraduate degree from Iowa State University in 1888, and worked for a time as a teacher and a farmer. In 1911, Hunt was elected as a Republican to represent Harrison County, Iowa, in the Thirty-fourth and Thirty-fifth sessions of the Iowa General Assembly, in the Iowa House of Representatives, serving until 1915. He held various other state offices and trade organization positions until 1924, when President Calvin Coolidge appointed Hunt to a seat on the FTC vacated by the resignation of Victor Murdock.
Hunt's reappointment was contested in the Senate, where Senator William H. King of Utah objected, asserting "that Hunt was a reactionary and was not enforcing the law". After several weeks of delay, Hunt was reconfirmed. Hunt retired from the FTC in 1932, and remained in Washington, D.C., until his death, at the age of 74.
References
Federal Trade Commission personnel
1864 births
1938 deaths
People from Logan, Iowa
Iowa State University alumni
Republican Party members of the Iowa House of Representatives
|
Carrier Air Wing Two (CVW-2) is a United States Navy aircraft carrier air wing based at Naval Air Station Lemoore. The air wing is attached to the aircraft carrier .
Subordinate units
CVW-2 consists of 8 squadrons and one detachment.
History
1940s-50s
Originally established as CVBG-74 (Battle Air Group) on 1 May 1945, it was renamed CVBG-1 on 15 November 1946 before finally being renamed CVG-2 in 1948. During that time, CVG-2 was assigned to (CVB-41). CVG-2 later would see action during the Korean War on board the Essex-class carriers , Valley Forge and Philippine Sea. During the war, they supported the Inchon Invasion, bombing of North Korea-occupied Seoul and the recapture of Kimpo Airfield. Starting in 1958, the squadron started an 8-year association with the USS Midway which ended in 1966.
1960s
In 1961, the first A4D-2 (A-4B) Skyhawks to join CVW-2 came aboard during a deployment in the Taiwan Strait during tensions between the two chinas (People's Republic of China and 'Republic of China' on Taiwan). In late 63', CVG-2 made their first deployment with the new F-4H-1F (F-4B) Phantom II with VF-21.
It during the first deployment to the Vietnam War that VF-21 as part of the renamed CVW-2 scored the first air to air kills of Vietnam War. In a first for CVW-2, the air wing deployed with the F-4 as the only fighter aircraft on board as well as the E-2A Hawkeye joining the air wing. It was in 1967 that CVW-2 began their long assignment to the USS Ranger (CV/A-61) which would last till the Rangers retirement in 1993 (excluding the mid-1980s). With the new A-7A Corsair II and A-6A Intruder, they became the first all-jet attack carrier air wing. CVW-2 spent thirty days in the Sea of Japan due to seizure of the .
1970s
In December 1972 during their last deployment in the Vietnam War, CVW-2's squadrons introduced laser-guided bombs into Navy combat service, with VA-145 destroying fourteen out of fifteen targeted bridges in under 3 hours. CVW-2 was later renamed from Attack Carrier Air Wing Two to Carrier Air Wing Two due to the addition of Anti-submarine warfare units including VS-29 flying the S-3A Viking and HS-4 flying the SH-3D/G (later SH-3H) Sea King helicopter.
1980s
Starting in 1980, the first F-14A Tomcat squadrons VF-1 and VF-2 were assigned to CVW-2, replacing VF-154 and VF-21 both flying the F-4J Phantom. Between 1982 and 1986, CVW-2 was reassigned to the USS Kitty Hawk (CV-63) making one deployment to the West Pacific and Indian Ocean along with the newly assigned VS-38. In May 1986, CVW-2 returned to the Ranger. Starting between 1986 and 1993, CVW-2 was nicknamed the "Grumman Air Wing" due to lack of a light attack squadron flying either the A-7E Corsair II or the newer F/A-18A Hornet. The only change made was with the newer VA-155 replacing the USMC squadron VMA(AW)-121 in 1990.
1990s
With the invasion of Kuwait by Iraq on 2 August 1990, USS Ranger and CVW-2 deployed on 8 December to take in Operation Desert Shield, transiting the Strait of Hormuz on 15 January 1991. At around 4:00 am on 17 January 1991, while USS Midway's air wing were striking targets in Iraq on the first night of the war, the "William Tell Overture" was broadcast around the Ranger as CVW-2 launched to strike targets that morning. During the strike, CVW-2's aircraft struck the port of Umm Qasr and the Mina al-Bakr oil terminal with cluster bombs. For the next 75 hours, they flew more strike missions against Iraqi military targets. During war, the "Grumman Air Wing" was well suited as the primary night Air Wing, with 75 percent of their 10,500 hours being flown at night. With the war over in February 1991, the Ranger and CVW-2 returned to San Diego on 8 June 1991.
In 1992, after take in Operation Southern Watch, CVW-2 sailed to Somalia becoming the first Air Wing to take part in Operation Restore Hope, providing air coverage for ground forces and controlling all air traffic into the capital of Mogadishu.
In early 1993, VA-155, VF-1 and USS Ranger were decommissioned followed by VA-145 as the A-6E TRAM Intruder was being retired from Navy service. During that time, CVW-2 moved the USS Constellation CV-64 and became the first 50 Strike Fighter Air Wing in the US Navy. Between 1995 and 1997, CVW-2 deployed also with a detachment from VQ-5 flying the ES-3A Shadow based on the S-3 Viking.
2000s
During its 2004–2005 deployment, Carrier Air Wing Two executed 4400 fixed-wing sorties for a total of 7588 flight hours, as well as 1518 rotary-wing sorties for a total of 4401 flight hours. The air wing also completed 4455 flight deck landings (traps) while also flying 1737 humanitarian relief missions in support of Operation Unified Assistance between 26 December 2004 and 3 February 2005.
During its 2006 deployment, Carrier Air Wing Two participated in three major exercises (i.e., Foal Eagle 06, Valiant Shield 06, RIMPAC 06), and its aircraft flew 7,871 sorties, with a total of 7,578 catapult launches from the flight deck of the Abraham Lincoln. Between 24–31 March 2006, during Foal Eagle 2006 exercises, strike squadrons VFA-2, VFA-34, VFA-137, and VFA-151 from Carrier Air Wing Two teamed with U.S. Air Force aircraft from the 18th Wing based at Kadena Air Base to provide combat air patrols and coordinated bombing runs via the exercise's Combined Air Operations Center.
During its 2008 deployment, Carrier Air Wing Two flew approximately 7,100 sorties, totaling more than 22,000 flight hours, which included 2,307 combat sorties that dropped 255,963 pounds (116,102,863.8 kg) of ordnance in support of Operation Enduring Freedom – Afghanistan (OEF-A) and Operation Iraqi Freedom (OIF) as a part of the U.S. Fifth Fleet.
2010s
When Abraham Lincoln began its Refueling and Complex Overhaul in 2013, CVW-2 was reassigned to . It made only a short deployment aboard Ronald Reagan during exercise RIMPAC between June and August 2014, before the carrier was stationed in Japan. CVW-2 then accompanied for her voyage around South America from September to December 2015.
In 2016, CVW-2 was reassigned to . The wing made its next deployment to the Western Pacific aboard Carl Vinson from 23 January to 23 June 2017.
On 5 January 2018, CVW-2 left San Diego aboard Carl Vinson for another scheduled deployment to the Western Pacific. Carl Vinson returned to San Diego on 12 April 2018.
Current force
Fixed-wing aircraft
F/A-18E/F Super Hornet
F-35C Lightning II
E/A-18G Growler
E-2D Advanced Hawkeye
CMV-22B Osprey
Rotary-wing aircraft
MH-60R Seahawk
MH-60S Seahawk
See also
List of United States Navy Carrier air wings
History of the United States Navy
References
External links
Carrier Air Wing Two (official site)
CVW-02
Military units and formations in California
AW0002
Military units and formations of the United States in the Gulf War
Military units and formations established in 1963
Vinson is not carrying VRC-30 Det 2, she is carrying VRM-30 Titans, because of the F-35C engine lift requirement
|
Subramaniam Rajesh, popularly known as S.Rajesh, was an Indian cricketer, who has represented Kerala in 27 first-class matches between 1981 and 1989. Rajesh, captaining two matches, was an allrounder, along with his cricketer brothers S.Ramesh and S.Santosh, played an integral role in making Kerala cricket team, a notable one of South India in 80's. Rajesh has scored over 1000 runs including 7 half centuries and has also served the state as a selector.
References
External links
1959 births
Kerala cricketers
Indian cricketers
South Zone cricketers
Cricketers from Thiruvananthapuram
2009 deaths
|
```objective-c
/*++
version 3. Alternative licensing terms are available. Contact
info@minocacorp.com for details. See the LICENSE file at the root of this
project for complete licensing information.
Module Name:
imp.h
Abstract:
This header contains definitions internal to the Image Library.
Author:
Evan Green 13-Oct-2012
--*/
//
// your_sha256_hash--- Includes
//
#define RTL_API __DLLEXPORT
#include <minoca/kernel/driver.h>
#include "immux.h"
//
// your_sha256_hash Definitions
//
//
// Define the initial amount to read for loading image segments.
//
#define IMAGE_INITIAL_READ_SIZE 1024
//
// Define the macros to the various functions.
//
#define ImAllocateMemory ImImportTable->AllocateMemory
#define ImFreeMemory ImImportTable->FreeMemory
#define ImOpenFile ImImportTable->OpenFile
#define ImCloseFile ImImportTable->CloseFile
#define ImLoadFile ImImportTable->LoadFile
#define ImReadFile ImImportTable->ReadFile
#define ImUnloadBuffer ImImportTable->UnloadBuffer
#define ImAllocateAddressSpace ImImportTable->AllocateAddressSpace
#define ImFreeAddressSpace ImImportTable->FreeAddressSpace
#define ImMapImageSegment ImImportTable->MapImageSegment
#define ImUnmapImageSegment ImImportTable->UnmapImageSegment
#define ImNotifyImageLoad ImImportTable->NotifyImageLoad
#define ImNotifyImageUnload ImImportTable->NotifyImageUnload
#define ImInvalidateInstructionCacheRegion \
ImImportTable->InvalidateInstructionCacheRegion
#define ImGetEnvironmentVariable ImImportTable->GetEnvironmentVariable
#define ImFinalizeSegments ImImportTable->FinalizeSegments
//
// Define the initial scope array size.
//
#define IM_INITIAL_SCOPE_SIZE 8
//
// Define the maximum size a collection of shared object dependencies can
// reasonably grow to.
//
#define IM_MAX_SCOPE_SIZE 0x10000
//
// ------------------------------------------------------ Data Type Definitions
//
//
// your_sha256_hash---- Globals
//
//
// Define the table of functions called by the image library.
//
extern PIM_IMPORT_TABLE ImImportTable;
//
// -------------------------------------------------------- Function Prototypes
//
PVOID
ImpReadBuffer (
PIMAGE_FILE_INFORMATION File,
PIMAGE_BUFFER Buffer,
UINTN Offset,
UINTN Size
);
/*++
Routine Description:
This routine handles access to an image buffer.
Arguments:
File - Supplies an optional pointer to the file information, if the buffer
may need to be resized.
Buffer - Supplies a pointer to the buffer to read from.
Offset - Supplies the offset from the start of the file to read.
Size - Supplies the required size.
Return Value:
Returns a pointer to the image file at the requested offset on success.
NULL if the range is invalid or the file could not be fully loaded.
--*/
KSTATUS
ImpLoad (
PLIST_ENTRY ListHead,
PCSTR BinaryName,
PIMAGE_FILE_INFORMATION BinaryFile,
PIMAGE_BUFFER ImageBuffer,
PVOID SystemContext,
ULONG Flags,
PLOADED_IMAGE Parent,
PLOADED_IMAGE *LoadedImage,
PLOADED_IMAGE *Interpreter
);
/*++
Routine Description:
This routine loads an executable image into memory.
Arguments:
ListHead - Supplies a pointer to the head of the list of loaded images.
BinaryName - Supplies the name of the binary executable image to load. If
this is NULL, then a pointer to the first (primary) image loaded, with
a reference added.
BinaryFile - Supplies an optional handle to the file information. The
handle should be positioned to the beginning of the file. Supply NULL
if the caller does not already have an open handle to the binary. On
success, the image library takes ownership of the handle.
ImageBuffer - Supplies an optional pointer to the image buffer. This can
be a complete image file buffer, or just a partial load of the file.
SystemContext - Supplies an opaque token that will be passed to the
support functions called by the image support library.
Flags - Supplies a bitfield of flags governing the load. See
IMAGE_LOAD_FLAG_* flags.
Parent - Supplies an optional pointer to the parent image that imports this
image.
LoadedImage - Supplies an optional pointer where a pointer to the loaded
image structure will be returned on success.
Interpreter - Supplies an optional pointer where a pointer to the loaded
interpreter structure will be returned on success.
Return Value:
Status code.
--*/
KSTATUS
ImpAddImageToScope (
PLOADED_IMAGE Parent,
PLOADED_IMAGE Child
);
/*++
Routine Description:
This routine appends a breadth first traversal of the child's dependencies
to the image scope.
Arguments:
Parent - Supplies a pointer to the innermost scope to add the child to.
Child - Supplies a pointer to the child to add to the scope. This is often
the parent itself.
Return Value:
STATUS_SUCCESS on success.
STATUS_INSUFFICIENT_RESOURCES if there was an allocation failure.
--*/
```
|
```javascript
Computed property names in object literals
Handling modules
Typed Arrays
The `for-of` loop in ES6
ES6 `Number` methods
```
|
QUCHIC (BB-22, SGT-32 or 1-(cyclohexylmethyl)-1H-indole-3-carboxylic acid 8-quinolinyl ester) is a designer drug offered by online vendors as a cannabimimetic agent, and was first detected being sold in synthetic cannabis products in Japan in early 2013, and subsequently also in New Zealand. The structure of QUCHIC appears to use an understanding of structure-activity relationships within the indole class of cannabimimetics, although its design origins are unclear. QUCHIC, along with QUPIC, represents a structurally unique synthetic cannabinoid chemotype since it contains an ester linker at the indole 3-position rather than the precedented ketone of JWH-018 and its analogues, or the amide of SDB-001 and its analogues.
Pharmacology
BB-22 acts as a full agonist with a binding affinity of 0.217nM at CB1 and 0.338nM at CB2 cannabinoid receptors.
See also
5F-PB-22
JWH-018
PB-22
QUPIC
SDB-001
SDB-005
References
Cannabinoids
Designer drugs
Indoles
Indolecarboxylates
|
```go
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
// Code generated by client-gen. DO NOT EDIT.
package fake
import (
"context"
v1beta1 "github.com/kubernetes-sigs/service-catalog/pkg/apis/servicecatalog/v1beta1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeClusterServiceClasses implements ClusterServiceClassInterface
type FakeClusterServiceClasses struct {
Fake *FakeServicecatalogV1beta1
}
var clusterserviceclassesResource = schema.GroupVersionResource{Group: "servicecatalog.k8s.io", Version: "v1beta1", Resource: "clusterserviceclasses"}
var clusterserviceclassesKind = schema.GroupVersionKind{Group: "servicecatalog.k8s.io", Version: "v1beta1", Kind: "ClusterServiceClass"}
// Get takes name of the clusterServiceClass, and returns the corresponding clusterServiceClass object, and an error if there is any.
func (c *FakeClusterServiceClasses) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.ClusterServiceClass, err error) {
obj, err := c.Fake.
Invokes(testing.NewRootGetAction(clusterserviceclassesResource, name), &v1beta1.ClusterServiceClass{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.ClusterServiceClass), err
}
// List takes label and field selectors, and returns the list of ClusterServiceClasses that match those selectors.
func (c *FakeClusterServiceClasses) List(ctx context.Context, opts v1.ListOptions) (result *v1beta1.ClusterServiceClassList, err error) {
obj, err := c.Fake.
Invokes(testing.NewRootListAction(clusterserviceclassesResource, clusterserviceclassesKind, opts), &v1beta1.ClusterServiceClassList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1beta1.ClusterServiceClassList{ListMeta: obj.(*v1beta1.ClusterServiceClassList).ListMeta}
for _, item := range obj.(*v1beta1.ClusterServiceClassList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested clusterServiceClasses.
func (c *FakeClusterServiceClasses) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewRootWatchAction(clusterserviceclassesResource, opts))
}
// Create takes the representation of a clusterServiceClass and creates it. Returns the server's representation of the clusterServiceClass, and an error, if there is any.
func (c *FakeClusterServiceClasses) Create(ctx context.Context, clusterServiceClass *v1beta1.ClusterServiceClass, opts v1.CreateOptions) (result *v1beta1.ClusterServiceClass, err error) {
obj, err := c.Fake.
Invokes(testing.NewRootCreateAction(clusterserviceclassesResource, clusterServiceClass), &v1beta1.ClusterServiceClass{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.ClusterServiceClass), err
}
// Update takes the representation of a clusterServiceClass and updates it. Returns the server's representation of the clusterServiceClass, and an error, if there is any.
func (c *FakeClusterServiceClasses) Update(ctx context.Context, clusterServiceClass *v1beta1.ClusterServiceClass, opts v1.UpdateOptions) (result *v1beta1.ClusterServiceClass, err error) {
obj, err := c.Fake.
Invokes(testing.NewRootUpdateAction(clusterserviceclassesResource, clusterServiceClass), &v1beta1.ClusterServiceClass{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.ClusterServiceClass), err
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeClusterServiceClasses) UpdateStatus(ctx context.Context, clusterServiceClass *v1beta1.ClusterServiceClass, opts v1.UpdateOptions) (*v1beta1.ClusterServiceClass, error) {
obj, err := c.Fake.
Invokes(testing.NewRootUpdateSubresourceAction(clusterserviceclassesResource, "status", clusterServiceClass), &v1beta1.ClusterServiceClass{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.ClusterServiceClass), err
}
// Delete takes name of the clusterServiceClass and deletes it. Returns an error if one occurs.
func (c *FakeClusterServiceClasses) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewRootDeleteAction(clusterserviceclassesResource, name), &v1beta1.ClusterServiceClass{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeClusterServiceClasses) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
action := testing.NewRootDeleteCollectionAction(clusterserviceclassesResource, listOpts)
_, err := c.Fake.Invokes(action, &v1beta1.ClusterServiceClassList{})
return err
}
// Patch applies the patch and returns the patched clusterServiceClass.
func (c *FakeClusterServiceClasses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.ClusterServiceClass, err error) {
obj, err := c.Fake.
Invokes(testing.NewRootPatchSubresourceAction(clusterserviceclassesResource, name, pt, data, subresources...), &v1beta1.ClusterServiceClass{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.ClusterServiceClass), err
}
```
|
```java
/*
* Contributions to FindBugs
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*
* You should have received a copy of the GNU Lesser General Public
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package de.tobject.findbugs.properties.test;
import java.io.File;
import java.util.ArrayList;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.TabFolder;
import de.tobject.findbugs.properties.FilterFilesTab;
import de.tobject.findbugs.properties.FindbugsPropertyPage;
import de.tobject.findbugs.properties.IPathElement;
/**
* Test subclass of FilterFilesTab that provides methods for testing purposes.
*
* @author Toms Pollak
*/
public class FilterFilesTabTestSubclass extends FilterFilesTab {
public FilterFilesTabTestSubclass(TabFolder tabFolder, FindbugsPropertyPage page, int style) {
super(tabFolder, page, style);
}
public void addFileToExcludeBugsFilter(String file) {
((FilterProviderTestSubclass) getFilterExclBugs()).addFile(file);
}
public void addFileToExcludeFilter(String file) {
((FilterProviderTestSubclass) getFilterExcl()).addFile(file);
}
public void addFileToIncludeFilter(String file) {
((FilterProviderTestSubclass) getFilterIncl()).addFile(file);
}
public void removeFilesFromExcludeBugsFilter() {
((FilterProviderTestSubclass) getFilterExclBugs()).removeAllFiles();
}
public void removeFilesFromExcludeFilter() {
((FilterProviderTestSubclass) getFilterExcl()).removeAllFiles();
}
public void removeFilesFromIncludeFilter() {
((FilterProviderTestSubclass) getFilterIncl()).removeAllFiles();
}
@Override
protected FilterProvider createFilterProvider(TableViewer viewer, FilterKind kind, FindbugsPropertyPage page) {
return new FilterProviderTestSubclass(viewer, kind, page);
}
private class FilterProviderTestSubclass extends FilterProvider {
private String fileLocation;
private String parentPath;
private String fileName;
protected FilterProviderTestSubclass(TableViewer viewer, FilterKind kind, FindbugsPropertyPage propertyPage) {
super(viewer, kind, propertyPage);
}
public void addFile(String fileLocation) {
File file = new File(fileLocation);
this.fileLocation = fileLocation;
this.fileName = file.getName();
this.parentPath = file.getParent();
addFiles(FilterFilesTabTestSubclass.this.getShell());
}
public void removeAllFiles() {
for (IPathElement pathElement : new ArrayList<IPathElement>(paths)) {
remove(pathElement);
}
}
@Override
protected String[] getFileNames(FileDialog dialog) {
return new String[] { fileName };
}
@Override
protected String getFilePath(FileDialog dialog) {
return parentPath;
}
@Override
protected String openFileDialog(FileDialog dialog) {
return fileLocation;
}
}
}
```
|
The Dakota Hogback is a long hogback ridge at the eastern fringe of the Rocky Mountains that extends north-south from southern Wyoming through Colorado and into northern New Mexico in the United States. The ridge is prominently visible as the first line of foothills along the edge of the Great Plains. It is generally faulted along its western side, and varies in height, with gaps in numerous locations where rivers exit the mountains. The ridge takes its name from the Dakota Formation, a formation with resistant sandstone beds that cap the ridge. The hogback was formed during the Laramide orogeny, approximately 50 million years (50 my) ago, when the modern Rockies were created. The general uplift to the west created long faulting in the North American Plate, resulting in the creation of the hogback.
While the hogback was created during the Laramide Orogeny, the geologic strata comprising the hogback are much older. For example, fossilized data such as dinosaur footprints have been observed in the exposed strata, created by dinosaurs which lived during the Jurassic Period approximately 150 million years ago. Some of these footprints were attributed to the Diplodocus dinosaur and could be seen on the hogback west of Denver, Colorado as recently as the 1980s.
The ridge forms a barrier between the high plains and the Rocky Mountain foothills. The ridge is pierced by a few water-cut gaps, which have been used to provide road access between the mountains and the plains. The ridge is paralleled by I-25 from north of Cheyenne, Wyoming, through Colorado, into northern New Mexico. The ridge is to the west. North of Denver its major gaps are I-80 in southern Wyoming, U.S. Highway 34 at Loveland, and U.S. 36 to Rocky Mountain National Park. Interstate 70 passes through a highway cut, revealing the numerous layers making up the ridge. South of Denver, the major gaps are U.S. Route 24 in Colorado Springs, U.S. Route 50 in Pueblo, and finally in Colorado, U.S. Route 160 in Walsenburg.
Orogeny
Before the mountains, the region was a shallow sea. As sediments fell to the bottom of the water, they were compressed into soft sedimentary rock. Thus, oyster and clam shells, sand, and mud built slowly into layers of sandstone, shale, limestone, and "mudstone." As the Rocky Mountains rose over the last 67 million years, up to nearly 30,000 feet above sea level, the soft sedimentary rocks were quickly weathered and washed away from the high mountains. But on the edge of the foothills, where the layers were scraped and pushed only slightly upward, the western edge of their remnant still stands at about a 45-degree angle - the Dakota Ridge.
The top layer is a hard sandstone, the Dakota Sandstone, from which the ridge gets its name. It protects the softer shales and limestones beneath it from weathering and erosion.
References
Ridges of Colorado
Geology of the Rocky Mountains
Landforms of New Mexico
|
Kasper Larsen (born 25 January 1993) is a Danish footballer who plays as a centre-back for Hungarian club Fehérvár FC.
Career
Club
In the 2011–2012 season, Larsen started first-team training in Odense BK. He was integrated in the squad spring 2012 and gained 8 Superliga performances.
In February 2015, Larsen moved to Kazakhstan Premier League side FC Astana on a season-long loan.
In July 2015, Larsen returned to Odense from Astana in July without having played a match for Kazakhstan, and signed for Eredivisie side FC Groningen in August 2015.
On 4 August 2018, Larsen joined Swedish side IFK Norrköping on a free transfer, after his contract with FC Groningen expired earlier that summer.
International career
In 2012, Larsen was a regular in the Denmark u19 team.
Career statistics
Honours
Club
Astana
Kazakhstan Super Cup (1): 2015
References
External links
Kasper Larsen official Danish Superliga statistics at danskfodbold.com
1993 births
Living people
Men's association football defenders
Danish men's footballers
Denmark men's youth international footballers
Denmark men's under-21 international footballers
Danish expatriate men's footballers
Odense Boldklub players
FC Groningen players
IFK Norrköping players
Fehérvár FC players
Danish Superliga players
Eredivisie players
Allsvenskan players
Nemzeti Bajnokság I players
Footballers at the 2016 Summer Olympics
Olympic footballers for Denmark
Danish expatriate sportspeople in the Netherlands
Danish expatriate sportspeople in Sweden
Danish expatriate sportspeople in Hungary
Expatriate men's footballers in the Netherlands
Expatriate men's footballers in Sweden
Expatriate men's footballers in Hungary
|
Geoffrey Bwalya Mwamba (born 15 March 1959) is a Zambian businessman and politician who served as Member of Parliament for Kasama Central from 2009 to 2016. He later served as Vice President of the United Party for National Development. Under the Patriotic Front government of President Michael Sata, he served as Minister of Defence from 2011 to 2013.
Mwamba was expelled from the ruling PF in February 2014. On 23 July 2015, he endorsed the main opposition party, the United Party for National Development (UPND). On 3 June 2016, he was selected to stand as the running mate of UPND candidate Hakainde Hichilema in the August 2016 presidential election. However, he unceremoniously left the United Party for National Development and returned to the Patriotic Front party in 2019.
References
Defence Ministers of Zambia
Living people
Members of the National Assembly of Zambia
United Party for National Development politicians
Patriotic Front (Zambia) politicians
1959 births
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
/**
* Compute the mean error incrementally.
*
* @module @stdlib/stats/incr/me
*
* @example
* var incrme = require( '@stdlib/stats/incr/me' );
*
* var accumulator = incrme();
*
* var m = accumulator();
* // returns null
*
* m = accumulator( 2.0, 3.0 );
* // returns 1.0
*
* m = accumulator( -5.0, 2.0 );
* // returns 4.0
*
* m = accumulator();
* // returns 4.0
*/
// MODULES //
var main = require( './main.js' );
// EXPORTS //
module.exports = main;
```
|
Forelius mccooki is a species of ant in the genus Forelius. Described by McCook in 1880, the species is endemic to the United States and Mexico, where they nest in soil surrounded by a typically small mound, and also nests under stones.
References
External links
Dolichoderinae
Hymenoptera of North America
Insects described in 1880
|
Liberato Firmino Sifonia (Geneva, 6 February 1917 - Lanciano, 25 December 1996) was an Italian composer.
Biography
Son of an Italian double bass player, he completed his literary and musical studies in the Principality of Monaco and later attended master classes in France with Alfred Cortot, Lazare Lévy and Claude Delvincourt. He was also a pupil of Goffredo Petrassi at the Accademia Nazionale di Santa Cecilia in Rome, where he obtained his diploma in composition. His fellow students included Boris Porena, Ennio Morricone and Domenico Guaccero.
Between 1953 and 1958 he was responsible for the musical programming of RAI's third channel. He taught composition at the Perugia Conservatory from 1958 to 1965, at the Bologna Conservatory from 1965 to 1969, and then became director of the Pescara and Florence Conservatories from 1977 to 1987.
In 1962, he was appointed secretary of the Italian National Committee for Music at UNESCO.
Style
Around the 1950s, Sifonia embraced the serial technique, without, however, leaning towards the radicalism of the Nuova Musica currents and successfully achieving an effective and immediate communicativeness. His personal interpretation of serialism gave him evocative pages of artistic value, in which a particular care for instrumentation emerges (especially in solo concerts). He is the author of much symphonic, vocal and choral music and essays on musical analysis.
References
1917 births
1996 deaths
20th-century Italian composers
Accademia Nazionale di Santa Cecilia alumni
|
```ocaml
open Ctypes
module Bindings(F:Cstubs.FOREIGN) =
struct
open F
module Hacl_Streaming_Types_applied =
(Hacl_Streaming_Types_bindings.Bindings)(Hacl_Streaming_Types_stubs)
open Hacl_Streaming_Types_applied
module Hacl_Hash_Blake2b_applied =
(Hacl_Hash_Blake2b_bindings.Bindings)(Hacl_Hash_Blake2b_stubs)
open Hacl_Hash_Blake2b_applied
let hacl_Hash_Blake2s_init =
foreign "Hacl_Hash_Blake2s_init"
((ptr uint32_t) @-> (uint32_t @-> (uint32_t @-> (returning void))))
let hacl_Hash_Blake2s_update_multi =
foreign "Hacl_Hash_Blake2s_update_multi"
(uint32_t @->
((ptr uint32_t) @->
((ptr uint32_t) @->
(uint64_t @->
(ocaml_bytes @-> (uint32_t @-> (returning void)))))))
let hacl_Hash_Blake2s_update_last =
foreign "Hacl_Hash_Blake2s_update_last"
(uint32_t @->
((ptr uint32_t) @->
((ptr uint32_t) @->
(bool @->
(uint64_t @->
(uint32_t @-> (ocaml_bytes @-> (returning void))))))))
let hacl_Hash_Blake2s_finish =
foreign "Hacl_Hash_Blake2s_finish"
(uint32_t @-> (ocaml_bytes @-> ((ptr uint32_t) @-> (returning void))))
type k____uint32_t___uint32_t_ = [ `k____uint32_t___uint32_t_ ] structure
let (k____uint32_t___uint32_t_ :
[ `k____uint32_t___uint32_t_ ] structure typ) =
structure "K____uint32_t___uint32_t__s"
let k____uint32_t___uint32_t__fst =
field k____uint32_t___uint32_t_ "fst" (ptr uint32_t)
let k____uint32_t___uint32_t__snd =
field k____uint32_t___uint32_t_ "snd" (ptr uint32_t)
let _ = seal k____uint32_t___uint32_t_
type hacl_Hash_Blake2s_block_state_t =
[ `hacl_Hash_Blake2s_block_state_t ] structure
let (hacl_Hash_Blake2s_block_state_t :
[ `hacl_Hash_Blake2s_block_state_t ] structure typ) =
structure "Hacl_Hash_Blake2s_block_state_t_s"
let hacl_Hash_Blake2s_block_state_t_fst =
field hacl_Hash_Blake2s_block_state_t "fst" uint8_t
let hacl_Hash_Blake2s_block_state_t_snd =
field hacl_Hash_Blake2s_block_state_t "snd" uint8_t
let hacl_Hash_Blake2s_block_state_t_thd =
field hacl_Hash_Blake2s_block_state_t "thd" bool
let hacl_Hash_Blake2s_block_state_t_f3 =
field hacl_Hash_Blake2s_block_state_t "f3" k____uint32_t___uint32_t_
let _ = seal hacl_Hash_Blake2s_block_state_t
type hacl_Hash_Blake2s_state_t = [ `hacl_Hash_Blake2s_state_t ] structure
let (hacl_Hash_Blake2s_state_t :
[ `hacl_Hash_Blake2s_state_t ] structure typ) =
structure "Hacl_Hash_Blake2s_state_t_s"
let hacl_Hash_Blake2s_state_t_block_state =
field hacl_Hash_Blake2s_state_t "block_state"
hacl_Hash_Blake2s_block_state_t
let hacl_Hash_Blake2s_state_t_buf =
field hacl_Hash_Blake2s_state_t "buf" (ptr uint8_t)
let hacl_Hash_Blake2s_state_t_total_len =
field hacl_Hash_Blake2s_state_t "total_len" uint64_t
let _ = seal hacl_Hash_Blake2s_state_t
let hacl_Hash_Blake2s_malloc_with_params_and_key =
foreign "Hacl_Hash_Blake2s_malloc_with_params_and_key"
((ptr hacl_Hash_Blake2b_blake2_params) @->
(bool @->
(ocaml_bytes @-> (returning (ptr hacl_Hash_Blake2s_state_t)))))
let hacl_Hash_Blake2s_malloc_with_key =
foreign "Hacl_Hash_Blake2s_malloc_with_key"
(ocaml_bytes @->
(uint8_t @-> (returning (ptr hacl_Hash_Blake2s_state_t))))
let hacl_Hash_Blake2s_malloc =
foreign "Hacl_Hash_Blake2s_malloc"
(void @-> (returning (ptr hacl_Hash_Blake2s_state_t)))
let hacl_Hash_Blake2s_reset_with_key_and_params =
foreign "Hacl_Hash_Blake2s_reset_with_key_and_params"
((ptr hacl_Hash_Blake2s_state_t) @->
((ptr hacl_Hash_Blake2b_blake2_params) @->
(ocaml_bytes @-> (returning void))))
let hacl_Hash_Blake2s_reset_with_key =
foreign "Hacl_Hash_Blake2s_reset_with_key"
((ptr hacl_Hash_Blake2s_state_t) @->
(ocaml_bytes @-> (returning void)))
let hacl_Hash_Blake2s_reset =
foreign "Hacl_Hash_Blake2s_reset"
((ptr hacl_Hash_Blake2s_state_t) @-> (returning void))
let hacl_Hash_Blake2s_update =
foreign "Hacl_Hash_Blake2s_update"
((ptr hacl_Hash_Blake2s_state_t) @->
(ocaml_bytes @->
(uint32_t @-> (returning hacl_Streaming_Types_error_code))))
let hacl_Hash_Blake2s_digest =
foreign "Hacl_Hash_Blake2s_digest"
((ptr hacl_Hash_Blake2s_state_t) @->
(ocaml_bytes @-> (returning uint8_t)))
let hacl_Hash_Blake2s_info =
foreign "Hacl_Hash_Blake2s_info"
((ptr hacl_Hash_Blake2s_state_t) @->
(returning hacl_Hash_Blake2b_index))
let hacl_Hash_Blake2s_free =
foreign "Hacl_Hash_Blake2s_free"
((ptr hacl_Hash_Blake2s_state_t) @-> (returning void))
let hacl_Hash_Blake2s_copy =
foreign "Hacl_Hash_Blake2s_copy"
((ptr hacl_Hash_Blake2s_state_t) @->
(returning (ptr hacl_Hash_Blake2s_state_t)))
let hacl_Hash_Blake2s_hash_with_key =
foreign "Hacl_Hash_Blake2s_hash_with_key"
(ocaml_bytes @->
(uint32_t @->
(ocaml_bytes @->
(uint32_t @->
(ocaml_bytes @-> (uint32_t @-> (returning void)))))))
let hacl_Hash_Blake2s_hash_with_key_and_params =
foreign "Hacl_Hash_Blake2s_hash_with_key_and_params"
(ocaml_bytes @->
(ocaml_bytes @->
(uint32_t @->
(hacl_Hash_Blake2b_blake2_params @->
(ocaml_bytes @-> (returning void))))))
end
```
|
```sourcepawn
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|* *|
|* DAG Instruction Selector for the RISCV target *|
|* *|
|* Automatically generated file, do not edit! *|
|* *|
\*===your_sha256_hash------===*/
// *** NOTE: This file is #included into the middle of the target
// *** instruction selector class. These functions are really methods.
// If GET_DAGISEL_DECL is #defined with any value, only function
// declarations will be included when this file is included.
// If GET_DAGISEL_BODY is #defined, its value should be the name of
// the instruction selector class. Function bodies will be emitted
// and each function's name will be qualified with the name of the
// class.
//
// When neither of the GET_DAGISEL* macros is defined, the functions
// are emitted inline.
#if defined(GET_DAGISEL_DECL) && defined(GET_DAGISEL_BODY)
#error GET_DAGISEL_DECL and GET_DAGISEL_BODY cannot be both defined, undef both for inline definitions
#endif
#ifdef GET_DAGISEL_BODY
#define LOCAL_DAGISEL_STRINGIZE(X) LOCAL_DAGISEL_STRINGIZE_(X)
#define LOCAL_DAGISEL_STRINGIZE_(X) #X
static_assert(sizeof(LOCAL_DAGISEL_STRINGIZE(GET_DAGISEL_BODY)) > 1,
"GET_DAGISEL_BODY is empty: it should be defined with the class name");
#undef LOCAL_DAGISEL_STRINGIZE_
#undef LOCAL_DAGISEL_STRINGIZE
#endif
#if !defined(GET_DAGISEL_DECL) && !defined(GET_DAGISEL_BODY)
#define DAGISEL_INLINE 1
#else
#define DAGISEL_INLINE 0
#endif
#if !DAGISEL_INLINE
#define DAGISEL_CLASS_COLONCOLON GET_DAGISEL_BODY ::
#else
#define DAGISEL_CLASS_COLONCOLON
#endif
#ifdef GET_DAGISEL_DECL
void SelectCode(SDNode *N);
#endif
#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE
void DAGISEL_CLASS_COLONCOLON SelectCode(SDNode *N)
{
// Some target values are emitted as 2 bytes, TARGET_VAL handles
// this.
#define TARGET_VAL(X) X & 255, unsigned(X) >> 8
static const unsigned char MatcherTable[] = {
/* 0*/ OPC_SwitchOpcode /*81 cases */, 12|128,5/*652*/, TARGET_VAL(ISD::AND),// ->657
/* 5*/ OPC_Scope, 41|128,4/*553*/, /*->561*/ // 2 children in Scope
/* 8*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 14*/ OPC_Scope, 75|128,3/*459*/, /*->476*/ // 2 children in Scope
/* 17*/ OPC_MoveChild0,
/* 18*/ OPC_SwitchOpcode /*2 cases */, 96|128,1/*224*/, TARGET_VAL(RISCVISD::DIVUW),// ->247
/* 23*/ OPC_MoveChild0,
/* 24*/ OPC_Scope, 110, /*->136*/ // 2 children in Scope
/* 26*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 32*/ OPC_RecordChild0, // #0 = $rs1
/* 33*/ OPC_MoveParent,
/* 34*/ OPC_MoveChild1,
/* 35*/ OPC_Scope, 49, /*->86*/ // 2 children in Scope
/* 37*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 43*/ OPC_RecordChild0, // #1 = $rs2
/* 44*/ OPC_MoveParent,
/* 45*/ OPC_MoveParent,
/* 46*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->73
/* 49*/ OPC_Scope, 10, /*->61*/ // 2 children in Scope
/* 51*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 53*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 27
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 61*/ /*Scope*/ 10, /*->72*/
/* 62*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 64*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 27
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 72*/ 0, /*End of Scope*/
/* 73*/ /*SwitchType*/ 10, MVT::i64,// ->85
/* 75*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 77*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_divuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })), 4294967295:{ *:[i64] }) - Complexity = 27
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 85*/ 0, // EndSwitchType
/* 86*/ /*Scope*/ 48, /*->135*/
/* 87*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 90*/ OPC_RecordChild0, // #1 = $rs2
/* 91*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 93*/ OPC_MoveParent,
/* 94*/ OPC_MoveParent,
/* 95*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->122
/* 98*/ OPC_Scope, 10, /*->110*/ // 2 children in Scope
/* 100*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 102*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 110*/ /*Scope*/ 10, /*->121*/
/* 111*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 113*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 121*/ 0, /*End of Scope*/
/* 122*/ /*SwitchType*/ 10, MVT::i64,// ->134
/* 124*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 126*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_divuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i64] }) - Complexity = 23
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 134*/ 0, // EndSwitchType
/* 135*/ 0, /*End of Scope*/
/* 136*/ /*Scope*/ 109, /*->246*/
/* 137*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 140*/ OPC_RecordChild0, // #0 = $rs1
/* 141*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 143*/ OPC_MoveParent,
/* 144*/ OPC_MoveChild1,
/* 145*/ OPC_Scope, 49, /*->196*/ // 2 children in Scope
/* 147*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 153*/ OPC_RecordChild0, // #1 = $rs2
/* 154*/ OPC_MoveParent,
/* 155*/ OPC_MoveParent,
/* 156*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->183
/* 159*/ OPC_Scope, 10, /*->171*/ // 2 children in Scope
/* 161*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 163*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 171*/ /*Scope*/ 10, /*->182*/
/* 172*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 174*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 182*/ 0, /*End of Scope*/
/* 183*/ /*SwitchType*/ 10, MVT::i64,// ->195
/* 185*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 187*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_divuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })), 4294967295:{ *:[i64] }) - Complexity = 23
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 195*/ 0, // EndSwitchType
/* 196*/ /*Scope*/ 48, /*->245*/
/* 197*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 200*/ OPC_RecordChild0, // #1 = $rs2
/* 201*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 203*/ OPC_MoveParent,
/* 204*/ OPC_MoveParent,
/* 205*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->232
/* 208*/ OPC_Scope, 10, /*->220*/ // 2 children in Scope
/* 210*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 212*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 220*/ /*Scope*/ 10, /*->231*/
/* 221*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 223*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 231*/ 0, /*End of Scope*/
/* 232*/ /*SwitchType*/ 10, MVT::i64,// ->244
/* 234*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 236*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_divuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i64] }) - Complexity = 19
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 244*/ 0, // EndSwitchType
/* 245*/ 0, /*End of Scope*/
/* 246*/ 0, /*End of Scope*/
/* 247*/ /*SwitchOpcode*/ 96|128,1/*224*/, TARGET_VAL(RISCVISD::REMUW),// ->475
/* 251*/ OPC_MoveChild0,
/* 252*/ OPC_Scope, 110, /*->364*/ // 2 children in Scope
/* 254*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 260*/ OPC_RecordChild0, // #0 = $rs1
/* 261*/ OPC_MoveParent,
/* 262*/ OPC_MoveChild1,
/* 263*/ OPC_Scope, 49, /*->314*/ // 2 children in Scope
/* 265*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 271*/ OPC_RecordChild0, // #1 = $rs2
/* 272*/ OPC_MoveParent,
/* 273*/ OPC_MoveParent,
/* 274*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->301
/* 277*/ OPC_Scope, 10, /*->289*/ // 2 children in Scope
/* 279*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 281*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 27
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 289*/ /*Scope*/ 10, /*->300*/
/* 290*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 292*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 27
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 300*/ 0, /*End of Scope*/
/* 301*/ /*SwitchType*/ 10, MVT::i64,// ->313
/* 303*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 305*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_remuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })), 4294967295:{ *:[i64] }) - Complexity = 27
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 313*/ 0, // EndSwitchType
/* 314*/ /*Scope*/ 48, /*->363*/
/* 315*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 318*/ OPC_RecordChild0, // #1 = $rs2
/* 319*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 321*/ OPC_MoveParent,
/* 322*/ OPC_MoveParent,
/* 323*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->350
/* 326*/ OPC_Scope, 10, /*->338*/ // 2 children in Scope
/* 328*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 330*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 338*/ /*Scope*/ 10, /*->349*/
/* 339*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 341*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 349*/ 0, /*End of Scope*/
/* 350*/ /*SwitchType*/ 10, MVT::i64,// ->362
/* 352*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 354*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_remuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i64] }) - Complexity = 23
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 362*/ 0, // EndSwitchType
/* 363*/ 0, /*End of Scope*/
/* 364*/ /*Scope*/ 109, /*->474*/
/* 365*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 368*/ OPC_RecordChild0, // #0 = $rs1
/* 369*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 371*/ OPC_MoveParent,
/* 372*/ OPC_MoveChild1,
/* 373*/ OPC_Scope, 49, /*->424*/ // 2 children in Scope
/* 375*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 381*/ OPC_RecordChild0, // #1 = $rs2
/* 382*/ OPC_MoveParent,
/* 383*/ OPC_MoveParent,
/* 384*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->411
/* 387*/ OPC_Scope, 10, /*->399*/ // 2 children in Scope
/* 389*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 391*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 399*/ /*Scope*/ 10, /*->410*/
/* 400*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 402*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })), 4294967295:{ *:[i32] }) - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 410*/ 0, /*End of Scope*/
/* 411*/ /*SwitchType*/ 10, MVT::i64,// ->423
/* 413*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 415*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_remuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })), 4294967295:{ *:[i64] }) - Complexity = 23
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 423*/ 0, // EndSwitchType
/* 424*/ /*Scope*/ 48, /*->473*/
/* 425*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 428*/ OPC_RecordChild0, // #1 = $rs2
/* 429*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 431*/ OPC_MoveParent,
/* 432*/ OPC_MoveParent,
/* 433*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->460
/* 436*/ OPC_Scope, 10, /*->448*/ // 2 children in Scope
/* 438*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 440*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 448*/ /*Scope*/ 10, /*->459*/
/* 449*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 451*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i32] }) - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 459*/ 0, /*End of Scope*/
/* 460*/ /*SwitchType*/ 10, MVT::i64,// ->472
/* 462*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 464*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } (riscv_remuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>), 4294967295:{ *:[i64] }) - Complexity = 19
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 472*/ 0, // EndSwitchType
/* 473*/ 0, /*End of Scope*/
/* 474*/ 0, /*End of Scope*/
/* 475*/ 0, // EndSwitchOpcode
/* 476*/ /*Scope*/ 83, /*->560*/
/* 477*/ OPC_RecordChild0, // #0 = $rs1
/* 478*/ OPC_SwitchType /*2 cases */, 52, MVT::i32,// ->533
/* 481*/ OPC_Scope, 24, /*->507*/ // 2 children in Scope
/* 483*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 485*/ OPC_EmitInteger, MVT::i32, 32,
/* 488*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 496*/ OPC_EmitInteger, MVT::i32, 32,
/* 499*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }) - Complexity = 8
// Dst: (SRLI:{ *:[i32] } (SLLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 32:{ *:[i32] }), 32:{ *:[i32] })
/* 507*/ /*Scope*/ 24, /*->532*/
/* 508*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 510*/ OPC_EmitInteger, MVT::i32, 32,
/* 513*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 521*/ OPC_EmitInteger, MVT::i32, 32,
/* 524*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }) - Complexity = 8
// Dst: (SRLI:{ *:[i32] } (SLLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 32:{ *:[i32] }), 32:{ *:[i32] })
/* 532*/ 0, /*End of Scope*/
/* 533*/ /*SwitchType*/ 24, MVT::i64,// ->559
/* 535*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 537*/ OPC_EmitInteger, MVT::i64, 32,
/* 540*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i64, 2/*#Ops*/, 0, 1, // Results = #2
/* 548*/ OPC_EmitInteger, MVT::i64, 32,
/* 551*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }) - Complexity = 8
// Dst: (SRLI:{ *:[i64] } (SLLI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 32:{ *:[i64] }), 32:{ *:[i64] })
/* 559*/ 0, // EndSwitchType
/* 560*/ 0, /*End of Scope*/
/* 561*/ /*Scope*/ 94, /*->656*/
/* 562*/ OPC_RecordChild0, // #0 = $rs1
/* 563*/ OPC_RecordChild1, // #1 = $imm12
/* 564*/ OPC_Scope, 51, /*->617*/ // 3 children in Scope
/* 566*/ OPC_MoveChild1,
/* 567*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 570*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 572*/ OPC_MoveParent,
/* 573*/ OPC_SwitchType /*2 cases */, 26, MVT::i32,// ->602
/* 576*/ OPC_Scope, 12, /*->590*/ // 2 children in Scope
/* 578*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 580*/ OPC_EmitConvertToTarget, 1,
/* 582*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ANDI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ANDI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 590*/ /*Scope*/ 10, /*->601*/
/* 591*/ OPC_EmitConvertToTarget, 1,
/* 593*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ANDI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ANDI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 601*/ 0, /*End of Scope*/
/* 602*/ /*SwitchType*/ 12, MVT::i64,// ->616
/* 604*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 606*/ OPC_EmitConvertToTarget, 1,
/* 608*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ANDI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ANDI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 616*/ 0, // EndSwitchType
/* 617*/ /*Scope*/ 24, /*->642*/
/* 618*/ OPC_CheckType, MVT::i32,
/* 620*/ OPC_Scope, 10, /*->632*/ // 2 children in Scope
/* 622*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 624*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (AND:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 632*/ /*Scope*/ 8, /*->641*/
/* 633*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (AND:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 641*/ 0, /*End of Scope*/
/* 642*/ /*Scope*/ 12, /*->655*/
/* 643*/ OPC_CheckType, MVT::i64,
/* 645*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 647*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (AND:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 655*/ 0, /*End of Scope*/
/* 656*/ 0, /*End of Scope*/
/* 657*/ /*SwitchOpcode*/ 91|128,3/*475*/, TARGET_VAL(ISD::AssertZext),// ->1136
/* 661*/ OPC_MoveChild0,
/* 662*/ OPC_SwitchOpcode /*2 cases */, 104|128,1/*232*/, TARGET_VAL(RISCVISD::DIVUW),// ->899
/* 667*/ OPC_MoveChild0,
/* 668*/ OPC_Scope, 114, /*->784*/ // 2 children in Scope
/* 670*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 676*/ OPC_RecordChild0, // #0 = $rs1
/* 677*/ OPC_MoveParent,
/* 678*/ OPC_MoveChild1,
/* 679*/ OPC_Scope, 51, /*->732*/ // 2 children in Scope
/* 681*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 687*/ OPC_RecordChild0, // #1 = $rs2
/* 688*/ OPC_MoveParent,
/* 689*/ OPC_MoveParent,
/* 690*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 692*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->719
/* 695*/ OPC_Scope, 10, /*->707*/ // 2 children in Scope
/* 697*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 699*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 707*/ /*Scope*/ 10, /*->718*/
/* 708*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 710*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 718*/ 0, /*End of Scope*/
/* 719*/ /*SwitchType*/ 10, MVT::i64,// ->731
/* 721*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 723*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_divuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 731*/ 0, // EndSwitchType
/* 732*/ /*Scope*/ 50, /*->783*/
/* 733*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 736*/ OPC_RecordChild0, // #1 = $rs2
/* 737*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 739*/ OPC_MoveParent,
/* 740*/ OPC_MoveParent,
/* 741*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 743*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->770
/* 746*/ OPC_Scope, 10, /*->758*/ // 2 children in Scope
/* 748*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 750*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 758*/ /*Scope*/ 10, /*->769*/
/* 759*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 761*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 769*/ 0, /*End of Scope*/
/* 770*/ /*SwitchType*/ 10, MVT::i64,// ->782
/* 772*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 774*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_divuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 782*/ 0, // EndSwitchType
/* 783*/ 0, /*End of Scope*/
/* 784*/ /*Scope*/ 113, /*->898*/
/* 785*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 788*/ OPC_RecordChild0, // #0 = $rs1
/* 789*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 791*/ OPC_MoveParent,
/* 792*/ OPC_MoveChild1,
/* 793*/ OPC_Scope, 51, /*->846*/ // 2 children in Scope
/* 795*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 801*/ OPC_RecordChild0, // #1 = $rs2
/* 802*/ OPC_MoveParent,
/* 803*/ OPC_MoveParent,
/* 804*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 806*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->833
/* 809*/ OPC_Scope, 10, /*->821*/ // 2 children in Scope
/* 811*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 813*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 821*/ /*Scope*/ 10, /*->832*/
/* 822*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 824*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 832*/ 0, /*End of Scope*/
/* 833*/ /*SwitchType*/ 10, MVT::i64,// ->845
/* 835*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 837*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_divuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 845*/ 0, // EndSwitchType
/* 846*/ /*Scope*/ 50, /*->897*/
/* 847*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 850*/ OPC_RecordChild0, // #1 = $rs2
/* 851*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 853*/ OPC_MoveParent,
/* 854*/ OPC_MoveParent,
/* 855*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 857*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->884
/* 860*/ OPC_Scope, 10, /*->872*/ // 2 children in Scope
/* 862*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 864*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 872*/ /*Scope*/ 10, /*->883*/
/* 873*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 875*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_divuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 883*/ 0, /*End of Scope*/
/* 884*/ /*SwitchType*/ 10, MVT::i64,// ->896
/* 886*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 888*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_divuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 896*/ 0, // EndSwitchType
/* 897*/ 0, /*End of Scope*/
/* 898*/ 0, /*End of Scope*/
/* 899*/ /*SwitchOpcode*/ 104|128,1/*232*/, TARGET_VAL(RISCVISD::REMUW),// ->1135
/* 903*/ OPC_MoveChild0,
/* 904*/ OPC_Scope, 114, /*->1020*/ // 2 children in Scope
/* 906*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 912*/ OPC_RecordChild0, // #0 = $rs1
/* 913*/ OPC_MoveParent,
/* 914*/ OPC_MoveChild1,
/* 915*/ OPC_Scope, 51, /*->968*/ // 2 children in Scope
/* 917*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 923*/ OPC_RecordChild0, // #1 = $rs2
/* 924*/ OPC_MoveParent,
/* 925*/ OPC_MoveParent,
/* 926*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 928*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->955
/* 931*/ OPC_Scope, 10, /*->943*/ // 2 children in Scope
/* 933*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 935*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 943*/ /*Scope*/ 10, /*->954*/
/* 944*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 946*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 954*/ 0, /*End of Scope*/
/* 955*/ /*SwitchType*/ 10, MVT::i64,// ->967
/* 957*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 959*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_remuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })))<<P:Predicate_assertzexti32>> - Complexity = 23
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 967*/ 0, // EndSwitchType
/* 968*/ /*Scope*/ 50, /*->1019*/
/* 969*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 972*/ OPC_RecordChild0, // #1 = $rs2
/* 973*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 975*/ OPC_MoveParent,
/* 976*/ OPC_MoveParent,
/* 977*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 979*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->1006
/* 982*/ OPC_Scope, 10, /*->994*/ // 2 children in Scope
/* 984*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 986*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 994*/ /*Scope*/ 10, /*->1005*/
/* 995*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 997*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] }), (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 1005*/ 0, /*End of Scope*/
/* 1006*/ /*SwitchType*/ 10, MVT::i64,// ->1018
/* 1008*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1010*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_remuw:{ *:[i64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] }), (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 1018*/ 0, // EndSwitchType
/* 1019*/ 0, /*End of Scope*/
/* 1020*/ /*Scope*/ 113, /*->1134*/
/* 1021*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 1024*/ OPC_RecordChild0, // #0 = $rs1
/* 1025*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 1027*/ OPC_MoveParent,
/* 1028*/ OPC_MoveChild1,
/* 1029*/ OPC_Scope, 51, /*->1082*/ // 2 children in Scope
/* 1031*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 1037*/ OPC_RecordChild0, // #1 = $rs2
/* 1038*/ OPC_MoveParent,
/* 1039*/ OPC_MoveParent,
/* 1040*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 1042*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->1069
/* 1045*/ OPC_Scope, 10, /*->1057*/ // 2 children in Scope
/* 1047*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1049*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 1057*/ /*Scope*/ 10, /*->1068*/
/* 1058*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 1060*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, 4294967295:{ *:[i32] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 1068*/ 0, /*End of Scope*/
/* 1069*/ /*SwitchType*/ 10, MVT::i64,// ->1081
/* 1071*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1073*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_remuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, 4294967295:{ *:[i64] })))<<P:Predicate_assertzexti32>> - Complexity = 19
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 1081*/ 0, // EndSwitchType
/* 1082*/ /*Scope*/ 50, /*->1133*/
/* 1083*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 1086*/ OPC_RecordChild0, // #1 = $rs2
/* 1087*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 1089*/ OPC_MoveParent,
/* 1090*/ OPC_MoveParent,
/* 1091*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 1093*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->1120
/* 1096*/ OPC_Scope, 10, /*->1108*/ // 2 children in Scope
/* 1098*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1100*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 1108*/ /*Scope*/ 10, /*->1119*/
/* 1109*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 1111*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i32] } (riscv_remuw:{ *:[i32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 1119*/ 0, /*End of Scope*/
/* 1120*/ /*SwitchType*/ 10, MVT::i64,// ->1132
/* 1122*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1124*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (assertzext:{ *:[i64] } (riscv_remuw:{ *:[i64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>, (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertzexti32>>))<<P:Predicate_assertzexti32>> - Complexity = 15
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 1132*/ 0, // EndSwitchType
/* 1133*/ 0, /*End of Scope*/
/* 1134*/ 0, /*End of Scope*/
/* 1135*/ 0, // EndSwitchOpcode
/* 1136*/ /*SwitchOpcode*/ 80|128,30/*3920*/, TARGET_VAL(ISD::LOAD),// ->5060
/* 1140*/ OPC_RecordMemRef,
/* 1141*/ OPC_RecordNode, // #0 = 'ld' chained node
/* 1142*/ OPC_Scope, 48|128,15/*1968*/, /*->3113*/ // 4 children in Scope
/* 1145*/ OPC_MoveChild1,
/* 1146*/ OPC_SwitchOpcode /*2 cases */, 57|128,5/*697*/, TARGET_VAL(ISD::OR),// ->1848
/* 1151*/ OPC_RecordChild0, // #1 = $rs1
/* 1152*/ OPC_RecordChild1, // #2 = $imm12
/* 1153*/ OPC_MoveChild1,
/* 1154*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 1157*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 1159*/ OPC_MoveParent,
/* 1160*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 1162*/ OPC_SwitchType /*2 cases */, 59|128,3/*443*/, MVT::i32,// ->1609
/* 1166*/ OPC_MoveParent,
/* 1167*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 1169*/ OPC_CheckType, MVT::i32,
/* 1171*/ OPC_Scope, 38, /*->1211*/ // 10 children in Scope
/* 1173*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1175*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 1177*/ OPC_Scope, 16, /*->1195*/ // 2 children in Scope
/* 1179*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1181*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1184*/ OPC_EmitMergeInputChains1_0,
/* 1185*/ OPC_EmitConvertToTarget, 2,
/* 1187*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1195*/ /*Scope*/ 14, /*->1210*/
/* 1196*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1199*/ OPC_EmitMergeInputChains1_0,
/* 1200*/ OPC_EmitConvertToTarget, 2,
/* 1202*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1210*/ 0, /*End of Scope*/
/* 1211*/ /*Scope*/ 38, /*->1250*/
/* 1212*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1214*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 1216*/ OPC_Scope, 16, /*->1234*/ // 2 children in Scope
/* 1218*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1220*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1223*/ OPC_EmitMergeInputChains1_0,
/* 1224*/ OPC_EmitConvertToTarget, 2,
/* 1226*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1234*/ /*Scope*/ 14, /*->1249*/
/* 1235*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1238*/ OPC_EmitMergeInputChains1_0,
/* 1239*/ OPC_EmitConvertToTarget, 2,
/* 1241*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1249*/ 0, /*End of Scope*/
/* 1250*/ /*Scope*/ 38, /*->1289*/
/* 1251*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1253*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 1255*/ OPC_Scope, 16, /*->1273*/ // 2 children in Scope
/* 1257*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1259*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1262*/ OPC_EmitMergeInputChains1_0,
/* 1263*/ OPC_EmitConvertToTarget, 2,
/* 1265*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1273*/ /*Scope*/ 14, /*->1288*/
/* 1274*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1277*/ OPC_EmitMergeInputChains1_0,
/* 1278*/ OPC_EmitConvertToTarget, 2,
/* 1280*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1288*/ 0, /*End of Scope*/
/* 1289*/ /*Scope*/ 38, /*->1328*/
/* 1290*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1292*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 1294*/ OPC_Scope, 16, /*->1312*/ // 2 children in Scope
/* 1296*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1298*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1301*/ OPC_EmitMergeInputChains1_0,
/* 1302*/ OPC_EmitConvertToTarget, 2,
/* 1304*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1312*/ /*Scope*/ 14, /*->1327*/
/* 1313*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1316*/ OPC_EmitMergeInputChains1_0,
/* 1317*/ OPC_EmitConvertToTarget, 2,
/* 1319*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1327*/ 0, /*End of Scope*/
/* 1328*/ /*Scope*/ 38, /*->1367*/
/* 1329*/ OPC_CheckPredicate, 8, // Predicate_load
/* 1331*/ OPC_Scope, 16, /*->1349*/ // 2 children in Scope
/* 1333*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1335*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1338*/ OPC_EmitMergeInputChains1_0,
/* 1339*/ OPC_EmitConvertToTarget, 2,
/* 1341*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1349*/ /*Scope*/ 16, /*->1366*/
/* 1350*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 1352*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1355*/ OPC_EmitMergeInputChains1_0,
/* 1356*/ OPC_EmitConvertToTarget, 2,
/* 1358*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1366*/ 0, /*End of Scope*/
/* 1367*/ /*Scope*/ 78, /*->1446*/
/* 1368*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 1370*/ OPC_Scope, 36, /*->1408*/ // 2 children in Scope
/* 1372*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 1374*/ OPC_Scope, 16, /*->1392*/ // 2 children in Scope
/* 1376*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1378*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1381*/ OPC_EmitMergeInputChains1_0,
/* 1382*/ OPC_EmitConvertToTarget, 2,
/* 1384*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 18
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1392*/ /*Scope*/ 14, /*->1407*/
/* 1393*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1396*/ OPC_EmitMergeInputChains1_0,
/* 1397*/ OPC_EmitConvertToTarget, 2,
/* 1399*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 18
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1407*/ 0, /*End of Scope*/
/* 1408*/ /*Scope*/ 36, /*->1445*/
/* 1409*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 1411*/ OPC_Scope, 16, /*->1429*/ // 2 children in Scope
/* 1413*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1415*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1418*/ OPC_EmitMergeInputChains1_0,
/* 1419*/ OPC_EmitConvertToTarget, 2,
/* 1421*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 18
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1429*/ /*Scope*/ 14, /*->1444*/
/* 1430*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1433*/ OPC_EmitMergeInputChains1_0,
/* 1434*/ OPC_EmitConvertToTarget, 2,
/* 1436*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 18
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1444*/ 0, /*End of Scope*/
/* 1445*/ 0, /*End of Scope*/
/* 1446*/ /*Scope*/ 40, /*->1487*/
/* 1447*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1449*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 1451*/ OPC_Scope, 16, /*->1469*/ // 2 children in Scope
/* 1453*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1455*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1458*/ OPC_EmitMergeInputChains1_0,
/* 1459*/ OPC_EmitConvertToTarget, 2,
/* 1461*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1469*/ /*Scope*/ 16, /*->1486*/
/* 1470*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 1472*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1475*/ OPC_EmitMergeInputChains1_0,
/* 1476*/ OPC_EmitConvertToTarget, 2,
/* 1478*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1486*/ 0, /*End of Scope*/
/* 1487*/ /*Scope*/ 40, /*->1528*/
/* 1488*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1490*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 1492*/ OPC_Scope, 16, /*->1510*/ // 2 children in Scope
/* 1494*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1496*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1499*/ OPC_EmitMergeInputChains1_0,
/* 1500*/ OPC_EmitConvertToTarget, 2,
/* 1502*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1510*/ /*Scope*/ 16, /*->1527*/
/* 1511*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 1513*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1516*/ OPC_EmitMergeInputChains1_0,
/* 1517*/ OPC_EmitConvertToTarget, 2,
/* 1519*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1527*/ 0, /*End of Scope*/
/* 1528*/ /*Scope*/ 40, /*->1569*/
/* 1529*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 1531*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 1533*/ OPC_Scope, 16, /*->1551*/ // 2 children in Scope
/* 1535*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1537*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1540*/ OPC_EmitMergeInputChains1_0,
/* 1541*/ OPC_EmitConvertToTarget, 2,
/* 1543*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 18
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1551*/ /*Scope*/ 16, /*->1568*/
/* 1552*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 1554*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1557*/ OPC_EmitMergeInputChains1_0,
/* 1558*/ OPC_EmitConvertToTarget, 2,
/* 1560*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 18
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1568*/ 0, /*End of Scope*/
/* 1569*/ /*Scope*/ 38, /*->1608*/
/* 1570*/ OPC_CheckPredicate, 8, // Predicate_load
/* 1572*/ OPC_Scope, 16, /*->1590*/ // 2 children in Scope
/* 1574*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 1576*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1579*/ OPC_EmitMergeInputChains1_0,
/* 1580*/ OPC_EmitConvertToTarget, 2,
/* 1582*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1590*/ /*Scope*/ 16, /*->1607*/
/* 1591*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 1593*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1596*/ OPC_EmitMergeInputChains1_0,
/* 1597*/ OPC_EmitConvertToTarget, 2,
/* 1599*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1607*/ 0, /*End of Scope*/
/* 1608*/ 0, /*End of Scope*/
/* 1609*/ /*SwitchType*/ 107|128,1/*235*/, MVT::i64,// ->1847
/* 1612*/ OPC_MoveParent,
/* 1613*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 1615*/ OPC_CheckType, MVT::i64,
/* 1617*/ OPC_Scope, 20, /*->1639*/ // 10 children in Scope
/* 1619*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1621*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 1623*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1625*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1628*/ OPC_EmitMergeInputChains1_0,
/* 1629*/ OPC_EmitConvertToTarget, 2,
/* 1631*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1639*/ /*Scope*/ 20, /*->1660*/
/* 1640*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1642*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 1644*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1646*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1649*/ OPC_EmitMergeInputChains1_0,
/* 1650*/ OPC_EmitConvertToTarget, 2,
/* 1652*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 18
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1660*/ /*Scope*/ 20, /*->1681*/
/* 1661*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1663*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 1665*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1667*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1670*/ OPC_EmitMergeInputChains1_0,
/* 1671*/ OPC_EmitConvertToTarget, 2,
/* 1673*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1681*/ /*Scope*/ 20, /*->1702*/
/* 1682*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1684*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 1686*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1688*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1691*/ OPC_EmitMergeInputChains1_0,
/* 1692*/ OPC_EmitConvertToTarget, 2,
/* 1694*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 18
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1702*/ /*Scope*/ 18, /*->1721*/
/* 1703*/ OPC_CheckPredicate, 8, // Predicate_load
/* 1705*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1707*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1710*/ OPC_EmitMergeInputChains1_0,
/* 1711*/ OPC_EmitConvertToTarget, 2,
/* 1713*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1721*/ /*Scope*/ 42, /*->1764*/
/* 1722*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 1724*/ OPC_Scope, 18, /*->1744*/ // 2 children in Scope
/* 1726*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 1728*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1730*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1733*/ OPC_EmitMergeInputChains1_0,
/* 1734*/ OPC_EmitConvertToTarget, 2,
/* 1736*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 18
// Dst: (LBU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1744*/ /*Scope*/ 18, /*->1763*/
/* 1745*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 1747*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 1749*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1752*/ OPC_EmitMergeInputChains1_0,
/* 1753*/ OPC_EmitConvertToTarget, 2,
/* 1755*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 18
// Dst: (LHU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1763*/ 0, /*End of Scope*/
/* 1764*/ /*Scope*/ 20, /*->1785*/
/* 1765*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1767*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 1769*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1771*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1774*/ OPC_EmitMergeInputChains1_0,
/* 1775*/ OPC_EmitConvertToTarget, 2,
/* 1777*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1785*/ /*Scope*/ 20, /*->1806*/
/* 1786*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1788*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 1790*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1792*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1795*/ OPC_EmitMergeInputChains1_0,
/* 1796*/ OPC_EmitConvertToTarget, 2,
/* 1798*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 18
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1806*/ /*Scope*/ 20, /*->1827*/
/* 1807*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 1809*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 1811*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1813*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1816*/ OPC_EmitMergeInputChains1_0,
/* 1817*/ OPC_EmitConvertToTarget, 2,
/* 1819*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 18
// Dst: (LWU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1827*/ /*Scope*/ 18, /*->1846*/
/* 1828*/ OPC_CheckPredicate, 8, // Predicate_load
/* 1830*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 1832*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1835*/ OPC_EmitMergeInputChains1_0,
/* 1836*/ OPC_EmitConvertToTarget, 2,
/* 1838*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 1846*/ 0, /*End of Scope*/
/* 1847*/ 0, // EndSwitchType
/* 1848*/ /*SwitchOpcode*/ 108|128,9/*1260*/, TARGET_VAL(ISD::ADD),// ->3112
/* 1852*/ OPC_RecordChild0, // #1 = $rs1
/* 1853*/ OPC_RecordChild1, // #2 = $imm12
/* 1854*/ OPC_MoveChild1,
/* 1855*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 1858*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 1860*/ OPC_MoveParent,
/* 1861*/ OPC_SwitchType /*2 cases */, 45|128,6/*813*/, MVT::i32,// ->2678
/* 1865*/ OPC_MoveParent,
/* 1866*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 1868*/ OPC_CheckType, MVT::i32,
/* 1870*/ OPC_Scope, 38, /*->1910*/ // 20 children in Scope
/* 1872*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1874*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 1876*/ OPC_Scope, 16, /*->1894*/ // 2 children in Scope
/* 1878*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1880*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1883*/ OPC_EmitMergeInputChains1_0,
/* 1884*/ OPC_EmitConvertToTarget, 2,
/* 1886*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1894*/ /*Scope*/ 14, /*->1909*/
/* 1895*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1898*/ OPC_EmitMergeInputChains1_0,
/* 1899*/ OPC_EmitConvertToTarget, 2,
/* 1901*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1909*/ 0, /*End of Scope*/
/* 1910*/ /*Scope*/ 38, /*->1949*/
/* 1911*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1913*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 1915*/ OPC_Scope, 16, /*->1933*/ // 2 children in Scope
/* 1917*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1919*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1922*/ OPC_EmitMergeInputChains1_0,
/* 1923*/ OPC_EmitConvertToTarget, 2,
/* 1925*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1933*/ /*Scope*/ 14, /*->1948*/
/* 1934*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1937*/ OPC_EmitMergeInputChains1_0,
/* 1938*/ OPC_EmitConvertToTarget, 2,
/* 1940*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1948*/ 0, /*End of Scope*/
/* 1949*/ /*Scope*/ 38, /*->1988*/
/* 1950*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 1952*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 1954*/ OPC_Scope, 16, /*->1972*/ // 2 children in Scope
/* 1956*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1958*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1961*/ OPC_EmitMergeInputChains1_0,
/* 1962*/ OPC_EmitConvertToTarget, 2,
/* 1964*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1972*/ /*Scope*/ 14, /*->1987*/
/* 1973*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 1976*/ OPC_EmitMergeInputChains1_0,
/* 1977*/ OPC_EmitConvertToTarget, 2,
/* 1979*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 1987*/ 0, /*End of Scope*/
/* 1988*/ /*Scope*/ 38, /*->2027*/
/* 1989*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 1991*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 1993*/ OPC_Scope, 16, /*->2011*/ // 2 children in Scope
/* 1995*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 1997*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2000*/ OPC_EmitMergeInputChains1_0,
/* 2001*/ OPC_EmitConvertToTarget, 2,
/* 2003*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2011*/ /*Scope*/ 14, /*->2026*/
/* 2012*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2015*/ OPC_EmitMergeInputChains1_0,
/* 2016*/ OPC_EmitConvertToTarget, 2,
/* 2018*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2026*/ 0, /*End of Scope*/
/* 2027*/ /*Scope*/ 38, /*->2066*/
/* 2028*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2030*/ OPC_Scope, 16, /*->2048*/ // 2 children in Scope
/* 2032*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2034*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2037*/ OPC_EmitMergeInputChains1_0,
/* 2038*/ OPC_EmitConvertToTarget, 2,
/* 2040*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2048*/ /*Scope*/ 16, /*->2065*/
/* 2049*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 2051*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2054*/ OPC_EmitMergeInputChains1_0,
/* 2055*/ OPC_EmitConvertToTarget, 2,
/* 2057*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2065*/ 0, /*End of Scope*/
/* 2066*/ /*Scope*/ 78, /*->2145*/
/* 2067*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2069*/ OPC_Scope, 36, /*->2107*/ // 2 children in Scope
/* 2071*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 2073*/ OPC_Scope, 16, /*->2091*/ // 2 children in Scope
/* 2075*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2077*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2080*/ OPC_EmitMergeInputChains1_0,
/* 2081*/ OPC_EmitConvertToTarget, 2,
/* 2083*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 17
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2091*/ /*Scope*/ 14, /*->2106*/
/* 2092*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2095*/ OPC_EmitMergeInputChains1_0,
/* 2096*/ OPC_EmitConvertToTarget, 2,
/* 2098*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 17
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2106*/ 0, /*End of Scope*/
/* 2107*/ /*Scope*/ 36, /*->2144*/
/* 2108*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 2110*/ OPC_Scope, 16, /*->2128*/ // 2 children in Scope
/* 2112*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2114*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2117*/ OPC_EmitMergeInputChains1_0,
/* 2118*/ OPC_EmitConvertToTarget, 2,
/* 2120*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 17
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2128*/ /*Scope*/ 14, /*->2143*/
/* 2129*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2132*/ OPC_EmitMergeInputChains1_0,
/* 2133*/ OPC_EmitConvertToTarget, 2,
/* 2135*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 17
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2143*/ 0, /*End of Scope*/
/* 2144*/ 0, /*End of Scope*/
/* 2145*/ /*Scope*/ 40, /*->2186*/
/* 2146*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2148*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 2150*/ OPC_Scope, 16, /*->2168*/ // 2 children in Scope
/* 2152*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2154*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2157*/ OPC_EmitMergeInputChains1_0,
/* 2158*/ OPC_EmitConvertToTarget, 2,
/* 2160*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2168*/ /*Scope*/ 16, /*->2185*/
/* 2169*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2171*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2174*/ OPC_EmitMergeInputChains1_0,
/* 2175*/ OPC_EmitConvertToTarget, 2,
/* 2177*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2185*/ 0, /*End of Scope*/
/* 2186*/ /*Scope*/ 40, /*->2227*/
/* 2187*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2189*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 2191*/ OPC_Scope, 16, /*->2209*/ // 2 children in Scope
/* 2193*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2195*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2198*/ OPC_EmitMergeInputChains1_0,
/* 2199*/ OPC_EmitConvertToTarget, 2,
/* 2201*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2209*/ /*Scope*/ 16, /*->2226*/
/* 2210*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2212*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2215*/ OPC_EmitMergeInputChains1_0,
/* 2216*/ OPC_EmitConvertToTarget, 2,
/* 2218*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2226*/ 0, /*End of Scope*/
/* 2227*/ /*Scope*/ 40, /*->2268*/
/* 2228*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2230*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 2232*/ OPC_Scope, 16, /*->2250*/ // 2 children in Scope
/* 2234*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2236*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2239*/ OPC_EmitMergeInputChains1_0,
/* 2240*/ OPC_EmitConvertToTarget, 2,
/* 2242*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 17
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2250*/ /*Scope*/ 16, /*->2267*/
/* 2251*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2253*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2256*/ OPC_EmitMergeInputChains1_0,
/* 2257*/ OPC_EmitConvertToTarget, 2,
/* 2259*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 17
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2267*/ 0, /*End of Scope*/
/* 2268*/ /*Scope*/ 38, /*->2307*/
/* 2269*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2271*/ OPC_Scope, 16, /*->2289*/ // 2 children in Scope
/* 2273*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2275*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2278*/ OPC_EmitMergeInputChains1_0,
/* 2279*/ OPC_EmitConvertToTarget, 2,
/* 2281*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2289*/ /*Scope*/ 16, /*->2306*/
/* 2290*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2292*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2295*/ OPC_EmitMergeInputChains1_0,
/* 2296*/ OPC_EmitConvertToTarget, 2,
/* 2298*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2306*/ 0, /*End of Scope*/
/* 2307*/ /*Scope*/ 32, /*->2340*/
/* 2308*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2310*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 2312*/ OPC_Scope, 13, /*->2327*/ // 2 children in Scope
/* 2314*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2316*/ OPC_EmitMergeInputChains1_0,
/* 2317*/ OPC_EmitConvertToTarget, 2,
/* 2319*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2327*/ /*Scope*/ 11, /*->2339*/
/* 2328*/ OPC_EmitMergeInputChains1_0,
/* 2329*/ OPC_EmitConvertToTarget, 2,
/* 2331*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2339*/ 0, /*End of Scope*/
/* 2340*/ /*Scope*/ 32, /*->2373*/
/* 2341*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2343*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 2345*/ OPC_Scope, 13, /*->2360*/ // 2 children in Scope
/* 2347*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2349*/ OPC_EmitMergeInputChains1_0,
/* 2350*/ OPC_EmitConvertToTarget, 2,
/* 2352*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2360*/ /*Scope*/ 11, /*->2372*/
/* 2361*/ OPC_EmitMergeInputChains1_0,
/* 2362*/ OPC_EmitConvertToTarget, 2,
/* 2364*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2372*/ 0, /*End of Scope*/
/* 2373*/ /*Scope*/ 32, /*->2406*/
/* 2374*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2376*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 2378*/ OPC_Scope, 13, /*->2393*/ // 2 children in Scope
/* 2380*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2382*/ OPC_EmitMergeInputChains1_0,
/* 2383*/ OPC_EmitConvertToTarget, 2,
/* 2385*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2393*/ /*Scope*/ 11, /*->2405*/
/* 2394*/ OPC_EmitMergeInputChains1_0,
/* 2395*/ OPC_EmitConvertToTarget, 2,
/* 2397*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2405*/ 0, /*End of Scope*/
/* 2406*/ /*Scope*/ 32, /*->2439*/
/* 2407*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2409*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 2411*/ OPC_Scope, 13, /*->2426*/ // 2 children in Scope
/* 2413*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2415*/ OPC_EmitMergeInputChains1_0,
/* 2416*/ OPC_EmitConvertToTarget, 2,
/* 2418*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2426*/ /*Scope*/ 11, /*->2438*/
/* 2427*/ OPC_EmitMergeInputChains1_0,
/* 2428*/ OPC_EmitConvertToTarget, 2,
/* 2430*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2438*/ 0, /*End of Scope*/
/* 2439*/ /*Scope*/ 32, /*->2472*/
/* 2440*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2442*/ OPC_Scope, 13, /*->2457*/ // 2 children in Scope
/* 2444*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2446*/ OPC_EmitMergeInputChains1_0,
/* 2447*/ OPC_EmitConvertToTarget, 2,
/* 2449*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2457*/ /*Scope*/ 13, /*->2471*/
/* 2458*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 2460*/ OPC_EmitMergeInputChains1_0,
/* 2461*/ OPC_EmitConvertToTarget, 2,
/* 2463*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2471*/ 0, /*End of Scope*/
/* 2472*/ /*Scope*/ 66, /*->2539*/
/* 2473*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2475*/ OPC_Scope, 30, /*->2507*/ // 2 children in Scope
/* 2477*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 2479*/ OPC_Scope, 13, /*->2494*/ // 2 children in Scope
/* 2481*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2483*/ OPC_EmitMergeInputChains1_0,
/* 2484*/ OPC_EmitConvertToTarget, 2,
/* 2486*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 11
// Dst: (LBU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2494*/ /*Scope*/ 11, /*->2506*/
/* 2495*/ OPC_EmitMergeInputChains1_0,
/* 2496*/ OPC_EmitConvertToTarget, 2,
/* 2498*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 11
// Dst: (LBU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2506*/ 0, /*End of Scope*/
/* 2507*/ /*Scope*/ 30, /*->2538*/
/* 2508*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 2510*/ OPC_Scope, 13, /*->2525*/ // 2 children in Scope
/* 2512*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 2514*/ OPC_EmitMergeInputChains1_0,
/* 2515*/ OPC_EmitConvertToTarget, 2,
/* 2517*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 11
// Dst: (LHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2525*/ /*Scope*/ 11, /*->2537*/
/* 2526*/ OPC_EmitMergeInputChains1_0,
/* 2527*/ OPC_EmitConvertToTarget, 2,
/* 2529*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 11
// Dst: (LHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2537*/ 0, /*End of Scope*/
/* 2538*/ 0, /*End of Scope*/
/* 2539*/ /*Scope*/ 34, /*->2574*/
/* 2540*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2542*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 2544*/ OPC_Scope, 13, /*->2559*/ // 2 children in Scope
/* 2546*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2548*/ OPC_EmitMergeInputChains1_0,
/* 2549*/ OPC_EmitConvertToTarget, 2,
/* 2551*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2559*/ /*Scope*/ 13, /*->2573*/
/* 2560*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2562*/ OPC_EmitMergeInputChains1_0,
/* 2563*/ OPC_EmitConvertToTarget, 2,
/* 2565*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2573*/ 0, /*End of Scope*/
/* 2574*/ /*Scope*/ 34, /*->2609*/
/* 2575*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2577*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 2579*/ OPC_Scope, 13, /*->2594*/ // 2 children in Scope
/* 2581*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2583*/ OPC_EmitMergeInputChains1_0,
/* 2584*/ OPC_EmitConvertToTarget, 2,
/* 2586*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2594*/ /*Scope*/ 13, /*->2608*/
/* 2595*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2597*/ OPC_EmitMergeInputChains1_0,
/* 2598*/ OPC_EmitConvertToTarget, 2,
/* 2600*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2608*/ 0, /*End of Scope*/
/* 2609*/ /*Scope*/ 34, /*->2644*/
/* 2610*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2612*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 2614*/ OPC_Scope, 13, /*->2629*/ // 2 children in Scope
/* 2616*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2618*/ OPC_EmitMergeInputChains1_0,
/* 2619*/ OPC_EmitConvertToTarget, 2,
/* 2621*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 11
// Dst: (LWU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2629*/ /*Scope*/ 13, /*->2643*/
/* 2630*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2632*/ OPC_EmitMergeInputChains1_0,
/* 2633*/ OPC_EmitConvertToTarget, 2,
/* 2635*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 11
// Dst: (LWU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2643*/ 0, /*End of Scope*/
/* 2644*/ /*Scope*/ 32, /*->2677*/
/* 2645*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2647*/ OPC_Scope, 13, /*->2662*/ // 2 children in Scope
/* 2649*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 2651*/ OPC_EmitMergeInputChains1_0,
/* 2652*/ OPC_EmitConvertToTarget, 2,
/* 2654*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2662*/ /*Scope*/ 13, /*->2676*/
/* 2663*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 2665*/ OPC_EmitMergeInputChains1_0,
/* 2666*/ OPC_EmitConvertToTarget, 2,
/* 2668*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 2676*/ 0, /*End of Scope*/
/* 2677*/ 0, /*End of Scope*/
/* 2678*/ /*SwitchType*/ 46|128,3/*430*/, MVT::i64,// ->3111
/* 2681*/ OPC_MoveParent,
/* 2682*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 2684*/ OPC_CheckType, MVT::i64,
/* 2686*/ OPC_Scope, 20, /*->2708*/ // 20 children in Scope
/* 2688*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2690*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 2692*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2694*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2697*/ OPC_EmitMergeInputChains1_0,
/* 2698*/ OPC_EmitConvertToTarget, 2,
/* 2700*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2708*/ /*Scope*/ 20, /*->2729*/
/* 2709*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2711*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 2713*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2715*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2718*/ OPC_EmitMergeInputChains1_0,
/* 2719*/ OPC_EmitConvertToTarget, 2,
/* 2721*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 17
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2729*/ /*Scope*/ 20, /*->2750*/
/* 2730*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2732*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 2734*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2736*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2739*/ OPC_EmitMergeInputChains1_0,
/* 2740*/ OPC_EmitConvertToTarget, 2,
/* 2742*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2750*/ /*Scope*/ 20, /*->2771*/
/* 2751*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2753*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 2755*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2757*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2760*/ OPC_EmitMergeInputChains1_0,
/* 2761*/ OPC_EmitConvertToTarget, 2,
/* 2763*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 17
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2771*/ /*Scope*/ 18, /*->2790*/
/* 2772*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2774*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2776*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2779*/ OPC_EmitMergeInputChains1_0,
/* 2780*/ OPC_EmitConvertToTarget, 2,
/* 2782*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2790*/ /*Scope*/ 42, /*->2833*/
/* 2791*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2793*/ OPC_Scope, 18, /*->2813*/ // 2 children in Scope
/* 2795*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 2797*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2799*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2802*/ OPC_EmitMergeInputChains1_0,
/* 2803*/ OPC_EmitConvertToTarget, 2,
/* 2805*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 17
// Dst: (LBU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2813*/ /*Scope*/ 18, /*->2832*/
/* 2814*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 2816*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2818*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2821*/ OPC_EmitMergeInputChains1_0,
/* 2822*/ OPC_EmitConvertToTarget, 2,
/* 2824*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 17
// Dst: (LHU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2832*/ 0, /*End of Scope*/
/* 2833*/ /*Scope*/ 20, /*->2854*/
/* 2834*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2836*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 2838*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2840*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2843*/ OPC_EmitMergeInputChains1_0,
/* 2844*/ OPC_EmitConvertToTarget, 2,
/* 2846*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2854*/ /*Scope*/ 20, /*->2875*/
/* 2855*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2857*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 2859*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2861*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2864*/ OPC_EmitMergeInputChains1_0,
/* 2865*/ OPC_EmitConvertToTarget, 2,
/* 2867*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 17
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2875*/ /*Scope*/ 20, /*->2896*/
/* 2876*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 2878*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 2880*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2882*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2885*/ OPC_EmitMergeInputChains1_0,
/* 2886*/ OPC_EmitConvertToTarget, 2,
/* 2888*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 17
// Dst: (LWU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2896*/ /*Scope*/ 18, /*->2915*/
/* 2897*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2899*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2901*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 2904*/ OPC_EmitMergeInputChains1_0,
/* 2905*/ OPC_EmitConvertToTarget, 2,
/* 2907*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2915*/ /*Scope*/ 17, /*->2933*/
/* 2916*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2918*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 2920*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2922*/ OPC_EmitMergeInputChains1_0,
/* 2923*/ OPC_EmitConvertToTarget, 2,
/* 2925*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2933*/ /*Scope*/ 17, /*->2951*/
/* 2934*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2936*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 2938*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2940*/ OPC_EmitMergeInputChains1_0,
/* 2941*/ OPC_EmitConvertToTarget, 2,
/* 2943*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 11
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2951*/ /*Scope*/ 17, /*->2969*/
/* 2952*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 2954*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 2956*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2958*/ OPC_EmitMergeInputChains1_0,
/* 2959*/ OPC_EmitConvertToTarget, 2,
/* 2961*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2969*/ /*Scope*/ 17, /*->2987*/
/* 2970*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 2972*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 2974*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 2976*/ OPC_EmitMergeInputChains1_0,
/* 2977*/ OPC_EmitConvertToTarget, 2,
/* 2979*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 11
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 2987*/ /*Scope*/ 15, /*->3003*/
/* 2988*/ OPC_CheckPredicate, 8, // Predicate_load
/* 2990*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 2992*/ OPC_EmitMergeInputChains1_0,
/* 2993*/ OPC_EmitConvertToTarget, 2,
/* 2995*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3003*/ /*Scope*/ 36, /*->3040*/
/* 3004*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 3006*/ OPC_Scope, 15, /*->3023*/ // 2 children in Scope
/* 3008*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 3010*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3012*/ OPC_EmitMergeInputChains1_0,
/* 3013*/ OPC_EmitConvertToTarget, 2,
/* 3015*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 11
// Dst: (LBU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3023*/ /*Scope*/ 15, /*->3039*/
/* 3024*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 3026*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3028*/ OPC_EmitMergeInputChains1_0,
/* 3029*/ OPC_EmitConvertToTarget, 2,
/* 3031*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 11
// Dst: (LHU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3039*/ 0, /*End of Scope*/
/* 3040*/ /*Scope*/ 17, /*->3058*/
/* 3041*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3043*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 3045*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3047*/ OPC_EmitMergeInputChains1_0,
/* 3048*/ OPC_EmitConvertToTarget, 2,
/* 3050*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3058*/ /*Scope*/ 17, /*->3076*/
/* 3059*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3061*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 3063*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3065*/ OPC_EmitMergeInputChains1_0,
/* 3066*/ OPC_EmitConvertToTarget, 2,
/* 3068*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 11
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3076*/ /*Scope*/ 17, /*->3094*/
/* 3077*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 3079*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 3081*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3083*/ OPC_EmitMergeInputChains1_0,
/* 3084*/ OPC_EmitConvertToTarget, 2,
/* 3086*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 11
// Dst: (LWU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3094*/ /*Scope*/ 15, /*->3110*/
/* 3095*/ OPC_CheckPredicate, 8, // Predicate_load
/* 3097*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3099*/ OPC_EmitMergeInputChains1_0,
/* 3100*/ OPC_EmitConvertToTarget, 2,
/* 3102*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (LD:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 3110*/ 0, /*End of Scope*/
/* 3111*/ 0, // EndSwitchType
/* 3112*/ 0, // EndSwitchOpcode
/* 3113*/ /*Scope*/ 51|128,10/*1331*/, /*->4446*/
/* 3115*/ OPC_RecordChild1, // #1 = $rs1
/* 3116*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 3118*/ OPC_Scope, 63, /*->3183*/ // 12 children in Scope
/* 3120*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3122*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 3124*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3163
/* 3127*/ OPC_Scope, 17, /*->3146*/ // 2 children in Scope
/* 3129*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3131*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3134*/ OPC_EmitMergeInputChains1_0,
/* 3135*/ OPC_EmitInteger, MVT::i32, 0,
/* 3138*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3146*/ /*Scope*/ 15, /*->3162*/
/* 3147*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3150*/ OPC_EmitMergeInputChains1_0,
/* 3151*/ OPC_EmitInteger, MVT::i32, 0,
/* 3154*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3162*/ 0, /*End of Scope*/
/* 3163*/ /*SwitchType*/ 17, MVT::i64,// ->3182
/* 3165*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3167*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3170*/ OPC_EmitMergeInputChains1_0,
/* 3171*/ OPC_EmitInteger, MVT::i64, 0,
/* 3174*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3182*/ 0, // EndSwitchType
/* 3183*/ /*Scope*/ 63, /*->3247*/
/* 3184*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3186*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 3188*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3227
/* 3191*/ OPC_Scope, 17, /*->3210*/ // 2 children in Scope
/* 3193*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3195*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3198*/ OPC_EmitMergeInputChains1_0,
/* 3199*/ OPC_EmitInteger, MVT::i32, 0,
/* 3202*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3210*/ /*Scope*/ 15, /*->3226*/
/* 3211*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3214*/ OPC_EmitMergeInputChains1_0,
/* 3215*/ OPC_EmitInteger, MVT::i32, 0,
/* 3218*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3226*/ 0, /*End of Scope*/
/* 3227*/ /*SwitchType*/ 17, MVT::i64,// ->3246
/* 3229*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3231*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3234*/ OPC_EmitMergeInputChains1_0,
/* 3235*/ OPC_EmitInteger, MVT::i64, 0,
/* 3238*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 10
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3246*/ 0, // EndSwitchType
/* 3247*/ /*Scope*/ 63, /*->3311*/
/* 3248*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3250*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 3252*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3291
/* 3255*/ OPC_Scope, 17, /*->3274*/ // 2 children in Scope
/* 3257*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3259*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3262*/ OPC_EmitMergeInputChains1_0,
/* 3263*/ OPC_EmitInteger, MVT::i32, 0,
/* 3266*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3274*/ /*Scope*/ 15, /*->3290*/
/* 3275*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3278*/ OPC_EmitMergeInputChains1_0,
/* 3279*/ OPC_EmitInteger, MVT::i32, 0,
/* 3282*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3290*/ 0, /*End of Scope*/
/* 3291*/ /*SwitchType*/ 17, MVT::i64,// ->3310
/* 3293*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3295*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3298*/ OPC_EmitMergeInputChains1_0,
/* 3299*/ OPC_EmitInteger, MVT::i64, 0,
/* 3302*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3310*/ 0, // EndSwitchType
/* 3311*/ /*Scope*/ 63, /*->3375*/
/* 3312*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3314*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 3316*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3355
/* 3319*/ OPC_Scope, 17, /*->3338*/ // 2 children in Scope
/* 3321*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3323*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3326*/ OPC_EmitMergeInputChains1_0,
/* 3327*/ OPC_EmitInteger, MVT::i32, 0,
/* 3330*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3338*/ /*Scope*/ 15, /*->3354*/
/* 3339*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3342*/ OPC_EmitMergeInputChains1_0,
/* 3343*/ OPC_EmitInteger, MVT::i32, 0,
/* 3346*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3354*/ 0, /*End of Scope*/
/* 3355*/ /*SwitchType*/ 17, MVT::i64,// ->3374
/* 3357*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3359*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3362*/ OPC_EmitMergeInputChains1_0,
/* 3363*/ OPC_EmitInteger, MVT::i64, 0,
/* 3366*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 10
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3374*/ 0, // EndSwitchType
/* 3375*/ /*Scope*/ 63, /*->3439*/
/* 3376*/ OPC_CheckPredicate, 8, // Predicate_load
/* 3378*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->3419
/* 3381*/ OPC_Scope, 17, /*->3400*/ // 2 children in Scope
/* 3383*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3385*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3388*/ OPC_EmitMergeInputChains1_0,
/* 3389*/ OPC_EmitInteger, MVT::i32, 0,
/* 3392*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3400*/ /*Scope*/ 17, /*->3418*/
/* 3401*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 3403*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3406*/ OPC_EmitMergeInputChains1_0,
/* 3407*/ OPC_EmitInteger, MVT::i32, 0,
/* 3410*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3418*/ 0, /*End of Scope*/
/* 3419*/ /*SwitchType*/ 17, MVT::i64,// ->3438
/* 3421*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3423*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3426*/ OPC_EmitMergeInputChains1_0,
/* 3427*/ OPC_EmitInteger, MVT::i64, 0,
/* 3430*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3438*/ 0, // EndSwitchType
/* 3439*/ /*Scope*/ 0|128,1/*128*/, /*->3569*/
/* 3441*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 3443*/ OPC_Scope, 61, /*->3506*/ // 2 children in Scope
/* 3445*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 3447*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3486
/* 3450*/ OPC_Scope, 17, /*->3469*/ // 2 children in Scope
/* 3452*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3454*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3457*/ OPC_EmitMergeInputChains1_0,
/* 3458*/ OPC_EmitInteger, MVT::i32, 0,
/* 3461*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 10
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3469*/ /*Scope*/ 15, /*->3485*/
/* 3470*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3473*/ OPC_EmitMergeInputChains1_0,
/* 3474*/ OPC_EmitInteger, MVT::i32, 0,
/* 3477*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 10
// Dst: (LBU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3485*/ 0, /*End of Scope*/
/* 3486*/ /*SwitchType*/ 17, MVT::i64,// ->3505
/* 3488*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3490*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3493*/ OPC_EmitMergeInputChains1_0,
/* 3494*/ OPC_EmitInteger, MVT::i64, 0,
/* 3497*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 10
// Dst: (LBU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3505*/ 0, // EndSwitchType
/* 3506*/ /*Scope*/ 61, /*->3568*/
/* 3507*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 3509*/ OPC_SwitchType /*2 cases */, 36, MVT::i32,// ->3548
/* 3512*/ OPC_Scope, 17, /*->3531*/ // 2 children in Scope
/* 3514*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3516*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3519*/ OPC_EmitMergeInputChains1_0,
/* 3520*/ OPC_EmitInteger, MVT::i32, 0,
/* 3523*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 10
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3531*/ /*Scope*/ 15, /*->3547*/
/* 3532*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3535*/ OPC_EmitMergeInputChains1_0,
/* 3536*/ OPC_EmitInteger, MVT::i32, 0,
/* 3539*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 10
// Dst: (LHU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3547*/ 0, /*End of Scope*/
/* 3548*/ /*SwitchType*/ 17, MVT::i64,// ->3567
/* 3550*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 3552*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3555*/ OPC_EmitMergeInputChains1_0,
/* 3556*/ OPC_EmitInteger, MVT::i64, 0,
/* 3559*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 10
// Dst: (LHU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3567*/ 0, // EndSwitchType
/* 3568*/ 0, /*End of Scope*/
/* 3569*/ /*Scope*/ 65, /*->3635*/
/* 3570*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3572*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 3574*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->3615
/* 3577*/ OPC_Scope, 17, /*->3596*/ // 2 children in Scope
/* 3579*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3581*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3584*/ OPC_EmitMergeInputChains1_0,
/* 3585*/ OPC_EmitInteger, MVT::i32, 0,
/* 3588*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3596*/ /*Scope*/ 17, /*->3614*/
/* 3597*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 3599*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3602*/ OPC_EmitMergeInputChains1_0,
/* 3603*/ OPC_EmitInteger, MVT::i32, 0,
/* 3606*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3614*/ 0, /*End of Scope*/
/* 3615*/ /*SwitchType*/ 17, MVT::i64,// ->3634
/* 3617*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3619*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3622*/ OPC_EmitMergeInputChains1_0,
/* 3623*/ OPC_EmitInteger, MVT::i64, 0,
/* 3626*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3634*/ 0, // EndSwitchType
/* 3635*/ /*Scope*/ 65, /*->3701*/
/* 3636*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3638*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 3640*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->3681
/* 3643*/ OPC_Scope, 17, /*->3662*/ // 2 children in Scope
/* 3645*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3647*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3650*/ OPC_EmitMergeInputChains1_0,
/* 3651*/ OPC_EmitInteger, MVT::i32, 0,
/* 3654*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3662*/ /*Scope*/ 17, /*->3680*/
/* 3663*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 3665*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3668*/ OPC_EmitMergeInputChains1_0,
/* 3669*/ OPC_EmitInteger, MVT::i32, 0,
/* 3672*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3680*/ 0, /*End of Scope*/
/* 3681*/ /*SwitchType*/ 17, MVT::i64,// ->3700
/* 3683*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3685*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3688*/ OPC_EmitMergeInputChains1_0,
/* 3689*/ OPC_EmitInteger, MVT::i64, 0,
/* 3692*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 10
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3700*/ 0, // EndSwitchType
/* 3701*/ /*Scope*/ 65, /*->3767*/
/* 3702*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 3704*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 3706*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->3747
/* 3709*/ OPC_Scope, 17, /*->3728*/ // 2 children in Scope
/* 3711*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3713*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3716*/ OPC_EmitMergeInputChains1_0,
/* 3717*/ OPC_EmitInteger, MVT::i32, 0,
/* 3720*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 10
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3728*/ /*Scope*/ 17, /*->3746*/
/* 3729*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 3731*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3734*/ OPC_EmitMergeInputChains1_0,
/* 3735*/ OPC_EmitInteger, MVT::i32, 0,
/* 3738*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 10
// Dst: (LWU:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3746*/ 0, /*End of Scope*/
/* 3747*/ /*SwitchType*/ 17, MVT::i64,// ->3766
/* 3749*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3751*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3754*/ OPC_EmitMergeInputChains1_0,
/* 3755*/ OPC_EmitInteger, MVT::i64, 0,
/* 3758*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 10
// Dst: (LWU:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3766*/ 0, // EndSwitchType
/* 3767*/ /*Scope*/ 63, /*->3831*/
/* 3768*/ OPC_CheckPredicate, 8, // Predicate_load
/* 3770*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->3811
/* 3773*/ OPC_Scope, 17, /*->3792*/ // 2 children in Scope
/* 3775*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3777*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3780*/ OPC_EmitMergeInputChains1_0,
/* 3781*/ OPC_EmitInteger, MVT::i32, 0,
/* 3784*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3792*/ /*Scope*/ 17, /*->3810*/
/* 3793*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 3795*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3798*/ OPC_EmitMergeInputChains1_0,
/* 3799*/ OPC_EmitInteger, MVT::i32, 0,
/* 3802*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3810*/ 0, /*End of Scope*/
/* 3811*/ /*SwitchType*/ 17, MVT::i64,// ->3830
/* 3813*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 3815*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 3818*/ OPC_EmitMergeInputChains1_0,
/* 3819*/ OPC_EmitInteger, MVT::i64, 0,
/* 3822*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 3830*/ 0, // EndSwitchType
/* 3831*/ /*Scope*/ 14|128,3/*398*/, /*->4231*/
/* 3833*/ OPC_CheckChild1Type, MVT::i32,
/* 3835*/ OPC_CheckType, MVT::i32,
/* 3837*/ OPC_Scope, 34, /*->3873*/ // 10 children in Scope
/* 3839*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3841*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 3843*/ OPC_Scope, 14, /*->3859*/ // 2 children in Scope
/* 3845*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3847*/ OPC_EmitMergeInputChains1_0,
/* 3848*/ OPC_EmitInteger, MVT::i32, 0,
/* 3851*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3859*/ /*Scope*/ 12, /*->3872*/
/* 3860*/ OPC_EmitMergeInputChains1_0,
/* 3861*/ OPC_EmitInteger, MVT::i32, 0,
/* 3864*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3872*/ 0, /*End of Scope*/
/* 3873*/ /*Scope*/ 34, /*->3908*/
/* 3874*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3876*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 3878*/ OPC_Scope, 14, /*->3894*/ // 2 children in Scope
/* 3880*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3882*/ OPC_EmitMergeInputChains1_0,
/* 3883*/ OPC_EmitInteger, MVT::i32, 0,
/* 3886*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3894*/ /*Scope*/ 12, /*->3907*/
/* 3895*/ OPC_EmitMergeInputChains1_0,
/* 3896*/ OPC_EmitInteger, MVT::i32, 0,
/* 3899*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3907*/ 0, /*End of Scope*/
/* 3908*/ /*Scope*/ 34, /*->3943*/
/* 3909*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 3911*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 3913*/ OPC_Scope, 14, /*->3929*/ // 2 children in Scope
/* 3915*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3917*/ OPC_EmitMergeInputChains1_0,
/* 3918*/ OPC_EmitInteger, MVT::i32, 0,
/* 3921*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3929*/ /*Scope*/ 12, /*->3942*/
/* 3930*/ OPC_EmitMergeInputChains1_0,
/* 3931*/ OPC_EmitInteger, MVT::i32, 0,
/* 3934*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3942*/ 0, /*End of Scope*/
/* 3943*/ /*Scope*/ 34, /*->3978*/
/* 3944*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 3946*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 3948*/ OPC_Scope, 14, /*->3964*/ // 2 children in Scope
/* 3950*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 3952*/ OPC_EmitMergeInputChains1_0,
/* 3953*/ OPC_EmitInteger, MVT::i32, 0,
/* 3956*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3964*/ /*Scope*/ 12, /*->3977*/
/* 3965*/ OPC_EmitMergeInputChains1_0,
/* 3966*/ OPC_EmitInteger, MVT::i32, 0,
/* 3969*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3977*/ 0, /*End of Scope*/
/* 3978*/ /*Scope*/ 34, /*->4013*/
/* 3979*/ OPC_CheckPredicate, 8, // Predicate_load
/* 3981*/ OPC_Scope, 14, /*->3997*/ // 2 children in Scope
/* 3983*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 3985*/ OPC_EmitMergeInputChains1_0,
/* 3986*/ OPC_EmitInteger, MVT::i32, 0,
/* 3989*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 3997*/ /*Scope*/ 14, /*->4012*/
/* 3998*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 4000*/ OPC_EmitMergeInputChains1_0,
/* 4001*/ OPC_EmitInteger, MVT::i32, 0,
/* 4004*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4012*/ 0, /*End of Scope*/
/* 4013*/ /*Scope*/ 70, /*->4084*/
/* 4014*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 4016*/ OPC_Scope, 32, /*->4050*/ // 2 children in Scope
/* 4018*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 4020*/ OPC_Scope, 14, /*->4036*/ // 2 children in Scope
/* 4022*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 4024*/ OPC_EmitMergeInputChains1_0,
/* 4025*/ OPC_EmitInteger, MVT::i32, 0,
/* 4028*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 4
// Dst: (LBU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4036*/ /*Scope*/ 12, /*->4049*/
/* 4037*/ OPC_EmitMergeInputChains1_0,
/* 4038*/ OPC_EmitInteger, MVT::i32, 0,
/* 4041*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 4
// Dst: (LBU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4049*/ 0, /*End of Scope*/
/* 4050*/ /*Scope*/ 32, /*->4083*/
/* 4051*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 4053*/ OPC_Scope, 14, /*->4069*/ // 2 children in Scope
/* 4055*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 4057*/ OPC_EmitMergeInputChains1_0,
/* 4058*/ OPC_EmitInteger, MVT::i32, 0,
/* 4061*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 4
// Dst: (LHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4069*/ /*Scope*/ 12, /*->4082*/
/* 4070*/ OPC_EmitMergeInputChains1_0,
/* 4071*/ OPC_EmitInteger, MVT::i32, 0,
/* 4074*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 4
// Dst: (LHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4082*/ 0, /*End of Scope*/
/* 4083*/ 0, /*End of Scope*/
/* 4084*/ /*Scope*/ 36, /*->4121*/
/* 4085*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 4087*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 4089*/ OPC_Scope, 14, /*->4105*/ // 2 children in Scope
/* 4091*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4093*/ OPC_EmitMergeInputChains1_0,
/* 4094*/ OPC_EmitInteger, MVT::i32, 0,
/* 4097*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4105*/ /*Scope*/ 14, /*->4120*/
/* 4106*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 4108*/ OPC_EmitMergeInputChains1_0,
/* 4109*/ OPC_EmitInteger, MVT::i32, 0,
/* 4112*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4120*/ 0, /*End of Scope*/
/* 4121*/ /*Scope*/ 36, /*->4158*/
/* 4122*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 4124*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 4126*/ OPC_Scope, 14, /*->4142*/ // 2 children in Scope
/* 4128*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4130*/ OPC_EmitMergeInputChains1_0,
/* 4131*/ OPC_EmitInteger, MVT::i32, 0,
/* 4134*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4142*/ /*Scope*/ 14, /*->4157*/
/* 4143*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 4145*/ OPC_EmitMergeInputChains1_0,
/* 4146*/ OPC_EmitInteger, MVT::i32, 0,
/* 4149*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4157*/ 0, /*End of Scope*/
/* 4158*/ /*Scope*/ 36, /*->4195*/
/* 4159*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 4161*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 4163*/ OPC_Scope, 14, /*->4179*/ // 2 children in Scope
/* 4165*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4167*/ OPC_EmitMergeInputChains1_0,
/* 4168*/ OPC_EmitInteger, MVT::i32, 0,
/* 4171*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 4
// Dst: (LWU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4179*/ /*Scope*/ 14, /*->4194*/
/* 4180*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 4182*/ OPC_EmitMergeInputChains1_0,
/* 4183*/ OPC_EmitInteger, MVT::i32, 0,
/* 4186*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 4
// Dst: (LWU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4194*/ 0, /*End of Scope*/
/* 4195*/ /*Scope*/ 34, /*->4230*/
/* 4196*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4198*/ OPC_Scope, 14, /*->4214*/ // 2 children in Scope
/* 4200*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4202*/ OPC_EmitMergeInputChains1_0,
/* 4203*/ OPC_EmitInteger, MVT::i32, 0,
/* 4206*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4214*/ /*Scope*/ 14, /*->4229*/
/* 4215*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 4217*/ OPC_EmitMergeInputChains1_0,
/* 4218*/ OPC_EmitInteger, MVT::i32, 0,
/* 4221*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4229*/ 0, /*End of Scope*/
/* 4230*/ 0, /*End of Scope*/
/* 4231*/ /*Scope*/ 84|128,1/*212*/, /*->4445*/
/* 4233*/ OPC_CheckChild1Type, MVT::i64,
/* 4235*/ OPC_CheckType, MVT::i64,
/* 4237*/ OPC_Scope, 18, /*->4257*/ // 10 children in Scope
/* 4239*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 4241*/ OPC_CheckPredicate, 5, // Predicate_sextloadi8
/* 4243*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4245*/ OPC_EmitMergeInputChains1_0,
/* 4246*/ OPC_EmitInteger, MVT::i64, 0,
/* 4249*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4257*/ /*Scope*/ 18, /*->4276*/
/* 4258*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 4260*/ OPC_CheckPredicate, 5, // Predicate_extloadi8
/* 4262*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4264*/ OPC_EmitMergeInputChains1_0,
/* 4265*/ OPC_EmitInteger, MVT::i64, 0,
/* 4268*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> - Complexity = 4
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4276*/ /*Scope*/ 18, /*->4295*/
/* 4277*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 4279*/ OPC_CheckPredicate, 7, // Predicate_sextloadi16
/* 4281*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4283*/ OPC_EmitMergeInputChains1_0,
/* 4284*/ OPC_EmitInteger, MVT::i64, 0,
/* 4287*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4295*/ /*Scope*/ 18, /*->4314*/
/* 4296*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 4298*/ OPC_CheckPredicate, 7, // Predicate_extloadi16
/* 4300*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4302*/ OPC_EmitMergeInputChains1_0,
/* 4303*/ OPC_EmitInteger, MVT::i64, 0,
/* 4306*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> - Complexity = 4
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4314*/ /*Scope*/ 16, /*->4331*/
/* 4315*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4317*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4319*/ OPC_EmitMergeInputChains1_0,
/* 4320*/ OPC_EmitInteger, MVT::i64, 0,
/* 4323*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4331*/ /*Scope*/ 38, /*->4370*/
/* 4332*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 4334*/ OPC_Scope, 16, /*->4352*/ // 2 children in Scope
/* 4336*/ OPC_CheckPredicate, 5, // Predicate_zextloadi8
/* 4338*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4340*/ OPC_EmitMergeInputChains1_0,
/* 4341*/ OPC_EmitInteger, MVT::i64, 0,
/* 4344*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LBU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> - Complexity = 4
// Dst: (LBU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4352*/ /*Scope*/ 16, /*->4369*/
/* 4353*/ OPC_CheckPredicate, 7, // Predicate_zextloadi16
/* 4355*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 4357*/ OPC_EmitMergeInputChains1_0,
/* 4358*/ OPC_EmitInteger, MVT::i64, 0,
/* 4361*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LHU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> - Complexity = 4
// Dst: (LHU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4369*/ 0, /*End of Scope*/
/* 4370*/ /*Scope*/ 18, /*->4389*/
/* 4371*/ OPC_CheckPredicate, 4, // Predicate_sextload
/* 4373*/ OPC_CheckPredicate, 10, // Predicate_sextloadi32
/* 4375*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4377*/ OPC_EmitMergeInputChains1_0,
/* 4378*/ OPC_EmitInteger, MVT::i64, 0,
/* 4381*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4389*/ /*Scope*/ 18, /*->4408*/
/* 4390*/ OPC_CheckPredicate, 6, // Predicate_extload
/* 4392*/ OPC_CheckPredicate, 10, // Predicate_extloadi32
/* 4394*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4396*/ OPC_EmitMergeInputChains1_0,
/* 4397*/ OPC_EmitInteger, MVT::i64, 0,
/* 4400*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> - Complexity = 4
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4408*/ /*Scope*/ 18, /*->4427*/
/* 4409*/ OPC_CheckPredicate, 9, // Predicate_zextload
/* 4411*/ OPC_CheckPredicate, 10, // Predicate_zextloadi32
/* 4413*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4415*/ OPC_EmitMergeInputChains1_0,
/* 4416*/ OPC_EmitInteger, MVT::i64, 0,
/* 4419*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LWU), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> - Complexity = 4
// Dst: (LWU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4427*/ /*Scope*/ 16, /*->4444*/
/* 4428*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4430*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4432*/ OPC_EmitMergeInputChains1_0,
/* 4433*/ OPC_EmitInteger, MVT::i64, 0,
/* 4436*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (LD:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4444*/ 0, /*End of Scope*/
/* 4445*/ 0, /*End of Scope*/
/* 4446*/ /*Scope*/ 126|128,2/*382*/, /*->4830*/
/* 4448*/ OPC_MoveChild1,
/* 4449*/ OPC_SwitchOpcode /*2 cases */, 15|128,1/*143*/, TARGET_VAL(ISD::OR),// ->4597
/* 4454*/ OPC_RecordChild0, // #1 = $rs1
/* 4455*/ OPC_RecordChild1, // #2 = $imm12
/* 4456*/ OPC_MoveChild1,
/* 4457*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 4460*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 4462*/ OPC_MoveParent,
/* 4463*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 4465*/ OPC_SwitchType /*2 cases */, 83, MVT::i32,// ->4551
/* 4468*/ OPC_MoveParent,
/* 4469*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 4471*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4473*/ OPC_SwitchType /*2 cases */, 36, MVT::f32,// ->4512
/* 4476*/ OPC_Scope, 16, /*->4494*/ // 2 children in Scope
/* 4478*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4480*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4483*/ OPC_EmitMergeInputChains1_0,
/* 4484*/ OPC_EmitConvertToTarget, 2,
/* 4486*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4494*/ /*Scope*/ 16, /*->4511*/
/* 4495*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 4497*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4500*/ OPC_EmitMergeInputChains1_0,
/* 4501*/ OPC_EmitConvertToTarget, 2,
/* 4503*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4511*/ 0, /*End of Scope*/
/* 4512*/ /*SwitchType*/ 36, MVT::f64,// ->4550
/* 4514*/ OPC_Scope, 16, /*->4532*/ // 2 children in Scope
/* 4516*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4518*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4521*/ OPC_EmitMergeInputChains1_0,
/* 4522*/ OPC_EmitConvertToTarget, 2,
/* 4524*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4532*/ /*Scope*/ 16, /*->4549*/
/* 4533*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 4535*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4538*/ OPC_EmitMergeInputChains1_0,
/* 4539*/ OPC_EmitConvertToTarget, 2,
/* 4541*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4549*/ 0, /*End of Scope*/
/* 4550*/ 0, // EndSwitchType
/* 4551*/ /*SwitchType*/ 43, MVT::i64,// ->4596
/* 4553*/ OPC_MoveParent,
/* 4554*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 4556*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4558*/ OPC_SwitchType /*2 cases */, 16, MVT::f32,// ->4577
/* 4561*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4563*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4566*/ OPC_EmitMergeInputChains1_0,
/* 4567*/ OPC_EmitConvertToTarget, 2,
/* 4569*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4577*/ /*SwitchType*/ 16, MVT::f64,// ->4595
/* 4579*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4581*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4584*/ OPC_EmitMergeInputChains1_0,
/* 4585*/ OPC_EmitConvertToTarget, 2,
/* 4587*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 18
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4595*/ 0, // EndSwitchType
/* 4596*/ 0, // EndSwitchType
/* 4597*/ /*SwitchOpcode*/ 100|128,1/*228*/, TARGET_VAL(ISD::ADD),// ->4829
/* 4601*/ OPC_RecordChild0, // #1 = $rs1
/* 4602*/ OPC_RecordChild1, // #2 = $imm12
/* 4603*/ OPC_MoveChild1,
/* 4604*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 4607*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 4609*/ OPC_MoveParent,
/* 4610*/ OPC_SwitchType /*2 cases */, 11|128,1/*139*/, MVT::i32,// ->4753
/* 4614*/ OPC_MoveParent,
/* 4615*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 4617*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4619*/ OPC_SwitchType /*2 cases */, 64, MVT::f32,// ->4686
/* 4622*/ OPC_Scope, 16, /*->4640*/ // 4 children in Scope
/* 4624*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4626*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4629*/ OPC_EmitMergeInputChains1_0,
/* 4630*/ OPC_EmitConvertToTarget, 2,
/* 4632*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4640*/ /*Scope*/ 16, /*->4657*/
/* 4641*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 4643*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4646*/ OPC_EmitMergeInputChains1_0,
/* 4647*/ OPC_EmitConvertToTarget, 2,
/* 4649*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4657*/ /*Scope*/ 13, /*->4671*/
/* 4658*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4660*/ OPC_EmitMergeInputChains1_0,
/* 4661*/ OPC_EmitConvertToTarget, 2,
/* 4663*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4671*/ /*Scope*/ 13, /*->4685*/
/* 4672*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 4674*/ OPC_EmitMergeInputChains1_0,
/* 4675*/ OPC_EmitConvertToTarget, 2,
/* 4677*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4685*/ 0, /*End of Scope*/
/* 4686*/ /*SwitchType*/ 64, MVT::f64,// ->4752
/* 4688*/ OPC_Scope, 16, /*->4706*/ // 4 children in Scope
/* 4690*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4692*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4695*/ OPC_EmitMergeInputChains1_0,
/* 4696*/ OPC_EmitConvertToTarget, 2,
/* 4698*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4706*/ /*Scope*/ 16, /*->4723*/
/* 4707*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 4709*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4712*/ OPC_EmitMergeInputChains1_0,
/* 4713*/ OPC_EmitConvertToTarget, 2,
/* 4715*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4723*/ /*Scope*/ 13, /*->4737*/
/* 4724*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4726*/ OPC_EmitMergeInputChains1_0,
/* 4727*/ OPC_EmitConvertToTarget, 2,
/* 4729*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f64] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4737*/ /*Scope*/ 13, /*->4751*/
/* 4738*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 4740*/ OPC_EmitMergeInputChains1_0,
/* 4741*/ OPC_EmitConvertToTarget, 2,
/* 4743*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f64] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 4751*/ 0, /*End of Scope*/
/* 4752*/ 0, // EndSwitchType
/* 4753*/ /*SwitchType*/ 73, MVT::i64,// ->4828
/* 4755*/ OPC_MoveParent,
/* 4756*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 4758*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4760*/ OPC_SwitchType /*2 cases */, 31, MVT::f32,// ->4794
/* 4763*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4765*/ OPC_Scope, 14, /*->4781*/ // 2 children in Scope
/* 4767*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4770*/ OPC_EmitMergeInputChains1_0,
/* 4771*/ OPC_EmitConvertToTarget, 2,
/* 4773*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f32] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4781*/ /*Scope*/ 11, /*->4793*/
/* 4782*/ OPC_EmitMergeInputChains1_0,
/* 4783*/ OPC_EmitConvertToTarget, 2,
/* 4785*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f32] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4793*/ 0, /*End of Scope*/
/* 4794*/ /*SwitchType*/ 31, MVT::f64,// ->4827
/* 4796*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4798*/ OPC_Scope, 14, /*->4814*/ // 2 children in Scope
/* 4800*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 4803*/ OPC_EmitMergeInputChains1_0,
/* 4804*/ OPC_EmitConvertToTarget, 2,
/* 4806*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 3, 4,
// Src: (ld:{ *:[f64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 17
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4814*/ /*Scope*/ 11, /*->4826*/
/* 4815*/ OPC_EmitMergeInputChains1_0,
/* 4816*/ OPC_EmitConvertToTarget, 2,
/* 4818*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 3,
// Src: (ld:{ *:[f64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 11
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 4826*/ 0, /*End of Scope*/
/* 4827*/ 0, // EndSwitchType
/* 4828*/ 0, // EndSwitchType
/* 4829*/ 0, // EndSwitchOpcode
/* 4830*/ /*Scope*/ 99|128,1/*227*/, /*->5059*/
/* 4832*/ OPC_RecordChild1, // #1 = $rs1
/* 4833*/ OPC_CheckPredicate, 3, // Predicate_unindexedload
/* 4835*/ OPC_CheckPredicate, 8, // Predicate_load
/* 4837*/ OPC_SwitchType /*2 cases */, 108, MVT::f32,// ->4948
/* 4840*/ OPC_Scope, 17, /*->4859*/ // 5 children in Scope
/* 4842*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4844*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4847*/ OPC_EmitMergeInputChains1_0,
/* 4848*/ OPC_EmitInteger, MVT::i32, 0,
/* 4851*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4859*/ /*Scope*/ 17, /*->4877*/
/* 4860*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4862*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4865*/ OPC_EmitMergeInputChains1_0,
/* 4866*/ OPC_EmitInteger, MVT::i64, 0,
/* 4869*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4877*/ /*Scope*/ 17, /*->4895*/
/* 4878*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 4880*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4883*/ OPC_EmitMergeInputChains1_0,
/* 4884*/ OPC_EmitInteger, MVT::i32, 0,
/* 4887*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLW:{ *:[f32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4895*/ /*Scope*/ 34, /*->4930*/
/* 4896*/ OPC_CheckChild1Type, MVT::i32,
/* 4898*/ OPC_Scope, 14, /*->4914*/ // 2 children in Scope
/* 4900*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4902*/ OPC_EmitMergeInputChains1_0,
/* 4903*/ OPC_EmitInteger, MVT::i32, 0,
/* 4906*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4914*/ /*Scope*/ 14, /*->4929*/
/* 4915*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 4917*/ OPC_EmitMergeInputChains1_0,
/* 4918*/ OPC_EmitInteger, MVT::i32, 0,
/* 4921*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4929*/ 0, /*End of Scope*/
/* 4930*/ /*Scope*/ 16, /*->4947*/
/* 4931*/ OPC_CheckChild1Type, MVT::i64,
/* 4933*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4935*/ OPC_EmitMergeInputChains1_0,
/* 4936*/ OPC_EmitInteger, MVT::i64, 0,
/* 4939*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f32, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f32] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLW:{ *:[f32] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4947*/ 0, /*End of Scope*/
/* 4948*/ /*SwitchType*/ 108, MVT::f64,// ->5058
/* 4950*/ OPC_Scope, 17, /*->4969*/ // 5 children in Scope
/* 4952*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 4954*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4957*/ OPC_EmitMergeInputChains1_0,
/* 4958*/ OPC_EmitInteger, MVT::i32, 0,
/* 4961*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 4969*/ /*Scope*/ 17, /*->4987*/
/* 4970*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 4972*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4975*/ OPC_EmitMergeInputChains1_0,
/* 4976*/ OPC_EmitInteger, MVT::i64, 0,
/* 4979*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 4987*/ /*Scope*/ 17, /*->5005*/
/* 4988*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 4990*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 4993*/ OPC_EmitMergeInputChains1_0,
/* 4994*/ OPC_EmitInteger, MVT::i32, 0,
/* 4997*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 2, 3,
// Src: (ld:{ *:[f64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 10
// Dst: (FLD:{ *:[f64] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5005*/ /*Scope*/ 34, /*->5040*/
/* 5006*/ OPC_CheckChild1Type, MVT::i32,
/* 5008*/ OPC_Scope, 14, /*->5024*/ // 2 children in Scope
/* 5010*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5012*/ OPC_EmitMergeInputChains1_0,
/* 5013*/ OPC_EmitInteger, MVT::i32, 0,
/* 5016*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f64] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5024*/ /*Scope*/ 14, /*->5039*/
/* 5025*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 5027*/ OPC_EmitMergeInputChains1_0,
/* 5028*/ OPC_EmitInteger, MVT::i32, 0,
/* 5031*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f64] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5039*/ 0, /*End of Scope*/
/* 5040*/ /*Scope*/ 16, /*->5057*/
/* 5041*/ OPC_CheckChild1Type, MVT::i64,
/* 5043*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 5045*/ OPC_EmitMergeInputChains1_0,
/* 5046*/ OPC_EmitInteger, MVT::i64, 0,
/* 5049*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::f64, 2/*#Ops*/, 1, 2,
// Src: (ld:{ *:[f64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedload>><<P:Predicate_load>> - Complexity = 4
// Dst: (FLD:{ *:[f64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 5057*/ 0, /*End of Scope*/
/* 5058*/ 0, // EndSwitchType
/* 5059*/ 0, /*End of Scope*/
/* 5060*/ /*SwitchOpcode*/ 59|128,17/*2235*/, TARGET_VAL(ISD::STORE),// ->7299
/* 5064*/ OPC_RecordMemRef,
/* 5065*/ OPC_RecordNode, // #0 = 'st' chained node
/* 5066*/ OPC_RecordChild1, // #1 = $rs2
/* 5067*/ OPC_Scope, 118|128,7/*1014*/, /*->6084*/ // 4 children in Scope
/* 5070*/ OPC_CheckChild1Type, MVT::i32,
/* 5072*/ OPC_Scope, 97|128,4/*609*/, /*->5684*/ // 2 children in Scope
/* 5075*/ OPC_MoveChild2,
/* 5076*/ OPC_SwitchOpcode /*2 cases */, 88|128,1/*216*/, TARGET_VAL(ISD::OR),// ->5297
/* 5081*/ OPC_RecordChild0, // #2 = $rs1
/* 5082*/ OPC_RecordChild1, // #3 = $imm12
/* 5083*/ OPC_MoveChild1,
/* 5084*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 5087*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 5089*/ OPC_MoveParent,
/* 5090*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 5092*/ OPC_CheckType, MVT::i32,
/* 5094*/ OPC_MoveParent,
/* 5095*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 5097*/ OPC_Scope, 78, /*->5177*/ // 4 children in Scope
/* 5099*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5101*/ OPC_Scope, 36, /*->5139*/ // 2 children in Scope
/* 5103*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 5105*/ OPC_Scope, 16, /*->5123*/ // 2 children in Scope
/* 5107*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5109*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5112*/ OPC_EmitMergeInputChains1_0,
/* 5113*/ OPC_EmitConvertToTarget, 3,
/* 5115*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5123*/ /*Scope*/ 14, /*->5138*/
/* 5124*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5127*/ OPC_EmitMergeInputChains1_0,
/* 5128*/ OPC_EmitConvertToTarget, 3,
/* 5130*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5138*/ 0, /*End of Scope*/
/* 5139*/ /*Scope*/ 36, /*->5176*/
/* 5140*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 5142*/ OPC_Scope, 16, /*->5160*/ // 2 children in Scope
/* 5144*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5146*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5149*/ OPC_EmitMergeInputChains1_0,
/* 5150*/ OPC_EmitConvertToTarget, 3,
/* 5152*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5160*/ /*Scope*/ 14, /*->5175*/
/* 5161*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5164*/ OPC_EmitMergeInputChains1_0,
/* 5165*/ OPC_EmitConvertToTarget, 3,
/* 5167*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5175*/ 0, /*End of Scope*/
/* 5176*/ 0, /*End of Scope*/
/* 5177*/ /*Scope*/ 38, /*->5216*/
/* 5178*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5180*/ OPC_Scope, 16, /*->5198*/ // 2 children in Scope
/* 5182*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5184*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5187*/ OPC_EmitMergeInputChains1_0,
/* 5188*/ OPC_EmitConvertToTarget, 3,
/* 5190*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5198*/ /*Scope*/ 16, /*->5215*/
/* 5199*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 5201*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5204*/ OPC_EmitMergeInputChains1_0,
/* 5205*/ OPC_EmitConvertToTarget, 3,
/* 5207*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5215*/ 0, /*End of Scope*/
/* 5216*/ /*Scope*/ 40, /*->5257*/
/* 5217*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5219*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 5221*/ OPC_Scope, 16, /*->5239*/ // 2 children in Scope
/* 5223*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5225*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5228*/ OPC_EmitMergeInputChains1_0,
/* 5229*/ OPC_EmitConvertToTarget, 3,
/* 5231*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5239*/ /*Scope*/ 16, /*->5256*/
/* 5240*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5242*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5245*/ OPC_EmitMergeInputChains1_0,
/* 5246*/ OPC_EmitConvertToTarget, 3,
/* 5248*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5256*/ 0, /*End of Scope*/
/* 5257*/ /*Scope*/ 38, /*->5296*/
/* 5258*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5260*/ OPC_Scope, 16, /*->5278*/ // 2 children in Scope
/* 5262*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5264*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5267*/ OPC_EmitMergeInputChains1_0,
/* 5268*/ OPC_EmitConvertToTarget, 3,
/* 5270*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5278*/ /*Scope*/ 16, /*->5295*/
/* 5279*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5281*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5284*/ OPC_EmitMergeInputChains1_0,
/* 5285*/ OPC_EmitConvertToTarget, 3,
/* 5287*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5295*/ 0, /*End of Scope*/
/* 5296*/ 0, /*End of Scope*/
/* 5297*/ /*SwitchOpcode*/ 126|128,2/*382*/, TARGET_VAL(ISD::ADD),// ->5683
/* 5301*/ OPC_RecordChild0, // #2 = $rs1
/* 5302*/ OPC_RecordChild1, // #3 = $imm12
/* 5303*/ OPC_MoveChild1,
/* 5304*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 5307*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 5309*/ OPC_MoveParent,
/* 5310*/ OPC_CheckType, MVT::i32,
/* 5312*/ OPC_MoveParent,
/* 5313*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 5315*/ OPC_Scope, 78, /*->5395*/ // 8 children in Scope
/* 5317*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5319*/ OPC_Scope, 36, /*->5357*/ // 2 children in Scope
/* 5321*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 5323*/ OPC_Scope, 16, /*->5341*/ // 2 children in Scope
/* 5325*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5327*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5330*/ OPC_EmitMergeInputChains1_0,
/* 5331*/ OPC_EmitConvertToTarget, 3,
/* 5333*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5341*/ /*Scope*/ 14, /*->5356*/
/* 5342*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5345*/ OPC_EmitMergeInputChains1_0,
/* 5346*/ OPC_EmitConvertToTarget, 3,
/* 5348*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5356*/ 0, /*End of Scope*/
/* 5357*/ /*Scope*/ 36, /*->5394*/
/* 5358*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 5360*/ OPC_Scope, 16, /*->5378*/ // 2 children in Scope
/* 5362*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5364*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5367*/ OPC_EmitMergeInputChains1_0,
/* 5368*/ OPC_EmitConvertToTarget, 3,
/* 5370*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5378*/ /*Scope*/ 14, /*->5393*/
/* 5379*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5382*/ OPC_EmitMergeInputChains1_0,
/* 5383*/ OPC_EmitConvertToTarget, 3,
/* 5385*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5393*/ 0, /*End of Scope*/
/* 5394*/ 0, /*End of Scope*/
/* 5395*/ /*Scope*/ 38, /*->5434*/
/* 5396*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5398*/ OPC_Scope, 16, /*->5416*/ // 2 children in Scope
/* 5400*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5402*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5405*/ OPC_EmitMergeInputChains1_0,
/* 5406*/ OPC_EmitConvertToTarget, 3,
/* 5408*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5416*/ /*Scope*/ 16, /*->5433*/
/* 5417*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 5419*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5422*/ OPC_EmitMergeInputChains1_0,
/* 5423*/ OPC_EmitConvertToTarget, 3,
/* 5425*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5433*/ 0, /*End of Scope*/
/* 5434*/ /*Scope*/ 40, /*->5475*/
/* 5435*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5437*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 5439*/ OPC_Scope, 16, /*->5457*/ // 2 children in Scope
/* 5441*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5443*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5446*/ OPC_EmitMergeInputChains1_0,
/* 5447*/ OPC_EmitConvertToTarget, 3,
/* 5449*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5457*/ /*Scope*/ 16, /*->5474*/
/* 5458*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5460*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5463*/ OPC_EmitMergeInputChains1_0,
/* 5464*/ OPC_EmitConvertToTarget, 3,
/* 5466*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5474*/ 0, /*End of Scope*/
/* 5475*/ /*Scope*/ 38, /*->5514*/
/* 5476*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5478*/ OPC_Scope, 16, /*->5496*/ // 2 children in Scope
/* 5480*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5482*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5485*/ OPC_EmitMergeInputChains1_0,
/* 5486*/ OPC_EmitConvertToTarget, 3,
/* 5488*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5496*/ /*Scope*/ 16, /*->5513*/
/* 5497*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5499*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 5502*/ OPC_EmitMergeInputChains1_0,
/* 5503*/ OPC_EmitConvertToTarget, 3,
/* 5505*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5513*/ 0, /*End of Scope*/
/* 5514*/ /*Scope*/ 66, /*->5581*/
/* 5515*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5517*/ OPC_Scope, 30, /*->5549*/ // 2 children in Scope
/* 5519*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 5521*/ OPC_Scope, 13, /*->5536*/ // 2 children in Scope
/* 5523*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5525*/ OPC_EmitMergeInputChains1_0,
/* 5526*/ OPC_EmitConvertToTarget, 3,
/* 5528*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5536*/ /*Scope*/ 11, /*->5548*/
/* 5537*/ OPC_EmitMergeInputChains1_0,
/* 5538*/ OPC_EmitConvertToTarget, 3,
/* 5540*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5548*/ 0, /*End of Scope*/
/* 5549*/ /*Scope*/ 30, /*->5580*/
/* 5550*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 5552*/ OPC_Scope, 13, /*->5567*/ // 2 children in Scope
/* 5554*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5556*/ OPC_EmitMergeInputChains1_0,
/* 5557*/ OPC_EmitConvertToTarget, 3,
/* 5559*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5567*/ /*Scope*/ 11, /*->5579*/
/* 5568*/ OPC_EmitMergeInputChains1_0,
/* 5569*/ OPC_EmitConvertToTarget, 3,
/* 5571*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5579*/ 0, /*End of Scope*/
/* 5580*/ 0, /*End of Scope*/
/* 5581*/ /*Scope*/ 32, /*->5614*/
/* 5582*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5584*/ OPC_Scope, 13, /*->5599*/ // 2 children in Scope
/* 5586*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5588*/ OPC_EmitMergeInputChains1_0,
/* 5589*/ OPC_EmitConvertToTarget, 3,
/* 5591*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5599*/ /*Scope*/ 13, /*->5613*/
/* 5600*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 5602*/ OPC_EmitMergeInputChains1_0,
/* 5603*/ OPC_EmitConvertToTarget, 3,
/* 5605*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5613*/ 0, /*End of Scope*/
/* 5614*/ /*Scope*/ 34, /*->5649*/
/* 5615*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5617*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 5619*/ OPC_Scope, 13, /*->5634*/ // 2 children in Scope
/* 5621*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5623*/ OPC_EmitMergeInputChains1_0,
/* 5624*/ OPC_EmitConvertToTarget, 3,
/* 5626*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5634*/ /*Scope*/ 13, /*->5648*/
/* 5635*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5637*/ OPC_EmitMergeInputChains1_0,
/* 5638*/ OPC_EmitConvertToTarget, 3,
/* 5640*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5648*/ 0, /*End of Scope*/
/* 5649*/ /*Scope*/ 32, /*->5682*/
/* 5650*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5652*/ OPC_Scope, 13, /*->5667*/ // 2 children in Scope
/* 5654*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5656*/ OPC_EmitMergeInputChains1_0,
/* 5657*/ OPC_EmitConvertToTarget, 3,
/* 5659*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5667*/ /*Scope*/ 13, /*->5681*/
/* 5668*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5670*/ OPC_EmitMergeInputChains1_0,
/* 5671*/ OPC_EmitConvertToTarget, 3,
/* 5673*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 5681*/ 0, /*End of Scope*/
/* 5682*/ 0, /*End of Scope*/
/* 5683*/ 0, // EndSwitchOpcode
/* 5684*/ /*Scope*/ 13|128,3/*397*/, /*->6083*/
/* 5686*/ OPC_RecordChild2, // #2 = $rs1
/* 5687*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 5689*/ OPC_Scope, 82, /*->5773*/ // 5 children in Scope
/* 5691*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5693*/ OPC_Scope, 38, /*->5733*/ // 2 children in Scope
/* 5695*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 5697*/ OPC_Scope, 17, /*->5716*/ // 2 children in Scope
/* 5699*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5701*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5704*/ OPC_EmitMergeInputChains1_0,
/* 5705*/ OPC_EmitInteger, MVT::i32, 0,
/* 5708*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5716*/ /*Scope*/ 15, /*->5732*/
/* 5717*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5720*/ OPC_EmitMergeInputChains1_0,
/* 5721*/ OPC_EmitInteger, MVT::i32, 0,
/* 5724*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5732*/ 0, /*End of Scope*/
/* 5733*/ /*Scope*/ 38, /*->5772*/
/* 5734*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 5736*/ OPC_Scope, 17, /*->5755*/ // 2 children in Scope
/* 5738*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5740*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5743*/ OPC_EmitMergeInputChains1_0,
/* 5744*/ OPC_EmitInteger, MVT::i32, 0,
/* 5747*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5755*/ /*Scope*/ 15, /*->5771*/
/* 5756*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5759*/ OPC_EmitMergeInputChains1_0,
/* 5760*/ OPC_EmitInteger, MVT::i32, 0,
/* 5763*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5771*/ 0, /*End of Scope*/
/* 5772*/ 0, /*End of Scope*/
/* 5773*/ /*Scope*/ 40, /*->5814*/
/* 5774*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5776*/ OPC_Scope, 17, /*->5795*/ // 2 children in Scope
/* 5778*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5780*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5783*/ OPC_EmitMergeInputChains1_0,
/* 5784*/ OPC_EmitInteger, MVT::i32, 0,
/* 5787*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5795*/ /*Scope*/ 17, /*->5813*/
/* 5796*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 5798*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5801*/ OPC_EmitMergeInputChains1_0,
/* 5802*/ OPC_EmitInteger, MVT::i32, 0,
/* 5805*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5813*/ 0, /*End of Scope*/
/* 5814*/ /*Scope*/ 42, /*->5857*/
/* 5815*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5817*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 5819*/ OPC_Scope, 17, /*->5838*/ // 2 children in Scope
/* 5821*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5823*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5826*/ OPC_EmitMergeInputChains1_0,
/* 5827*/ OPC_EmitInteger, MVT::i32, 0,
/* 5830*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5838*/ /*Scope*/ 17, /*->5856*/
/* 5839*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5841*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5844*/ OPC_EmitMergeInputChains1_0,
/* 5845*/ OPC_EmitInteger, MVT::i32, 0,
/* 5848*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5856*/ 0, /*End of Scope*/
/* 5857*/ /*Scope*/ 40, /*->5898*/
/* 5858*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5860*/ OPC_Scope, 17, /*->5879*/ // 2 children in Scope
/* 5862*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5864*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5867*/ OPC_EmitMergeInputChains1_0,
/* 5868*/ OPC_EmitInteger, MVT::i32, 0,
/* 5871*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5879*/ /*Scope*/ 17, /*->5897*/
/* 5880*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 5882*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 5885*/ OPC_EmitMergeInputChains1_0,
/* 5886*/ OPC_EmitInteger, MVT::i32, 0,
/* 5889*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5897*/ 0, /*End of Scope*/
/* 5898*/ /*Scope*/ 54|128,1/*182*/, /*->6082*/
/* 5900*/ OPC_CheckChild2Type, MVT::i32,
/* 5902*/ OPC_Scope, 70, /*->5974*/ // 4 children in Scope
/* 5904*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 5906*/ OPC_Scope, 32, /*->5940*/ // 2 children in Scope
/* 5908*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 5910*/ OPC_Scope, 14, /*->5926*/ // 2 children in Scope
/* 5912*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5914*/ OPC_EmitMergeInputChains1_0,
/* 5915*/ OPC_EmitInteger, MVT::i32, 0,
/* 5918*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5926*/ /*Scope*/ 12, /*->5939*/
/* 5927*/ OPC_EmitMergeInputChains1_0,
/* 5928*/ OPC_EmitInteger, MVT::i32, 0,
/* 5931*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5939*/ 0, /*End of Scope*/
/* 5940*/ /*Scope*/ 32, /*->5973*/
/* 5941*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 5943*/ OPC_Scope, 14, /*->5959*/ // 2 children in Scope
/* 5945*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 5947*/ OPC_EmitMergeInputChains1_0,
/* 5948*/ OPC_EmitInteger, MVT::i32, 0,
/* 5951*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5959*/ /*Scope*/ 12, /*->5972*/
/* 5960*/ OPC_EmitMergeInputChains1_0,
/* 5961*/ OPC_EmitInteger, MVT::i32, 0,
/* 5964*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5972*/ 0, /*End of Scope*/
/* 5973*/ 0, /*End of Scope*/
/* 5974*/ /*Scope*/ 34, /*->6009*/
/* 5975*/ OPC_CheckPredicate, 13, // Predicate_store
/* 5977*/ OPC_Scope, 14, /*->5993*/ // 2 children in Scope
/* 5979*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 5981*/ OPC_EmitMergeInputChains1_0,
/* 5982*/ OPC_EmitInteger, MVT::i32, 0,
/* 5985*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 5993*/ /*Scope*/ 14, /*->6008*/
/* 5994*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 5996*/ OPC_EmitMergeInputChains1_0,
/* 5997*/ OPC_EmitInteger, MVT::i32, 0,
/* 6000*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6008*/ 0, /*End of Scope*/
/* 6009*/ /*Scope*/ 36, /*->6046*/
/* 6010*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6012*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6014*/ OPC_Scope, 14, /*->6030*/ // 2 children in Scope
/* 6016*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6018*/ OPC_EmitMergeInputChains1_0,
/* 6019*/ OPC_EmitInteger, MVT::i32, 0,
/* 6022*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6030*/ /*Scope*/ 14, /*->6045*/
/* 6031*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 6033*/ OPC_EmitMergeInputChains1_0,
/* 6034*/ OPC_EmitInteger, MVT::i32, 0,
/* 6037*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6045*/ 0, /*End of Scope*/
/* 6046*/ /*Scope*/ 34, /*->6081*/
/* 6047*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6049*/ OPC_Scope, 14, /*->6065*/ // 2 children in Scope
/* 6051*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6053*/ OPC_EmitMergeInputChains1_0,
/* 6054*/ OPC_EmitInteger, MVT::i32, 0,
/* 6057*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6065*/ /*Scope*/ 14, /*->6080*/
/* 6066*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 6068*/ OPC_EmitMergeInputChains1_0,
/* 6069*/ OPC_EmitInteger, MVT::i32, 0,
/* 6072*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6080*/ 0, /*End of Scope*/
/* 6081*/ 0, /*End of Scope*/
/* 6082*/ 0, /*End of Scope*/
/* 6083*/ 0, /*End of Scope*/
/* 6084*/ /*Scope*/ 40|128,4/*552*/, /*->6638*/
/* 6086*/ OPC_CheckChild1Type, MVT::i64,
/* 6088*/ OPC_Scope, 79|128,2/*335*/, /*->6426*/ // 2 children in Scope
/* 6091*/ OPC_MoveChild2,
/* 6092*/ OPC_SwitchOpcode /*2 cases */, 120, TARGET_VAL(ISD::OR),// ->6216
/* 6096*/ OPC_RecordChild0, // #2 = $rs1
/* 6097*/ OPC_RecordChild1, // #3 = $imm12
/* 6098*/ OPC_MoveChild1,
/* 6099*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 6102*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 6104*/ OPC_MoveParent,
/* 6105*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 6107*/ OPC_CheckType, MVT::i64,
/* 6109*/ OPC_MoveParent,
/* 6110*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6112*/ OPC_Scope, 42, /*->6156*/ // 4 children in Scope
/* 6114*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6116*/ OPC_Scope, 18, /*->6136*/ // 2 children in Scope
/* 6118*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 6120*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6122*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6125*/ OPC_EmitMergeInputChains1_0,
/* 6126*/ OPC_EmitConvertToTarget, 3,
/* 6128*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6136*/ /*Scope*/ 18, /*->6155*/
/* 6137*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 6139*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6141*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6144*/ OPC_EmitMergeInputChains1_0,
/* 6145*/ OPC_EmitConvertToTarget, 3,
/* 6147*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6155*/ 0, /*End of Scope*/
/* 6156*/ /*Scope*/ 18, /*->6175*/
/* 6157*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6159*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6161*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6164*/ OPC_EmitMergeInputChains1_0,
/* 6165*/ OPC_EmitConvertToTarget, 3,
/* 6167*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6175*/ /*Scope*/ 20, /*->6196*/
/* 6176*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6178*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6180*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6182*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6185*/ OPC_EmitMergeInputChains1_0,
/* 6186*/ OPC_EmitConvertToTarget, 3,
/* 6188*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6196*/ /*Scope*/ 18, /*->6215*/
/* 6197*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6199*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6201*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6204*/ OPC_EmitMergeInputChains1_0,
/* 6205*/ OPC_EmitConvertToTarget, 3,
/* 6207*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6215*/ 0, /*End of Scope*/
/* 6216*/ /*SwitchOpcode*/ 77|128,1/*205*/, TARGET_VAL(ISD::ADD),// ->6425
/* 6220*/ OPC_RecordChild0, // #2 = $rs1
/* 6221*/ OPC_RecordChild1, // #3 = $imm12
/* 6222*/ OPC_MoveChild1,
/* 6223*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 6226*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 6228*/ OPC_MoveParent,
/* 6229*/ OPC_CheckType, MVT::i64,
/* 6231*/ OPC_MoveParent,
/* 6232*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6234*/ OPC_Scope, 42, /*->6278*/ // 8 children in Scope
/* 6236*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6238*/ OPC_Scope, 18, /*->6258*/ // 2 children in Scope
/* 6240*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 6242*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6244*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6247*/ OPC_EmitMergeInputChains1_0,
/* 6248*/ OPC_EmitConvertToTarget, 3,
/* 6250*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6258*/ /*Scope*/ 18, /*->6277*/
/* 6259*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 6261*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6263*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6266*/ OPC_EmitMergeInputChains1_0,
/* 6267*/ OPC_EmitConvertToTarget, 3,
/* 6269*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6277*/ 0, /*End of Scope*/
/* 6278*/ /*Scope*/ 18, /*->6297*/
/* 6279*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6281*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6283*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6286*/ OPC_EmitMergeInputChains1_0,
/* 6287*/ OPC_EmitConvertToTarget, 3,
/* 6289*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6297*/ /*Scope*/ 20, /*->6318*/
/* 6298*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6300*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6302*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6304*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6307*/ OPC_EmitMergeInputChains1_0,
/* 6308*/ OPC_EmitConvertToTarget, 3,
/* 6310*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6318*/ /*Scope*/ 18, /*->6337*/
/* 6319*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6321*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 6323*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6326*/ OPC_EmitMergeInputChains1_0,
/* 6327*/ OPC_EmitConvertToTarget, 3,
/* 6329*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6337*/ /*Scope*/ 36, /*->6374*/
/* 6338*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6340*/ OPC_Scope, 15, /*->6357*/ // 2 children in Scope
/* 6342*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 6344*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6346*/ OPC_EmitMergeInputChains1_0,
/* 6347*/ OPC_EmitConvertToTarget, 3,
/* 6349*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6357*/ /*Scope*/ 15, /*->6373*/
/* 6358*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 6360*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6362*/ OPC_EmitMergeInputChains1_0,
/* 6363*/ OPC_EmitConvertToTarget, 3,
/* 6365*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6373*/ 0, /*End of Scope*/
/* 6374*/ /*Scope*/ 15, /*->6390*/
/* 6375*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6377*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6379*/ OPC_EmitMergeInputChains1_0,
/* 6380*/ OPC_EmitConvertToTarget, 3,
/* 6382*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6390*/ /*Scope*/ 17, /*->6408*/
/* 6391*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6393*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6395*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6397*/ OPC_EmitMergeInputChains1_0,
/* 6398*/ OPC_EmitConvertToTarget, 3,
/* 6400*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6408*/ /*Scope*/ 15, /*->6424*/
/* 6409*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6411*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6413*/ OPC_EmitMergeInputChains1_0,
/* 6414*/ OPC_EmitConvertToTarget, 3,
/* 6416*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (SD GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6424*/ 0, /*End of Scope*/
/* 6425*/ 0, // EndSwitchOpcode
/* 6426*/ /*Scope*/ 81|128,1/*209*/, /*->6637*/
/* 6428*/ OPC_RecordChild2, // #2 = $rs1
/* 6429*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6431*/ OPC_Scope, 44, /*->6477*/ // 5 children in Scope
/* 6433*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6435*/ OPC_Scope, 19, /*->6456*/ // 2 children in Scope
/* 6437*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 6439*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6441*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6444*/ OPC_EmitMergeInputChains1_0,
/* 6445*/ OPC_EmitInteger, MVT::i64, 0,
/* 6448*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6456*/ /*Scope*/ 19, /*->6476*/
/* 6457*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 6459*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6461*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6464*/ OPC_EmitMergeInputChains1_0,
/* 6465*/ OPC_EmitInteger, MVT::i64, 0,
/* 6468*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6476*/ 0, /*End of Scope*/
/* 6477*/ /*Scope*/ 19, /*->6497*/
/* 6478*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6480*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6482*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6485*/ OPC_EmitMergeInputChains1_0,
/* 6486*/ OPC_EmitInteger, MVT::i64, 0,
/* 6489*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6497*/ /*Scope*/ 21, /*->6519*/
/* 6498*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6500*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6502*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6504*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6507*/ OPC_EmitMergeInputChains1_0,
/* 6508*/ OPC_EmitInteger, MVT::i64, 0,
/* 6511*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6519*/ /*Scope*/ 19, /*->6539*/
/* 6520*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6522*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6524*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6527*/ OPC_EmitMergeInputChains1_0,
/* 6528*/ OPC_EmitInteger, MVT::i64, 0,
/* 6531*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6539*/ /*Scope*/ 96, /*->6636*/
/* 6540*/ OPC_CheckChild2Type, MVT::i64,
/* 6542*/ OPC_Scope, 38, /*->6582*/ // 4 children in Scope
/* 6544*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6546*/ OPC_Scope, 16, /*->6564*/ // 2 children in Scope
/* 6548*/ OPC_CheckPredicate, 5, // Predicate_truncstorei8
/* 6550*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6552*/ OPC_EmitMergeInputChains1_0,
/* 6553*/ OPC_EmitInteger, MVT::i64, 0,
/* 6556*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6564*/ /*Scope*/ 16, /*->6581*/
/* 6565*/ OPC_CheckPredicate, 7, // Predicate_truncstorei16
/* 6567*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 6569*/ OPC_EmitMergeInputChains1_0,
/* 6570*/ OPC_EmitInteger, MVT::i64, 0,
/* 6573*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6581*/ 0, /*End of Scope*/
/* 6582*/ /*Scope*/ 16, /*->6599*/
/* 6583*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6585*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6587*/ OPC_EmitMergeInputChains1_0,
/* 6588*/ OPC_EmitInteger, MVT::i64, 0,
/* 6591*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6599*/ /*Scope*/ 18, /*->6618*/
/* 6600*/ OPC_CheckPredicate, 12, // Predicate_truncstore
/* 6602*/ OPC_CheckPredicate, 10, // Predicate_truncstorei32
/* 6604*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6606*/ OPC_EmitMergeInputChains1_0,
/* 6607*/ OPC_EmitInteger, MVT::i64, 0,
/* 6610*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstorei32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6618*/ /*Scope*/ 16, /*->6635*/
/* 6619*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6621*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6623*/ OPC_EmitMergeInputChains1_0,
/* 6624*/ OPC_EmitInteger, MVT::i64, 0,
/* 6627*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (SD GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6635*/ 0, /*End of Scope*/
/* 6636*/ 0, /*End of Scope*/
/* 6637*/ 0, /*End of Scope*/
/* 6638*/ /*Scope*/ 72|128,2/*328*/, /*->6968*/
/* 6640*/ OPC_CheckChild1Type, MVT::f32,
/* 6642*/ OPC_Scope, 80|128,1/*208*/, /*->6853*/ // 2 children in Scope
/* 6645*/ OPC_MoveChild2,
/* 6646*/ OPC_SwitchOpcode /*2 cases */, 79, TARGET_VAL(ISD::OR),// ->6729
/* 6650*/ OPC_RecordChild0, // #2 = $rs1
/* 6651*/ OPC_RecordChild1, // #3 = $imm12
/* 6652*/ OPC_MoveChild1,
/* 6653*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 6656*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 6658*/ OPC_MoveParent,
/* 6659*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 6661*/ OPC_SwitchType /*2 cases */, 41, MVT::i32,// ->6705
/* 6664*/ OPC_MoveParent,
/* 6665*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6667*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6669*/ OPC_Scope, 16, /*->6687*/ // 2 children in Scope
/* 6671*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6673*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6676*/ OPC_EmitMergeInputChains1_0,
/* 6677*/ OPC_EmitConvertToTarget, 3,
/* 6679*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6687*/ /*Scope*/ 16, /*->6704*/
/* 6688*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 6690*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6693*/ OPC_EmitMergeInputChains1_0,
/* 6694*/ OPC_EmitConvertToTarget, 3,
/* 6696*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6704*/ 0, /*End of Scope*/
/* 6705*/ /*SwitchType*/ 21, MVT::i64,// ->6728
/* 6707*/ OPC_MoveParent,
/* 6708*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6710*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6712*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6714*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6717*/ OPC_EmitMergeInputChains1_0,
/* 6718*/ OPC_EmitConvertToTarget, 3,
/* 6720*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6728*/ 0, // EndSwitchType
/* 6729*/ /*SwitchOpcode*/ 120, TARGET_VAL(ISD::ADD),// ->6852
/* 6732*/ OPC_RecordChild0, // #2 = $rs1
/* 6733*/ OPC_RecordChild1, // #3 = $imm12
/* 6734*/ OPC_MoveChild1,
/* 6735*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 6738*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 6740*/ OPC_MoveParent,
/* 6741*/ OPC_SwitchType /*2 cases */, 69, MVT::i32,// ->6813
/* 6744*/ OPC_MoveParent,
/* 6745*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6747*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6749*/ OPC_Scope, 16, /*->6767*/ // 4 children in Scope
/* 6751*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6753*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6756*/ OPC_EmitMergeInputChains1_0,
/* 6757*/ OPC_EmitConvertToTarget, 3,
/* 6759*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6767*/ /*Scope*/ 16, /*->6784*/
/* 6768*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 6770*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6773*/ OPC_EmitMergeInputChains1_0,
/* 6774*/ OPC_EmitConvertToTarget, 3,
/* 6776*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6784*/ /*Scope*/ 13, /*->6798*/
/* 6785*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6787*/ OPC_EmitMergeInputChains1_0,
/* 6788*/ OPC_EmitConvertToTarget, 3,
/* 6790*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6798*/ /*Scope*/ 13, /*->6812*/
/* 6799*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 6801*/ OPC_EmitMergeInputChains1_0,
/* 6802*/ OPC_EmitConvertToTarget, 3,
/* 6804*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 6812*/ 0, /*End of Scope*/
/* 6813*/ /*SwitchType*/ 36, MVT::i64,// ->6851
/* 6815*/ OPC_MoveParent,
/* 6816*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6818*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6820*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 6822*/ OPC_Scope, 14, /*->6838*/ // 2 children in Scope
/* 6824*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 6827*/ OPC_EmitMergeInputChains1_0,
/* 6828*/ OPC_EmitConvertToTarget, 3,
/* 6830*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6838*/ /*Scope*/ 11, /*->6850*/
/* 6839*/ OPC_EmitMergeInputChains1_0,
/* 6840*/ OPC_EmitConvertToTarget, 3,
/* 6842*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 6850*/ 0, /*End of Scope*/
/* 6851*/ 0, // EndSwitchType
/* 6852*/ 0, // EndSwitchOpcode
/* 6853*/ /*Scope*/ 113, /*->6967*/
/* 6854*/ OPC_RecordChild2, // #2 = $rs1
/* 6855*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6857*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6859*/ OPC_Scope, 17, /*->6878*/ // 5 children in Scope
/* 6861*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6863*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6866*/ OPC_EmitMergeInputChains1_0,
/* 6867*/ OPC_EmitInteger, MVT::i32, 0,
/* 6870*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6878*/ /*Scope*/ 17, /*->6896*/
/* 6879*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6881*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6884*/ OPC_EmitMergeInputChains1_0,
/* 6885*/ OPC_EmitInteger, MVT::i64, 0,
/* 6888*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6896*/ /*Scope*/ 17, /*->6914*/
/* 6897*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 6899*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 6902*/ OPC_EmitMergeInputChains1_0,
/* 6903*/ OPC_EmitInteger, MVT::i32, 0,
/* 6906*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6914*/ /*Scope*/ 34, /*->6949*/
/* 6915*/ OPC_CheckChild2Type, MVT::i32,
/* 6917*/ OPC_Scope, 14, /*->6933*/ // 2 children in Scope
/* 6919*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 6921*/ OPC_EmitMergeInputChains1_0,
/* 6922*/ OPC_EmitInteger, MVT::i32, 0,
/* 6925*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6933*/ /*Scope*/ 14, /*->6948*/
/* 6934*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 6936*/ OPC_EmitMergeInputChains1_0,
/* 6937*/ OPC_EmitInteger, MVT::i32, 0,
/* 6940*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 6948*/ 0, /*End of Scope*/
/* 6949*/ /*Scope*/ 16, /*->6966*/
/* 6950*/ OPC_CheckChild2Type, MVT::i64,
/* 6952*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 6954*/ OPC_EmitMergeInputChains1_0,
/* 6955*/ OPC_EmitInteger, MVT::i64, 0,
/* 6958*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSW FPR32:{ *:[f32] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 6966*/ 0, /*End of Scope*/
/* 6967*/ 0, /*End of Scope*/
/* 6968*/ /*Scope*/ 72|128,2/*328*/, /*->7298*/
/* 6970*/ OPC_CheckChild1Type, MVT::f64,
/* 6972*/ OPC_Scope, 80|128,1/*208*/, /*->7183*/ // 2 children in Scope
/* 6975*/ OPC_MoveChild2,
/* 6976*/ OPC_SwitchOpcode /*2 cases */, 79, TARGET_VAL(ISD::OR),// ->7059
/* 6980*/ OPC_RecordChild0, // #2 = $rs1
/* 6981*/ OPC_RecordChild1, // #3 = $imm12
/* 6982*/ OPC_MoveChild1,
/* 6983*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 6986*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 6988*/ OPC_MoveParent,
/* 6989*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 6991*/ OPC_SwitchType /*2 cases */, 41, MVT::i32,// ->7035
/* 6994*/ OPC_MoveParent,
/* 6995*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 6997*/ OPC_CheckPredicate, 13, // Predicate_store
/* 6999*/ OPC_Scope, 16, /*->7017*/ // 2 children in Scope
/* 7001*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7003*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7006*/ OPC_EmitMergeInputChains1_0,
/* 7007*/ OPC_EmitConvertToTarget, 3,
/* 7009*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7017*/ /*Scope*/ 16, /*->7034*/
/* 7018*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 7020*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7023*/ OPC_EmitMergeInputChains1_0,
/* 7024*/ OPC_EmitConvertToTarget, 3,
/* 7026*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7034*/ 0, /*End of Scope*/
/* 7035*/ /*SwitchType*/ 21, MVT::i64,// ->7058
/* 7037*/ OPC_MoveParent,
/* 7038*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 7040*/ OPC_CheckPredicate, 13, // Predicate_store
/* 7042*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7044*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7047*/ OPC_EmitMergeInputChains1_0,
/* 7048*/ OPC_EmitConvertToTarget, 3,
/* 7050*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 18
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7058*/ 0, // EndSwitchType
/* 7059*/ /*SwitchOpcode*/ 120, TARGET_VAL(ISD::ADD),// ->7182
/* 7062*/ OPC_RecordChild0, // #2 = $rs1
/* 7063*/ OPC_RecordChild1, // #3 = $imm12
/* 7064*/ OPC_MoveChild1,
/* 7065*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 7068*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 7070*/ OPC_MoveParent,
/* 7071*/ OPC_SwitchType /*2 cases */, 69, MVT::i32,// ->7143
/* 7074*/ OPC_MoveParent,
/* 7075*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 7077*/ OPC_CheckPredicate, 13, // Predicate_store
/* 7079*/ OPC_Scope, 16, /*->7097*/ // 4 children in Scope
/* 7081*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7083*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7086*/ OPC_EmitMergeInputChains1_0,
/* 7087*/ OPC_EmitConvertToTarget, 3,
/* 7089*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7097*/ /*Scope*/ 16, /*->7114*/
/* 7098*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 7100*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7103*/ OPC_EmitMergeInputChains1_0,
/* 7104*/ OPC_EmitConvertToTarget, 3,
/* 7106*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7114*/ /*Scope*/ 13, /*->7128*/
/* 7115*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7117*/ OPC_EmitMergeInputChains1_0,
/* 7118*/ OPC_EmitConvertToTarget, 3,
/* 7120*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7128*/ /*Scope*/ 13, /*->7142*/
/* 7129*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 7131*/ OPC_EmitMergeInputChains1_0,
/* 7132*/ OPC_EmitConvertToTarget, 3,
/* 7134*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7142*/ 0, /*End of Scope*/
/* 7143*/ /*SwitchType*/ 36, MVT::i64,// ->7181
/* 7145*/ OPC_MoveParent,
/* 7146*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 7148*/ OPC_CheckPredicate, 13, // Predicate_store
/* 7150*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7152*/ OPC_Scope, 14, /*->7168*/ // 2 children in Scope
/* 7154*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #4
/* 7157*/ OPC_EmitMergeInputChains1_0,
/* 7158*/ OPC_EmitConvertToTarget, 3,
/* 7160*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 4, 5,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 17
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7168*/ /*Scope*/ 11, /*->7180*/
/* 7169*/ OPC_EmitMergeInputChains1_0,
/* 7170*/ OPC_EmitConvertToTarget, 3,
/* 7172*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 11
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7180*/ 0, /*End of Scope*/
/* 7181*/ 0, // EndSwitchType
/* 7182*/ 0, // EndSwitchOpcode
/* 7183*/ /*Scope*/ 113, /*->7297*/
/* 7184*/ OPC_RecordChild2, // #2 = $rs1
/* 7185*/ OPC_CheckPredicate, 11, // Predicate_unindexedstore
/* 7187*/ OPC_CheckPredicate, 13, // Predicate_store
/* 7189*/ OPC_Scope, 17, /*->7208*/ // 5 children in Scope
/* 7191*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7193*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 7196*/ OPC_EmitMergeInputChains1_0,
/* 7197*/ OPC_EmitInteger, MVT::i32, 0,
/* 7200*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 7208*/ /*Scope*/ 17, /*->7226*/
/* 7209*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7211*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 7214*/ OPC_EmitMergeInputChains1_0,
/* 7215*/ OPC_EmitInteger, MVT::i64, 0,
/* 7218*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 7226*/ /*Scope*/ 17, /*->7244*/
/* 7227*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 7229*/ OPC_CheckComplexPat, /*CP*/0, /*#*/2, // SelectAddrFI:$rs1 #3
/* 7232*/ OPC_EmitMergeInputChains1_0,
/* 7233*/ OPC_EmitInteger, MVT::i32, 0,
/* 7236*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 3, 4,
// Src: (st FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 10
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 7244*/ /*Scope*/ 34, /*->7279*/
/* 7245*/ OPC_CheckChild2Type, MVT::i32,
/* 7247*/ OPC_Scope, 14, /*->7263*/ // 2 children in Scope
/* 7249*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7251*/ OPC_EmitMergeInputChains1_0,
/* 7252*/ OPC_EmitInteger, MVT::i32, 0,
/* 7255*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 7263*/ /*Scope*/ 14, /*->7278*/
/* 7264*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 7266*/ OPC_EmitMergeInputChains1_0,
/* 7267*/ OPC_EmitInteger, MVT::i32, 0,
/* 7270*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 7278*/ 0, /*End of Scope*/
/* 7279*/ /*Scope*/ 16, /*->7296*/
/* 7280*/ OPC_CheckChild2Type, MVT::i64,
/* 7282*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 7284*/ OPC_EmitMergeInputChains1_0,
/* 7285*/ OPC_EmitInteger, MVT::i64, 0,
/* 7288*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FSD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 1, 2, 3,
// Src: (st FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i64] }:$rs1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> - Complexity = 4
// Dst: (FSD FPR64:{ *:[f64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 7296*/ 0, /*End of Scope*/
/* 7297*/ 0, /*End of Scope*/
/* 7298*/ 0, /*End of Scope*/
/* 7299*/ /*SwitchOpcode*/ 74|128,9/*1226*/, TARGET_VAL(ISD::ATOMIC_STORE),// ->8529
/* 7303*/ OPC_RecordMemRef,
/* 7304*/ OPC_RecordNode, // #0 = 'atomic_store' chained node
/* 7305*/ OPC_Scope, 90|128,5/*730*/, /*->8038*/ // 2 children in Scope
/* 7308*/ OPC_MoveChild1,
/* 7309*/ OPC_SwitchOpcode /*2 cases */, 6|128,2/*262*/, TARGET_VAL(ISD::OR),// ->7576
/* 7314*/ OPC_RecordChild0, // #1 = $rs1
/* 7315*/ OPC_RecordChild1, // #2 = $imm12
/* 7316*/ OPC_MoveChild1,
/* 7317*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 7320*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 7322*/ OPC_MoveParent,
/* 7323*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 7325*/ OPC_SwitchType /*2 cases */, 34|128,1/*162*/, MVT::i32,// ->7491
/* 7329*/ OPC_MoveParent,
/* 7330*/ OPC_RecordChild2, // #3 = $rs2
/* 7331*/ OPC_CheckChild2Type, MVT::i32,
/* 7333*/ OPC_Scope, 38, /*->7373*/ // 4 children in Scope
/* 7335*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7337*/ OPC_Scope, 16, /*->7355*/ // 2 children in Scope
/* 7339*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7341*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7344*/ OPC_EmitMergeInputChains1_0,
/* 7345*/ OPC_EmitConvertToTarget, 2,
/* 7347*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7355*/ /*Scope*/ 16, /*->7372*/
/* 7356*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7358*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7361*/ OPC_EmitMergeInputChains1_0,
/* 7362*/ OPC_EmitConvertToTarget, 2,
/* 7364*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7372*/ 0, /*End of Scope*/
/* 7373*/ /*Scope*/ 38, /*->7412*/
/* 7374*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7376*/ OPC_Scope, 16, /*->7394*/ // 2 children in Scope
/* 7378*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7380*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7383*/ OPC_EmitMergeInputChains1_0,
/* 7384*/ OPC_EmitConvertToTarget, 2,
/* 7386*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7394*/ /*Scope*/ 16, /*->7411*/
/* 7395*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7397*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7400*/ OPC_EmitMergeInputChains1_0,
/* 7401*/ OPC_EmitConvertToTarget, 2,
/* 7403*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7411*/ 0, /*End of Scope*/
/* 7412*/ /*Scope*/ 38, /*->7451*/
/* 7413*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 7415*/ OPC_Scope, 16, /*->7433*/ // 2 children in Scope
/* 7417*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7419*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7422*/ OPC_EmitMergeInputChains1_0,
/* 7423*/ OPC_EmitConvertToTarget, 2,
/* 7425*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7433*/ /*Scope*/ 16, /*->7450*/
/* 7434*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7436*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7439*/ OPC_EmitMergeInputChains1_0,
/* 7440*/ OPC_EmitConvertToTarget, 2,
/* 7442*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7450*/ 0, /*End of Scope*/
/* 7451*/ /*Scope*/ 38, /*->7490*/
/* 7452*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 7454*/ OPC_Scope, 16, /*->7472*/ // 2 children in Scope
/* 7456*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7458*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7461*/ OPC_EmitMergeInputChains1_0,
/* 7462*/ OPC_EmitConvertToTarget, 2,
/* 7464*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 18
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7472*/ /*Scope*/ 16, /*->7489*/
/* 7473*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 7475*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7478*/ OPC_EmitMergeInputChains1_0,
/* 7479*/ OPC_EmitConvertToTarget, 2,
/* 7481*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 18
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7489*/ 0, /*End of Scope*/
/* 7490*/ 0, /*End of Scope*/
/* 7491*/ /*SwitchType*/ 82, MVT::i64,// ->7575
/* 7493*/ OPC_MoveParent,
/* 7494*/ OPC_RecordChild2, // #3 = $rs2
/* 7495*/ OPC_CheckChild2Type, MVT::i64,
/* 7497*/ OPC_Scope, 18, /*->7517*/ // 4 children in Scope
/* 7499*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7501*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7503*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7506*/ OPC_EmitMergeInputChains1_0,
/* 7507*/ OPC_EmitConvertToTarget, 2,
/* 7509*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 18
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7517*/ /*Scope*/ 18, /*->7536*/
/* 7518*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7520*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7522*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7525*/ OPC_EmitMergeInputChains1_0,
/* 7526*/ OPC_EmitConvertToTarget, 2,
/* 7528*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 18
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7536*/ /*Scope*/ 18, /*->7555*/
/* 7537*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 7539*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7541*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7544*/ OPC_EmitMergeInputChains1_0,
/* 7545*/ OPC_EmitConvertToTarget, 2,
/* 7547*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 18
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7555*/ /*Scope*/ 18, /*->7574*/
/* 7556*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 7558*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7560*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7563*/ OPC_EmitMergeInputChains1_0,
/* 7564*/ OPC_EmitConvertToTarget, 2,
/* 7566*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 18
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7574*/ 0, /*End of Scope*/
/* 7575*/ 0, // EndSwitchType
/* 7576*/ /*SwitchOpcode*/ 73|128,3/*457*/, TARGET_VAL(ISD::ADD),// ->8037
/* 7580*/ OPC_RecordChild0, // #1 = $rs1
/* 7581*/ OPC_RecordChild1, // #2 = $imm12
/* 7582*/ OPC_MoveChild1,
/* 7583*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 7586*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 7588*/ OPC_MoveParent,
/* 7589*/ OPC_SwitchType /*2 cases */, 38|128,2/*294*/, MVT::i32,// ->7887
/* 7593*/ OPC_MoveParent,
/* 7594*/ OPC_RecordChild2, // #3 = $rs2
/* 7595*/ OPC_CheckChild2Type, MVT::i32,
/* 7597*/ OPC_Scope, 38, /*->7637*/ // 8 children in Scope
/* 7599*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7601*/ OPC_Scope, 16, /*->7619*/ // 2 children in Scope
/* 7603*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7605*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7608*/ OPC_EmitMergeInputChains1_0,
/* 7609*/ OPC_EmitConvertToTarget, 2,
/* 7611*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7619*/ /*Scope*/ 16, /*->7636*/
/* 7620*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7622*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7625*/ OPC_EmitMergeInputChains1_0,
/* 7626*/ OPC_EmitConvertToTarget, 2,
/* 7628*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7636*/ 0, /*End of Scope*/
/* 7637*/ /*Scope*/ 38, /*->7676*/
/* 7638*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7640*/ OPC_Scope, 16, /*->7658*/ // 2 children in Scope
/* 7642*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7644*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7647*/ OPC_EmitMergeInputChains1_0,
/* 7648*/ OPC_EmitConvertToTarget, 2,
/* 7650*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7658*/ /*Scope*/ 16, /*->7675*/
/* 7659*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7661*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7664*/ OPC_EmitMergeInputChains1_0,
/* 7665*/ OPC_EmitConvertToTarget, 2,
/* 7667*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7675*/ 0, /*End of Scope*/
/* 7676*/ /*Scope*/ 38, /*->7715*/
/* 7677*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 7679*/ OPC_Scope, 16, /*->7697*/ // 2 children in Scope
/* 7681*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7683*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7686*/ OPC_EmitMergeInputChains1_0,
/* 7687*/ OPC_EmitConvertToTarget, 2,
/* 7689*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7697*/ /*Scope*/ 16, /*->7714*/
/* 7698*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7700*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7703*/ OPC_EmitMergeInputChains1_0,
/* 7704*/ OPC_EmitConvertToTarget, 2,
/* 7706*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7714*/ 0, /*End of Scope*/
/* 7715*/ /*Scope*/ 38, /*->7754*/
/* 7716*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 7718*/ OPC_Scope, 16, /*->7736*/ // 2 children in Scope
/* 7720*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7722*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7725*/ OPC_EmitMergeInputChains1_0,
/* 7726*/ OPC_EmitConvertToTarget, 2,
/* 7728*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 17
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7736*/ /*Scope*/ 16, /*->7753*/
/* 7737*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 7739*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7742*/ OPC_EmitMergeInputChains1_0,
/* 7743*/ OPC_EmitConvertToTarget, 2,
/* 7745*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 17
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7753*/ 0, /*End of Scope*/
/* 7754*/ /*Scope*/ 32, /*->7787*/
/* 7755*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7757*/ OPC_Scope, 13, /*->7772*/ // 2 children in Scope
/* 7759*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7761*/ OPC_EmitMergeInputChains1_0,
/* 7762*/ OPC_EmitConvertToTarget, 2,
/* 7764*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7772*/ /*Scope*/ 13, /*->7786*/
/* 7773*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7775*/ OPC_EmitMergeInputChains1_0,
/* 7776*/ OPC_EmitConvertToTarget, 2,
/* 7778*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7786*/ 0, /*End of Scope*/
/* 7787*/ /*Scope*/ 32, /*->7820*/
/* 7788*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7790*/ OPC_Scope, 13, /*->7805*/ // 2 children in Scope
/* 7792*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7794*/ OPC_EmitMergeInputChains1_0,
/* 7795*/ OPC_EmitConvertToTarget, 2,
/* 7797*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7805*/ /*Scope*/ 13, /*->7819*/
/* 7806*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7808*/ OPC_EmitMergeInputChains1_0,
/* 7809*/ OPC_EmitConvertToTarget, 2,
/* 7811*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7819*/ 0, /*End of Scope*/
/* 7820*/ /*Scope*/ 32, /*->7853*/
/* 7821*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 7823*/ OPC_Scope, 13, /*->7838*/ // 2 children in Scope
/* 7825*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7827*/ OPC_EmitMergeInputChains1_0,
/* 7828*/ OPC_EmitConvertToTarget, 2,
/* 7830*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7838*/ /*Scope*/ 13, /*->7852*/
/* 7839*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 7841*/ OPC_EmitMergeInputChains1_0,
/* 7842*/ OPC_EmitConvertToTarget, 2,
/* 7844*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7852*/ 0, /*End of Scope*/
/* 7853*/ /*Scope*/ 32, /*->7886*/
/* 7854*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 7856*/ OPC_Scope, 13, /*->7871*/ // 2 children in Scope
/* 7858*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 7860*/ OPC_EmitMergeInputChains1_0,
/* 7861*/ OPC_EmitConvertToTarget, 2,
/* 7863*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 11
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7871*/ /*Scope*/ 13, /*->7885*/
/* 7872*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 7874*/ OPC_EmitMergeInputChains1_0,
/* 7875*/ OPC_EmitConvertToTarget, 2,
/* 7877*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 11
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 7885*/ 0, /*End of Scope*/
/* 7886*/ 0, /*End of Scope*/
/* 7887*/ /*SwitchType*/ 18|128,1/*146*/, MVT::i64,// ->8036
/* 7890*/ OPC_MoveParent,
/* 7891*/ OPC_RecordChild2, // #3 = $rs2
/* 7892*/ OPC_CheckChild2Type, MVT::i64,
/* 7894*/ OPC_Scope, 18, /*->7914*/ // 8 children in Scope
/* 7896*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7898*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7900*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7903*/ OPC_EmitMergeInputChains1_0,
/* 7904*/ OPC_EmitConvertToTarget, 2,
/* 7906*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 17
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7914*/ /*Scope*/ 18, /*->7933*/
/* 7915*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7917*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7919*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7922*/ OPC_EmitMergeInputChains1_0,
/* 7923*/ OPC_EmitConvertToTarget, 2,
/* 7925*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 17
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7933*/ /*Scope*/ 18, /*->7952*/
/* 7934*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 7936*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7938*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7941*/ OPC_EmitMergeInputChains1_0,
/* 7942*/ OPC_EmitConvertToTarget, 2,
/* 7944*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 17
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7952*/ /*Scope*/ 18, /*->7971*/
/* 7953*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 7955*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7957*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #4
/* 7960*/ OPC_EmitMergeInputChains1_0,
/* 7961*/ OPC_EmitConvertToTarget, 2,
/* 7963*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 4, 5,
// Src: (atomic_store (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 17
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7971*/ /*Scope*/ 15, /*->7987*/
/* 7972*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 7974*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7976*/ OPC_EmitMergeInputChains1_0,
/* 7977*/ OPC_EmitConvertToTarget, 2,
/* 7979*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 11
// Dst: (SB GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 7987*/ /*Scope*/ 15, /*->8003*/
/* 7988*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 7990*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 7992*/ OPC_EmitMergeInputChains1_0,
/* 7993*/ OPC_EmitConvertToTarget, 2,
/* 7995*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 11
// Dst: (SH GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8003*/ /*Scope*/ 15, /*->8019*/
/* 8004*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 8006*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8008*/ OPC_EmitMergeInputChains1_0,
/* 8009*/ OPC_EmitConvertToTarget, 2,
/* 8011*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 11
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8019*/ /*Scope*/ 15, /*->8035*/
/* 8020*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 8022*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8024*/ OPC_EmitMergeInputChains1_0,
/* 8025*/ OPC_EmitConvertToTarget, 2,
/* 8027*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 3, 1, 4,
// Src: (atomic_store (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 11
// Dst: (SD GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8035*/ 0, /*End of Scope*/
/* 8036*/ 0, // EndSwitchType
/* 8037*/ 0, // EndSwitchOpcode
/* 8038*/ /*Scope*/ 104|128,3/*488*/, /*->8528*/
/* 8040*/ OPC_RecordChild1, // #1 = $rs1
/* 8041*/ OPC_Scope, 2|128,2/*258*/, /*->8302*/ // 3 children in Scope
/* 8044*/ OPC_RecordChild2, // #2 = $rs2
/* 8045*/ OPC_Scope, 40|128,1/*168*/, /*->8216*/ // 2 children in Scope
/* 8048*/ OPC_CheckChild2Type, MVT::i32,
/* 8050*/ OPC_Scope, 40, /*->8092*/ // 4 children in Scope
/* 8052*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 8054*/ OPC_Scope, 17, /*->8073*/ // 2 children in Scope
/* 8056*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8058*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8061*/ OPC_EmitMergeInputChains1_0,
/* 8062*/ OPC_EmitInteger, MVT::i32, 0,
/* 8065*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8073*/ /*Scope*/ 17, /*->8091*/
/* 8074*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8076*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8079*/ OPC_EmitMergeInputChains1_0,
/* 8080*/ OPC_EmitInteger, MVT::i32, 0,
/* 8083*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8091*/ 0, /*End of Scope*/
/* 8092*/ /*Scope*/ 40, /*->8133*/
/* 8093*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 8095*/ OPC_Scope, 17, /*->8114*/ // 2 children in Scope
/* 8097*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8099*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8102*/ OPC_EmitMergeInputChains1_0,
/* 8103*/ OPC_EmitInteger, MVT::i32, 0,
/* 8106*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8114*/ /*Scope*/ 17, /*->8132*/
/* 8115*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8117*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8120*/ OPC_EmitMergeInputChains1_0,
/* 8121*/ OPC_EmitInteger, MVT::i32, 0,
/* 8124*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8132*/ 0, /*End of Scope*/
/* 8133*/ /*Scope*/ 40, /*->8174*/
/* 8134*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 8136*/ OPC_Scope, 17, /*->8155*/ // 2 children in Scope
/* 8138*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8140*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8143*/ OPC_EmitMergeInputChains1_0,
/* 8144*/ OPC_EmitInteger, MVT::i32, 0,
/* 8147*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8155*/ /*Scope*/ 17, /*->8173*/
/* 8156*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8158*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8161*/ OPC_EmitMergeInputChains1_0,
/* 8162*/ OPC_EmitInteger, MVT::i32, 0,
/* 8165*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8173*/ 0, /*End of Scope*/
/* 8174*/ /*Scope*/ 40, /*->8215*/
/* 8175*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 8177*/ OPC_Scope, 17, /*->8196*/ // 2 children in Scope
/* 8179*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8181*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8184*/ OPC_EmitMergeInputChains1_0,
/* 8185*/ OPC_EmitInteger, MVT::i32, 0,
/* 8188*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 10
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8196*/ /*Scope*/ 17, /*->8214*/
/* 8197*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 8199*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8202*/ OPC_EmitMergeInputChains1_0,
/* 8203*/ OPC_EmitInteger, MVT::i32, 0,
/* 8206*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 10
// Dst: (SD GPR:{ *:[i32] }:$rs2, AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8214*/ 0, /*End of Scope*/
/* 8215*/ 0, /*End of Scope*/
/* 8216*/ /*Scope*/ 84, /*->8301*/
/* 8217*/ OPC_CheckChild2Type, MVT::i64,
/* 8219*/ OPC_Scope, 19, /*->8240*/ // 4 children in Scope
/* 8221*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 8223*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8225*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8228*/ OPC_EmitMergeInputChains1_0,
/* 8229*/ OPC_EmitInteger, MVT::i64, 0,
/* 8232*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 10
// Dst: (SB GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8240*/ /*Scope*/ 19, /*->8260*/
/* 8241*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 8243*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8245*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8248*/ OPC_EmitMergeInputChains1_0,
/* 8249*/ OPC_EmitInteger, MVT::i64, 0,
/* 8252*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 10
// Dst: (SH GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8260*/ /*Scope*/ 19, /*->8280*/
/* 8261*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 8263*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8265*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8268*/ OPC_EmitMergeInputChains1_0,
/* 8269*/ OPC_EmitInteger, MVT::i64, 0,
/* 8272*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 10
// Dst: (SW GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8280*/ /*Scope*/ 19, /*->8300*/
/* 8281*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 8283*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8285*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8288*/ OPC_EmitMergeInputChains1_0,
/* 8289*/ OPC_EmitInteger, MVT::i64, 0,
/* 8292*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 3, 4,
// Src: (atomic_store AddrFI:{ *:[iPTR] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 10
// Dst: (SD GPR:{ *:[i64] }:$rs2, AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8300*/ 0, /*End of Scope*/
/* 8301*/ 0, /*End of Scope*/
/* 8302*/ /*Scope*/ 19|128,1/*147*/, /*->8451*/
/* 8304*/ OPC_CheckChild1Type, MVT::i32,
/* 8306*/ OPC_RecordChild2, // #2 = $rs2
/* 8307*/ OPC_CheckChild2Type, MVT::i32,
/* 8309*/ OPC_Scope, 34, /*->8345*/ // 4 children in Scope
/* 8311*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 8313*/ OPC_Scope, 14, /*->8329*/ // 2 children in Scope
/* 8315*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8317*/ OPC_EmitMergeInputChains1_0,
/* 8318*/ OPC_EmitInteger, MVT::i32, 0,
/* 8321*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8329*/ /*Scope*/ 14, /*->8344*/
/* 8330*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8332*/ OPC_EmitMergeInputChains1_0,
/* 8333*/ OPC_EmitInteger, MVT::i32, 0,
/* 8336*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8344*/ 0, /*End of Scope*/
/* 8345*/ /*Scope*/ 34, /*->8380*/
/* 8346*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 8348*/ OPC_Scope, 14, /*->8364*/ // 2 children in Scope
/* 8350*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8352*/ OPC_EmitMergeInputChains1_0,
/* 8353*/ OPC_EmitInteger, MVT::i32, 0,
/* 8356*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8364*/ /*Scope*/ 14, /*->8379*/
/* 8365*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8367*/ OPC_EmitMergeInputChains1_0,
/* 8368*/ OPC_EmitInteger, MVT::i32, 0,
/* 8371*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8379*/ 0, /*End of Scope*/
/* 8380*/ /*Scope*/ 34, /*->8415*/
/* 8381*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 8383*/ OPC_Scope, 14, /*->8399*/ // 2 children in Scope
/* 8385*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8387*/ OPC_EmitMergeInputChains1_0,
/* 8388*/ OPC_EmitInteger, MVT::i32, 0,
/* 8391*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8399*/ /*Scope*/ 14, /*->8414*/
/* 8400*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8402*/ OPC_EmitMergeInputChains1_0,
/* 8403*/ OPC_EmitInteger, MVT::i32, 0,
/* 8406*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8414*/ 0, /*End of Scope*/
/* 8415*/ /*Scope*/ 34, /*->8450*/
/* 8416*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 8418*/ OPC_Scope, 14, /*->8434*/ // 2 children in Scope
/* 8420*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8422*/ OPC_EmitMergeInputChains1_0,
/* 8423*/ OPC_EmitInteger, MVT::i32, 0,
/* 8426*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 4
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8434*/ /*Scope*/ 14, /*->8449*/
/* 8435*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 8437*/ OPC_EmitMergeInputChains1_0,
/* 8438*/ OPC_EmitInteger, MVT::i32, 0,
/* 8441*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 4
// Dst: (SD GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 8449*/ 0, /*End of Scope*/
/* 8450*/ 0, /*End of Scope*/
/* 8451*/ /*Scope*/ 75, /*->8527*/
/* 8452*/ OPC_CheckChild1Type, MVT::i64,
/* 8454*/ OPC_RecordChild2, // #2 = $rs2
/* 8455*/ OPC_CheckChild2Type, MVT::i64,
/* 8457*/ OPC_Scope, 16, /*->8475*/ // 4 children in Scope
/* 8459*/ OPC_CheckPredicate, 5, // Predicate_atomic_store_8
/* 8461*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8463*/ OPC_EmitMergeInputChains1_0,
/* 8464*/ OPC_EmitInteger, MVT::i64, 0,
/* 8467*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SB), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_8>> - Complexity = 4
// Dst: (SB GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8475*/ /*Scope*/ 16, /*->8492*/
/* 8476*/ OPC_CheckPredicate, 7, // Predicate_atomic_store_16
/* 8478*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8480*/ OPC_EmitMergeInputChains1_0,
/* 8481*/ OPC_EmitInteger, MVT::i64, 0,
/* 8484*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SH), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_16>> - Complexity = 4
// Dst: (SH GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8492*/ /*Scope*/ 16, /*->8509*/
/* 8493*/ OPC_CheckPredicate, 10, // Predicate_atomic_store_32
/* 8495*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8497*/ OPC_EmitMergeInputChains1_0,
/* 8498*/ OPC_EmitInteger, MVT::i64, 0,
/* 8501*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SW), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_32>> - Complexity = 4
// Dst: (SW GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8509*/ /*Scope*/ 16, /*->8526*/
/* 8510*/ OPC_CheckPredicate, 14, // Predicate_atomic_store_64
/* 8512*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8514*/ OPC_EmitMergeInputChains1_0,
/* 8515*/ OPC_EmitInteger, MVT::i64, 0,
/* 8518*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SD), 0|OPFL_Chain|OPFL_MemRefs,
3/*#Ops*/, 2, 1, 3,
// Src: (atomic_store GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_store_64>> - Complexity = 4
// Dst: (SD GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 8526*/ 0, /*End of Scope*/
/* 8527*/ 0, /*End of Scope*/
/* 8528*/ 0, /*End of Scope*/
/* 8529*/ /*SwitchOpcode*/ 64|128,9/*1216*/, TARGET_VAL(ISD::ATOMIC_LOAD),// ->9749
/* 8533*/ OPC_RecordMemRef,
/* 8534*/ OPC_RecordNode, // #0 = 'atomic_load' chained node
/* 8535*/ OPC_Scope, 86|128,5/*726*/, /*->9264*/ // 2 children in Scope
/* 8538*/ OPC_MoveChild1,
/* 8539*/ OPC_SwitchOpcode /*2 cases */, 4|128,2/*260*/, TARGET_VAL(ISD::OR),// ->8804
/* 8544*/ OPC_RecordChild0, // #1 = $rs1
/* 8545*/ OPC_RecordChild1, // #2 = $imm12
/* 8546*/ OPC_MoveChild1,
/* 8547*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 8550*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 8552*/ OPC_MoveParent,
/* 8553*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 8555*/ OPC_SwitchType /*2 cases */, 33|128,1/*161*/, MVT::i32,// ->8720
/* 8559*/ OPC_MoveParent,
/* 8560*/ OPC_CheckType, MVT::i32,
/* 8562*/ OPC_Scope, 38, /*->8602*/ // 4 children in Scope
/* 8564*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 8566*/ OPC_Scope, 16, /*->8584*/ // 2 children in Scope
/* 8568*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8570*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8573*/ OPC_EmitMergeInputChains1_0,
/* 8574*/ OPC_EmitConvertToTarget, 2,
/* 8576*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8584*/ /*Scope*/ 16, /*->8601*/
/* 8585*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8587*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8590*/ OPC_EmitMergeInputChains1_0,
/* 8591*/ OPC_EmitConvertToTarget, 2,
/* 8593*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_8>> - Complexity = 18
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8601*/ 0, /*End of Scope*/
/* 8602*/ /*Scope*/ 38, /*->8641*/
/* 8603*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 8605*/ OPC_Scope, 16, /*->8623*/ // 2 children in Scope
/* 8607*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8609*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8612*/ OPC_EmitMergeInputChains1_0,
/* 8613*/ OPC_EmitConvertToTarget, 2,
/* 8615*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8623*/ /*Scope*/ 16, /*->8640*/
/* 8624*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8626*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8629*/ OPC_EmitMergeInputChains1_0,
/* 8630*/ OPC_EmitConvertToTarget, 2,
/* 8632*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_16>> - Complexity = 18
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8640*/ 0, /*End of Scope*/
/* 8641*/ /*Scope*/ 38, /*->8680*/
/* 8642*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 8644*/ OPC_Scope, 16, /*->8662*/ // 2 children in Scope
/* 8646*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8648*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8651*/ OPC_EmitMergeInputChains1_0,
/* 8652*/ OPC_EmitConvertToTarget, 2,
/* 8654*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8662*/ /*Scope*/ 16, /*->8679*/
/* 8663*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8665*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8668*/ OPC_EmitMergeInputChains1_0,
/* 8669*/ OPC_EmitConvertToTarget, 2,
/* 8671*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_32>> - Complexity = 18
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8679*/ 0, /*End of Scope*/
/* 8680*/ /*Scope*/ 38, /*->8719*/
/* 8681*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 8683*/ OPC_Scope, 16, /*->8701*/ // 2 children in Scope
/* 8685*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8687*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8690*/ OPC_EmitMergeInputChains1_0,
/* 8691*/ OPC_EmitConvertToTarget, 2,
/* 8693*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_64>> - Complexity = 18
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8701*/ /*Scope*/ 16, /*->8718*/
/* 8702*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 8704*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8707*/ OPC_EmitMergeInputChains1_0,
/* 8708*/ OPC_EmitConvertToTarget, 2,
/* 8710*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (or:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_64>> - Complexity = 18
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8718*/ 0, /*End of Scope*/
/* 8719*/ 0, /*End of Scope*/
/* 8720*/ /*SwitchType*/ 81, MVT::i64,// ->8803
/* 8722*/ OPC_MoveParent,
/* 8723*/ OPC_CheckType, MVT::i64,
/* 8725*/ OPC_Scope, 18, /*->8745*/ // 4 children in Scope
/* 8727*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 8729*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 8731*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8734*/ OPC_EmitMergeInputChains1_0,
/* 8735*/ OPC_EmitConvertToTarget, 2,
/* 8737*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_8>> - Complexity = 18
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8745*/ /*Scope*/ 18, /*->8764*/
/* 8746*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 8748*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8750*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8753*/ OPC_EmitMergeInputChains1_0,
/* 8754*/ OPC_EmitConvertToTarget, 2,
/* 8756*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_16>> - Complexity = 18
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8764*/ /*Scope*/ 18, /*->8783*/
/* 8765*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 8767*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8769*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8772*/ OPC_EmitMergeInputChains1_0,
/* 8773*/ OPC_EmitConvertToTarget, 2,
/* 8775*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_32>> - Complexity = 18
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8783*/ /*Scope*/ 18, /*->8802*/
/* 8784*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 8786*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 8788*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8791*/ OPC_EmitMergeInputChains1_0,
/* 8792*/ OPC_EmitConvertToTarget, 2,
/* 8794*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (or:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>>)<<P:Predicate_atomic_load_64>> - Complexity = 18
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 8802*/ 0, /*End of Scope*/
/* 8803*/ 0, // EndSwitchType
/* 8804*/ /*SwitchOpcode*/ 71|128,3/*455*/, TARGET_VAL(ISD::ADD),// ->9263
/* 8808*/ OPC_RecordChild0, // #1 = $rs1
/* 8809*/ OPC_RecordChild1, // #2 = $imm12
/* 8810*/ OPC_MoveChild1,
/* 8811*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 8814*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 8816*/ OPC_MoveParent,
/* 8817*/ OPC_SwitchType /*2 cases */, 37|128,2/*293*/, MVT::i32,// ->9114
/* 8821*/ OPC_MoveParent,
/* 8822*/ OPC_CheckType, MVT::i32,
/* 8824*/ OPC_Scope, 38, /*->8864*/ // 8 children in Scope
/* 8826*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 8828*/ OPC_Scope, 16, /*->8846*/ // 2 children in Scope
/* 8830*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8832*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8835*/ OPC_EmitMergeInputChains1_0,
/* 8836*/ OPC_EmitConvertToTarget, 2,
/* 8838*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8846*/ /*Scope*/ 16, /*->8863*/
/* 8847*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8849*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8852*/ OPC_EmitMergeInputChains1_0,
/* 8853*/ OPC_EmitConvertToTarget, 2,
/* 8855*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 17
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8863*/ 0, /*End of Scope*/
/* 8864*/ /*Scope*/ 38, /*->8903*/
/* 8865*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 8867*/ OPC_Scope, 16, /*->8885*/ // 2 children in Scope
/* 8869*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8871*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8874*/ OPC_EmitMergeInputChains1_0,
/* 8875*/ OPC_EmitConvertToTarget, 2,
/* 8877*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8885*/ /*Scope*/ 16, /*->8902*/
/* 8886*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8888*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8891*/ OPC_EmitMergeInputChains1_0,
/* 8892*/ OPC_EmitConvertToTarget, 2,
/* 8894*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 17
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8902*/ 0, /*End of Scope*/
/* 8903*/ /*Scope*/ 38, /*->8942*/
/* 8904*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 8906*/ OPC_Scope, 16, /*->8924*/ // 2 children in Scope
/* 8908*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8910*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8913*/ OPC_EmitMergeInputChains1_0,
/* 8914*/ OPC_EmitConvertToTarget, 2,
/* 8916*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8924*/ /*Scope*/ 16, /*->8941*/
/* 8925*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 8927*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8930*/ OPC_EmitMergeInputChains1_0,
/* 8931*/ OPC_EmitConvertToTarget, 2,
/* 8933*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 17
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8941*/ 0, /*End of Scope*/
/* 8942*/ /*Scope*/ 38, /*->8981*/
/* 8943*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 8945*/ OPC_Scope, 16, /*->8963*/ // 2 children in Scope
/* 8947*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8949*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8952*/ OPC_EmitMergeInputChains1_0,
/* 8953*/ OPC_EmitConvertToTarget, 2,
/* 8955*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 17
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8963*/ /*Scope*/ 16, /*->8980*/
/* 8964*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 8966*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 8969*/ OPC_EmitMergeInputChains1_0,
/* 8970*/ OPC_EmitConvertToTarget, 2,
/* 8972*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 17
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8980*/ 0, /*End of Scope*/
/* 8981*/ /*Scope*/ 32, /*->9014*/
/* 8982*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 8984*/ OPC_Scope, 13, /*->8999*/ // 2 children in Scope
/* 8986*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 8988*/ OPC_EmitMergeInputChains1_0,
/* 8989*/ OPC_EmitConvertToTarget, 2,
/* 8991*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 8999*/ /*Scope*/ 13, /*->9013*/
/* 9000*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9002*/ OPC_EmitMergeInputChains1_0,
/* 9003*/ OPC_EmitConvertToTarget, 2,
/* 9005*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 11
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9013*/ 0, /*End of Scope*/
/* 9014*/ /*Scope*/ 32, /*->9047*/
/* 9015*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9017*/ OPC_Scope, 13, /*->9032*/ // 2 children in Scope
/* 9019*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9021*/ OPC_EmitMergeInputChains1_0,
/* 9022*/ OPC_EmitConvertToTarget, 2,
/* 9024*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9032*/ /*Scope*/ 13, /*->9046*/
/* 9033*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9035*/ OPC_EmitMergeInputChains1_0,
/* 9036*/ OPC_EmitConvertToTarget, 2,
/* 9038*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 11
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9046*/ 0, /*End of Scope*/
/* 9047*/ /*Scope*/ 32, /*->9080*/
/* 9048*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9050*/ OPC_Scope, 13, /*->9065*/ // 2 children in Scope
/* 9052*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9054*/ OPC_EmitMergeInputChains1_0,
/* 9055*/ OPC_EmitConvertToTarget, 2,
/* 9057*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9065*/ /*Scope*/ 13, /*->9079*/
/* 9066*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9068*/ OPC_EmitMergeInputChains1_0,
/* 9069*/ OPC_EmitConvertToTarget, 2,
/* 9071*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 11
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9079*/ 0, /*End of Scope*/
/* 9080*/ /*Scope*/ 32, /*->9113*/
/* 9081*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9083*/ OPC_Scope, 13, /*->9098*/ // 2 children in Scope
/* 9085*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9087*/ OPC_EmitMergeInputChains1_0,
/* 9088*/ OPC_EmitConvertToTarget, 2,
/* 9090*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 11
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9098*/ /*Scope*/ 13, /*->9112*/
/* 9099*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 9101*/ OPC_EmitMergeInputChains1_0,
/* 9102*/ OPC_EmitConvertToTarget, 2,
/* 9104*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i32] } (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 11
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9112*/ 0, /*End of Scope*/
/* 9113*/ 0, /*End of Scope*/
/* 9114*/ /*SwitchType*/ 17|128,1/*145*/, MVT::i64,// ->9262
/* 9117*/ OPC_MoveParent,
/* 9118*/ OPC_CheckType, MVT::i64,
/* 9120*/ OPC_Scope, 18, /*->9140*/ // 8 children in Scope
/* 9122*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 9124*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9126*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 9129*/ OPC_EmitMergeInputChains1_0,
/* 9130*/ OPC_EmitConvertToTarget, 2,
/* 9132*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 17
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9140*/ /*Scope*/ 18, /*->9159*/
/* 9141*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9143*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9145*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 9148*/ OPC_EmitMergeInputChains1_0,
/* 9149*/ OPC_EmitConvertToTarget, 2,
/* 9151*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 17
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9159*/ /*Scope*/ 18, /*->9178*/
/* 9160*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9162*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9164*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 9167*/ OPC_EmitMergeInputChains1_0,
/* 9168*/ OPC_EmitConvertToTarget, 2,
/* 9170*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 17
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9178*/ /*Scope*/ 18, /*->9197*/
/* 9179*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9181*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9183*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #3
/* 9186*/ OPC_EmitMergeInputChains1_0,
/* 9187*/ OPC_EmitConvertToTarget, 2,
/* 9189*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 17
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9197*/ /*Scope*/ 15, /*->9213*/
/* 9198*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 9200*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9202*/ OPC_EmitMergeInputChains1_0,
/* 9203*/ OPC_EmitConvertToTarget, 2,
/* 9205*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_8>> - Complexity = 11
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9213*/ /*Scope*/ 15, /*->9229*/
/* 9214*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9216*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9218*/ OPC_EmitMergeInputChains1_0,
/* 9219*/ OPC_EmitConvertToTarget, 2,
/* 9221*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_16>> - Complexity = 11
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9229*/ /*Scope*/ 15, /*->9245*/
/* 9230*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9232*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9234*/ OPC_EmitMergeInputChains1_0,
/* 9235*/ OPC_EmitConvertToTarget, 2,
/* 9237*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_32>> - Complexity = 11
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9245*/ /*Scope*/ 15, /*->9261*/
/* 9246*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9248*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9250*/ OPC_EmitMergeInputChains1_0,
/* 9251*/ OPC_EmitConvertToTarget, 2,
/* 9253*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 3,
// Src: (atomic_load:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))<<P:Predicate_atomic_load_64>> - Complexity = 11
// Dst: (LD:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9261*/ 0, /*End of Scope*/
/* 9262*/ 0, // EndSwitchType
/* 9263*/ 0, // EndSwitchOpcode
/* 9264*/ /*Scope*/ 98|128,3/*482*/, /*->9748*/
/* 9266*/ OPC_RecordChild1, // #1 = $rs1
/* 9267*/ OPC_Scope, 63, /*->9332*/ // 6 children in Scope
/* 9269*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 9271*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->9312
/* 9274*/ OPC_Scope, 17, /*->9293*/ // 2 children in Scope
/* 9276*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9278*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9281*/ OPC_EmitMergeInputChains1_0,
/* 9282*/ OPC_EmitInteger, MVT::i32, 0,
/* 9285*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9293*/ /*Scope*/ 17, /*->9311*/
/* 9294*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9296*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9299*/ OPC_EmitMergeInputChains1_0,
/* 9300*/ OPC_EmitInteger, MVT::i32, 0,
/* 9303*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 10
// Dst: (LB:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9311*/ 0, /*End of Scope*/
/* 9312*/ /*SwitchType*/ 17, MVT::i64,// ->9331
/* 9314*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 9316*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9319*/ OPC_EmitMergeInputChains1_0,
/* 9320*/ OPC_EmitInteger, MVT::i64, 0,
/* 9323*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 10
// Dst: (LB:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9331*/ 0, // EndSwitchType
/* 9332*/ /*Scope*/ 63, /*->9396*/
/* 9333*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9335*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->9376
/* 9338*/ OPC_Scope, 17, /*->9357*/ // 2 children in Scope
/* 9340*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9342*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9345*/ OPC_EmitMergeInputChains1_0,
/* 9346*/ OPC_EmitInteger, MVT::i32, 0,
/* 9349*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9357*/ /*Scope*/ 17, /*->9375*/
/* 9358*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9360*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9363*/ OPC_EmitMergeInputChains1_0,
/* 9364*/ OPC_EmitInteger, MVT::i32, 0,
/* 9367*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 10
// Dst: (LH:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9375*/ 0, /*End of Scope*/
/* 9376*/ /*SwitchType*/ 17, MVT::i64,// ->9395
/* 9378*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 9380*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9383*/ OPC_EmitMergeInputChains1_0,
/* 9384*/ OPC_EmitInteger, MVT::i64, 0,
/* 9387*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 10
// Dst: (LH:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9395*/ 0, // EndSwitchType
/* 9396*/ /*Scope*/ 63, /*->9460*/
/* 9397*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9399*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->9440
/* 9402*/ OPC_Scope, 17, /*->9421*/ // 2 children in Scope
/* 9404*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9406*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9409*/ OPC_EmitMergeInputChains1_0,
/* 9410*/ OPC_EmitInteger, MVT::i32, 0,
/* 9413*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9421*/ /*Scope*/ 17, /*->9439*/
/* 9422*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9424*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9427*/ OPC_EmitMergeInputChains1_0,
/* 9428*/ OPC_EmitInteger, MVT::i32, 0,
/* 9431*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 10
// Dst: (LW:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9439*/ 0, /*End of Scope*/
/* 9440*/ /*SwitchType*/ 17, MVT::i64,// ->9459
/* 9442*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 9444*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9447*/ OPC_EmitMergeInputChains1_0,
/* 9448*/ OPC_EmitInteger, MVT::i64, 0,
/* 9451*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 10
// Dst: (LW:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9459*/ 0, // EndSwitchType
/* 9460*/ /*Scope*/ 63, /*->9524*/
/* 9461*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9463*/ OPC_SwitchType /*2 cases */, 38, MVT::i32,// ->9504
/* 9466*/ OPC_Scope, 17, /*->9485*/ // 2 children in Scope
/* 9468*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9470*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9473*/ OPC_EmitMergeInputChains1_0,
/* 9474*/ OPC_EmitInteger, MVT::i32, 0,
/* 9477*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 10
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9485*/ /*Scope*/ 17, /*->9503*/
/* 9486*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 9488*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9491*/ OPC_EmitMergeInputChains1_0,
/* 9492*/ OPC_EmitInteger, MVT::i32, 0,
/* 9495*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i32] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 10
// Dst: (LD:{ *:[i32] } AddrFI:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9503*/ 0, /*End of Scope*/
/* 9504*/ /*SwitchType*/ 17, MVT::i64,// ->9523
/* 9506*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("64bit"))
/* 9508*/ OPC_CheckComplexPat, /*CP*/0, /*#*/1, // SelectAddrFI:$rs1 #2
/* 9511*/ OPC_EmitMergeInputChains1_0,
/* 9512*/ OPC_EmitInteger, MVT::i64, 0,
/* 9515*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (atomic_load:{ *:[i64] } AddrFI:{ *:[iPTR] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 10
// Dst: (LD:{ *:[i64] } AddrFI:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9523*/ 0, // EndSwitchType
/* 9524*/ /*Scope*/ 18|128,1/*146*/, /*->9672*/
/* 9526*/ OPC_CheckChild1Type, MVT::i32,
/* 9528*/ OPC_CheckType, MVT::i32,
/* 9530*/ OPC_Scope, 34, /*->9566*/ // 4 children in Scope
/* 9532*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 9534*/ OPC_Scope, 14, /*->9550*/ // 2 children in Scope
/* 9536*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9538*/ OPC_EmitMergeInputChains1_0,
/* 9539*/ OPC_EmitInteger, MVT::i32, 0,
/* 9542*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9550*/ /*Scope*/ 14, /*->9565*/
/* 9551*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9553*/ OPC_EmitMergeInputChains1_0,
/* 9554*/ OPC_EmitInteger, MVT::i32, 0,
/* 9557*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 4
// Dst: (LB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9565*/ 0, /*End of Scope*/
/* 9566*/ /*Scope*/ 34, /*->9601*/
/* 9567*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9569*/ OPC_Scope, 14, /*->9585*/ // 2 children in Scope
/* 9571*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9573*/ OPC_EmitMergeInputChains1_0,
/* 9574*/ OPC_EmitInteger, MVT::i32, 0,
/* 9577*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9585*/ /*Scope*/ 14, /*->9600*/
/* 9586*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9588*/ OPC_EmitMergeInputChains1_0,
/* 9589*/ OPC_EmitInteger, MVT::i32, 0,
/* 9592*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 4
// Dst: (LH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9600*/ 0, /*End of Scope*/
/* 9601*/ /*Scope*/ 34, /*->9636*/
/* 9602*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9604*/ OPC_Scope, 14, /*->9620*/ // 2 children in Scope
/* 9606*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9608*/ OPC_EmitMergeInputChains1_0,
/* 9609*/ OPC_EmitInteger, MVT::i32, 0,
/* 9612*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9620*/ /*Scope*/ 14, /*->9635*/
/* 9621*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 9623*/ OPC_EmitMergeInputChains1_0,
/* 9624*/ OPC_EmitInteger, MVT::i32, 0,
/* 9627*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 4
// Dst: (LW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9635*/ 0, /*End of Scope*/
/* 9636*/ /*Scope*/ 34, /*->9671*/
/* 9637*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9639*/ OPC_Scope, 14, /*->9655*/ // 2 children in Scope
/* 9641*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 9643*/ OPC_EmitMergeInputChains1_0,
/* 9644*/ OPC_EmitInteger, MVT::i32, 0,
/* 9647*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 4
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9655*/ /*Scope*/ 14, /*->9670*/
/* 9656*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 9658*/ OPC_EmitMergeInputChains1_0,
/* 9659*/ OPC_EmitInteger, MVT::i32, 0,
/* 9662*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 4
// Dst: (LD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 9670*/ 0, /*End of Scope*/
/* 9671*/ 0, /*End of Scope*/
/* 9672*/ /*Scope*/ 74, /*->9747*/
/* 9673*/ OPC_CheckChild1Type, MVT::i64,
/* 9675*/ OPC_CheckType, MVT::i64,
/* 9677*/ OPC_Scope, 16, /*->9695*/ // 4 children in Scope
/* 9679*/ OPC_CheckPredicate, 5, // Predicate_atomic_load_8
/* 9681*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9683*/ OPC_EmitMergeInputChains1_0,
/* 9684*/ OPC_EmitInteger, MVT::i64, 0,
/* 9687*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LB), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_atomic_load_8>> - Complexity = 4
// Dst: (LB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9695*/ /*Scope*/ 16, /*->9712*/
/* 9696*/ OPC_CheckPredicate, 7, // Predicate_atomic_load_16
/* 9698*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9700*/ OPC_EmitMergeInputChains1_0,
/* 9701*/ OPC_EmitInteger, MVT::i64, 0,
/* 9704*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LH), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_atomic_load_16>> - Complexity = 4
// Dst: (LH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9712*/ /*Scope*/ 16, /*->9729*/
/* 9713*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_32
/* 9715*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9717*/ OPC_EmitMergeInputChains1_0,
/* 9718*/ OPC_EmitInteger, MVT::i64, 0,
/* 9721*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LW), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_atomic_load_32>> - Complexity = 4
// Dst: (LW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9729*/ /*Scope*/ 16, /*->9746*/
/* 9730*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_64
/* 9732*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9734*/ OPC_EmitMergeInputChains1_0,
/* 9735*/ OPC_EmitInteger, MVT::i64, 0,
/* 9738*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LD), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_atomic_load_64>> - Complexity = 4
// Dst: (LD:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 9746*/ 0, /*End of Scope*/
/* 9747*/ 0, /*End of Scope*/
/* 9748*/ 0, /*End of Scope*/
/* 9749*/ /*SwitchOpcode*/ 1|128,1/*129*/, TARGET_VAL(ISD::OR),// ->9882
/* 9753*/ OPC_RecordChild0, // #0 = $Rs
/* 9754*/ OPC_RecordChild1, // #1 = $imm12
/* 9755*/ OPC_Scope, 86, /*->9843*/ // 3 children in Scope
/* 9757*/ OPC_MoveChild1,
/* 9758*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 9761*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 9763*/ OPC_MoveParent,
/* 9764*/ OPC_SwitchType /*2 cases */, 61, MVT::i32,// ->9828
/* 9767*/ OPC_Scope, 34, /*->9803*/ // 3 children in Scope
/* 9769*/ OPC_CheckPredicate, 2, // Predicate_IsOrAdd
/* 9771*/ OPC_Scope, 15, /*->9788*/ // 2 children in Scope
/* 9773*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 9775*/ OPC_CheckComplexPat, /*CP*/0, /*#*/0, // SelectAddrFI:$Rs #2
/* 9778*/ OPC_EmitConvertToTarget, 1,
/* 9780*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (or:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>> - Complexity = 14
// Dst: (ADDI:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9788*/ /*Scope*/ 13, /*->9802*/
/* 9789*/ OPC_CheckComplexPat, /*CP*/0, /*#*/0, // SelectAddrFI:$Rs #2
/* 9792*/ OPC_EmitConvertToTarget, 1,
/* 9794*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (or:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)<<P:Predicate_IsOrAdd>> - Complexity = 14
// Dst: (ADDI:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9802*/ 0, /*End of Scope*/
/* 9803*/ /*Scope*/ 12, /*->9816*/
/* 9804*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 9806*/ OPC_EmitConvertToTarget, 1,
/* 9808*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9816*/ /*Scope*/ 10, /*->9827*/
/* 9817*/ OPC_EmitConvertToTarget, 1,
/* 9819*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 9827*/ 0, /*End of Scope*/
/* 9828*/ /*SwitchType*/ 12, MVT::i64,// ->9842
/* 9830*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 9832*/ OPC_EmitConvertToTarget, 1,
/* 9834*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ORI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ORI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 9842*/ 0, // EndSwitchType
/* 9843*/ /*Scope*/ 24, /*->9868*/
/* 9844*/ OPC_CheckType, MVT::i32,
/* 9846*/ OPC_Scope, 10, /*->9858*/ // 2 children in Scope
/* 9848*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 9850*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::OR), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (OR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 9858*/ /*Scope*/ 8, /*->9867*/
/* 9859*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::OR), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (OR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 9867*/ 0, /*End of Scope*/
/* 9868*/ /*Scope*/ 12, /*->9881*/
/* 9869*/ OPC_CheckType, MVT::i64,
/* 9871*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 9873*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::OR), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (OR:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 9881*/ 0, /*End of Scope*/
/* 9882*/ /*SwitchOpcode*/ 8|128,3/*392*/, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10278
/* 9886*/ OPC_Scope, 113|128,2/*369*/, /*->10258*/ // 2 children in Scope
/* 9889*/ OPC_MoveChild0,
/* 9890*/ OPC_Scope, 34, /*->9926*/ // 9 children in Scope
/* 9892*/ OPC_CheckOpcode, TARGET_VAL(ISD::SREM),
/* 9895*/ OPC_MoveChild0,
/* 9896*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertSext),
/* 9899*/ OPC_RecordChild0, // #0 = $rs1
/* 9900*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 9902*/ OPC_MoveParent,
/* 9903*/ OPC_MoveChild1,
/* 9904*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertSext),
/* 9907*/ OPC_RecordChild0, // #1 = $rs2
/* 9908*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 9910*/ OPC_MoveParent,
/* 9911*/ OPC_MoveParent,
/* 9912*/ OPC_MoveChild1,
/* 9913*/ OPC_CheckValueType, MVT::i32,
/* 9915*/ OPC_MoveParent,
/* 9916*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9918*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (srem:{ *:[i64] } (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertsexti32>>, (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertsexti32>>), i32:{ *:[Other] }) - Complexity = 14
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 9926*/ /*Scope*/ 32, /*->9959*/
/* 9927*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 9933*/ OPC_MoveChild0,
/* 9934*/ OPC_CheckOpcode, TARGET_VAL(ISD::FP_TO_UINT),
/* 9937*/ OPC_RecordChild0, // #0 = $rs1
/* 9938*/ OPC_CheckChild0Type, MVT::f64,
/* 9940*/ OPC_MoveParent,
/* 9941*/ OPC_MoveParent,
/* 9942*/ OPC_MoveChild1,
/* 9943*/ OPC_CheckValueType, MVT::i32,
/* 9945*/ OPC_MoveParent,
/* 9946*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9948*/ OPC_EmitInteger, MVT::i64, 1,
/* 9951*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (and:{ *:[i64] } (fp_to_uint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1), 4294967295:{ *:[i64] }), i32:{ *:[Other] }) - Complexity = 14
// Dst: (FCVT_WU_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 9959*/ /*Scope*/ 96, /*->10056*/
/* 9960*/ OPC_CheckOpcode, TARGET_VAL(ISD::SREM),
/* 9963*/ OPC_MoveChild0,
/* 9964*/ OPC_SwitchOpcode /*2 cases */, 55, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10023
/* 9968*/ OPC_RecordChild0, // #0 = $rs1
/* 9969*/ OPC_MoveChild1,
/* 9970*/ OPC_CheckValueType, MVT::i32,
/* 9972*/ OPC_MoveParent,
/* 9973*/ OPC_MoveParent,
/* 9974*/ OPC_MoveChild1,
/* 9975*/ OPC_SwitchOpcode /*2 cases */, 19, TARGET_VAL(ISD::AssertSext),// ->9998
/* 9979*/ OPC_RecordChild0, // #1 = $rs2
/* 9980*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 9982*/ OPC_MoveParent,
/* 9983*/ OPC_MoveParent,
/* 9984*/ OPC_MoveChild1,
/* 9985*/ OPC_CheckValueType, MVT::i32,
/* 9987*/ OPC_MoveParent,
/* 9988*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 9990*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (srem:{ *:[i64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }), (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertsexti32>>), i32:{ *:[Other] }) - Complexity = 13
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 9998*/ /*SwitchOpcode*/ 21, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10022
/* 10001*/ OPC_RecordChild0, // #1 = $rs2
/* 10002*/ OPC_MoveChild1,
/* 10003*/ OPC_CheckValueType, MVT::i32,
/* 10005*/ OPC_MoveParent,
/* 10006*/ OPC_MoveParent,
/* 10007*/ OPC_MoveParent,
/* 10008*/ OPC_MoveChild1,
/* 10009*/ OPC_CheckValueType, MVT::i32,
/* 10011*/ OPC_MoveParent,
/* 10012*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10014*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (srem:{ *:[i64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }), (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs2, i32:{ *:[Other] })), i32:{ *:[Other] }) - Complexity = 12
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10022*/ 0, // EndSwitchOpcode
/* 10023*/ /*SwitchOpcode*/ 29, TARGET_VAL(ISD::AssertSext),// ->10055
/* 10026*/ OPC_RecordChild0, // #0 = $rs1
/* 10027*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 10029*/ OPC_MoveParent,
/* 10030*/ OPC_MoveChild1,
/* 10031*/ OPC_CheckOpcode, TARGET_VAL(ISD::SIGN_EXTEND_INREG),
/* 10034*/ OPC_RecordChild0, // #1 = $rs2
/* 10035*/ OPC_MoveChild1,
/* 10036*/ OPC_CheckValueType, MVT::i32,
/* 10038*/ OPC_MoveParent,
/* 10039*/ OPC_MoveParent,
/* 10040*/ OPC_MoveParent,
/* 10041*/ OPC_MoveChild1,
/* 10042*/ OPC_CheckValueType, MVT::i32,
/* 10044*/ OPC_MoveParent,
/* 10045*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10047*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (srem:{ *:[i64] } (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertsexti32>>, (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs2, i32:{ *:[Other] })), i32:{ *:[Other] }) - Complexity = 13
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10055*/ 0, // EndSwitchOpcode
/* 10056*/ /*Scope*/ 48, /*->10105*/
/* 10057*/ OPC_CheckOpcode, TARGET_VAL(ISD::ADD),
/* 10060*/ OPC_RecordChild0, // #0 = $rs1
/* 10061*/ OPC_RecordChild1, // #1 = $imm12
/* 10062*/ OPC_Scope, 24, /*->10088*/ // 2 children in Scope
/* 10064*/ OPC_MoveChild1,
/* 10065*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 10068*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 10070*/ OPC_MoveParent,
/* 10071*/ OPC_MoveParent,
/* 10072*/ OPC_MoveChild1,
/* 10073*/ OPC_CheckValueType, MVT::i32,
/* 10075*/ OPC_MoveParent,
/* 10076*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10078*/ OPC_EmitConvertToTarget, 1,
/* 10080*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDIW), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (sext_inreg:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), i32:{ *:[Other] }) - Complexity = 10
// Dst: (ADDIW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 10088*/ /*Scope*/ 15, /*->10104*/
/* 10089*/ OPC_MoveParent,
/* 10090*/ OPC_MoveChild1,
/* 10091*/ OPC_CheckValueType, MVT::i32,
/* 10093*/ OPC_MoveParent,
/* 10094*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10096*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), i32:{ *:[Other] }) - Complexity = 6
// Dst: (ADDW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10104*/ 0, /*End of Scope*/
/* 10105*/ /*Scope*/ 31, /*->10137*/
/* 10106*/ OPC_CheckOpcode, TARGET_VAL(ISD::SHL),
/* 10109*/ OPC_RecordChild0, // #0 = $rs1
/* 10110*/ OPC_RecordChild1, // #1 = $shamt
/* 10111*/ OPC_MoveChild1,
/* 10112*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 10115*/ OPC_CheckPredicate, 15, // Predicate_uimm5
/* 10117*/ OPC_CheckType, MVT::i64,
/* 10119*/ OPC_MoveParent,
/* 10120*/ OPC_MoveParent,
/* 10121*/ OPC_MoveChild1,
/* 10122*/ OPC_CheckValueType, MVT::i32,
/* 10124*/ OPC_MoveParent,
/* 10125*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10127*/ OPC_EmitConvertToTarget, 1,
/* 10129*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLIW), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (sext_inreg:{ *:[i64] } (shl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimm5>>:$shamt), i32:{ *:[Other] }) - Complexity = 10
// Dst: (SLLIW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimm5>>:$shamt)
/* 10137*/ /*Scope*/ 58, /*->10196*/
/* 10138*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 10141*/ OPC_MoveChild0,
/* 10142*/ OPC_CheckOpcode, TARGET_VAL(ISD::FP_TO_UINT),
/* 10145*/ OPC_RecordChild0, // #0 = $rs1
/* 10146*/ OPC_Scope, 23, /*->10171*/ // 2 children in Scope
/* 10148*/ OPC_CheckChild0Type, MVT::f32,
/* 10150*/ OPC_MoveParent,
/* 10151*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 10153*/ OPC_MoveParent,
/* 10154*/ OPC_MoveChild1,
/* 10155*/ OPC_CheckValueType, MVT::i32,
/* 10157*/ OPC_MoveParent,
/* 10158*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10160*/ OPC_EmitInteger, MVT::i64, 1,
/* 10163*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (assertzext:{ *:[i64] } (fp_to_uint:{ *:[i64] } FPR32:{ *:[f32] }:$rs1))<<P:Predicate_assertzexti32>>, i32:{ *:[Other] }) - Complexity = 10
// Dst: (FCVT_WU_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, 1:{ *:[i64] })
/* 10171*/ /*Scope*/ 23, /*->10195*/
/* 10172*/ OPC_CheckChild0Type, MVT::f64,
/* 10174*/ OPC_MoveParent,
/* 10175*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 10177*/ OPC_MoveParent,
/* 10178*/ OPC_MoveChild1,
/* 10179*/ OPC_CheckValueType, MVT::i32,
/* 10181*/ OPC_MoveParent,
/* 10182*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10184*/ OPC_EmitInteger, MVT::i64, 1,
/* 10187*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (assertzext:{ *:[i64] } (fp_to_uint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1))<<P:Predicate_assertzexti32>>, i32:{ *:[Other] }) - Complexity = 10
// Dst: (FCVT_WU_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 10195*/ 0, /*End of Scope*/
/* 10196*/ /*Scope*/ 20, /*->10217*/
/* 10197*/ OPC_CheckOpcode, TARGET_VAL(ISD::SUB),
/* 10200*/ OPC_RecordChild0, // #0 = $rs1
/* 10201*/ OPC_RecordChild1, // #1 = $rs2
/* 10202*/ OPC_MoveParent,
/* 10203*/ OPC_MoveChild1,
/* 10204*/ OPC_CheckValueType, MVT::i32,
/* 10206*/ OPC_MoveParent,
/* 10207*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10209*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SUBW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (sub:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), i32:{ *:[Other] }) - Complexity = 6
// Dst: (SUBW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10217*/ /*Scope*/ 20, /*->10238*/
/* 10218*/ OPC_CheckOpcode, TARGET_VAL(ISD::MUL),
/* 10221*/ OPC_RecordChild0, // #0 = $rs1
/* 10222*/ OPC_RecordChild1, // #1 = $rs2
/* 10223*/ OPC_MoveParent,
/* 10224*/ OPC_MoveChild1,
/* 10225*/ OPC_CheckValueType, MVT::i32,
/* 10227*/ OPC_MoveParent,
/* 10228*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10230*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } (mul:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), i32:{ *:[Other] }) - Complexity = 6
// Dst: (MULW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10238*/ /*Scope*/ 18, /*->10257*/
/* 10239*/ OPC_CheckOpcode, TARGET_VAL(RISCVISD::FMV_X_ANYEXTW_RV64),
/* 10242*/ OPC_RecordChild0, // #0 = $src
/* 10243*/ OPC_MoveParent,
/* 10244*/ OPC_MoveChild1,
/* 10245*/ OPC_CheckValueType, MVT::i32,
/* 10247*/ OPC_MoveParent,
/* 10248*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10250*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i64, 1/*#Ops*/, 0,
// Src: (sext_inreg:{ *:[i64] } (riscv_fmv_x_anyextw_rv64:{ *:[i64] } FPR32:{ *:[f32] }:$src), i32:{ *:[Other] }) - Complexity = 6
// Dst: (FMV_X_W:{ *:[i64] } FPR32:{ *:[f32] }:$src)
/* 10257*/ 0, /*End of Scope*/
/* 10258*/ /*Scope*/ 18, /*->10277*/
/* 10259*/ OPC_RecordChild0, // #0 = $rs1
/* 10260*/ OPC_MoveChild1,
/* 10261*/ OPC_CheckValueType, MVT::i32,
/* 10263*/ OPC_MoveParent,
/* 10264*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10266*/ OPC_EmitInteger, MVT::i64, 0,
/* 10269*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDIW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }) - Complexity = 3
// Dst: (ADDIW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 10277*/ 0, /*End of Scope*/
/* 10278*/ /*SwitchOpcode*/ 124, TARGET_VAL(ISD::ADD),// ->10405
/* 10281*/ OPC_RecordChild0, // #0 = $Rs
/* 10282*/ OPC_RecordChild1, // #1 = $imm12
/* 10283*/ OPC_Scope, 81, /*->10366*/ // 3 children in Scope
/* 10285*/ OPC_MoveChild1,
/* 10286*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 10289*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 10291*/ OPC_MoveParent,
/* 10292*/ OPC_SwitchType /*2 cases */, 56, MVT::i32,// ->10351
/* 10295*/ OPC_Scope, 15, /*->10312*/ // 4 children in Scope
/* 10297*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10299*/ OPC_CheckComplexPat, /*CP*/0, /*#*/0, // SelectAddrFI:$Rs #2
/* 10302*/ OPC_EmitConvertToTarget, 1,
/* 10304*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (add:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 13
// Dst: (ADDI:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 10312*/ /*Scope*/ 13, /*->10326*/
/* 10313*/ OPC_CheckComplexPat, /*CP*/0, /*#*/0, // SelectAddrFI:$Rs #2
/* 10316*/ OPC_EmitConvertToTarget, 1,
/* 10318*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (add:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 13
// Dst: (ADDI:{ *:[i32] } AddrFI:{ *:[i32] }:$Rs, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 10326*/ /*Scope*/ 12, /*->10339*/
/* 10327*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10329*/ OPC_EmitConvertToTarget, 1,
/* 10331*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ADDI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 10339*/ /*Scope*/ 10, /*->10350*/
/* 10340*/ OPC_EmitConvertToTarget, 1,
/* 10342*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ADDI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 10350*/ 0, /*End of Scope*/
/* 10351*/ /*SwitchType*/ 12, MVT::i64,// ->10365
/* 10353*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10355*/ OPC_EmitConvertToTarget, 1,
/* 10357*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (ADDI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 10365*/ 0, // EndSwitchType
/* 10366*/ /*Scope*/ 24, /*->10391*/
/* 10367*/ OPC_CheckType, MVT::i32,
/* 10369*/ OPC_Scope, 10, /*->10381*/ // 2 children in Scope
/* 10371*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10373*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADD), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (ADD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 10381*/ /*Scope*/ 8, /*->10390*/
/* 10382*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADD), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (ADD:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 10390*/ 0, /*End of Scope*/
/* 10391*/ /*Scope*/ 12, /*->10404*/
/* 10392*/ OPC_CheckType, MVT::i64,
/* 10394*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10396*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADD), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (ADD:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10404*/ 0, /*End of Scope*/
/* 10405*/ /*SwitchOpcode*/ 7|128,2/*263*/, TARGET_VAL(ISD::ATOMIC_FENCE),// ->10672
/* 10409*/ OPC_RecordNode, // #0 = 'atomic_fence' chained node
/* 10410*/ OPC_Scope, 70, /*->10482*/ // 4 children in Scope
/* 10412*/ OPC_CheckChild1Integer, 4,
/* 10414*/ OPC_Scope, 41, /*->10457*/ // 2 children in Scope
/* 10416*/ OPC_CheckChild1Type, MVT::i32,
/* 10418*/ OPC_MoveChild2,
/* 10419*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10422*/ OPC_MoveParent,
/* 10423*/ OPC_Scope, 16, /*->10441*/ // 2 children in Scope
/* 10425*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10427*/ OPC_EmitMergeInputChains1_0,
/* 10428*/ OPC_EmitInteger, MVT::i32, 2,
/* 10431*/ OPC_EmitInteger, MVT::i32, 3,
/* 10434*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 4:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 2:{ *:[i32] }, 3:{ *:[i32] })
/* 10441*/ /*Scope*/ 14, /*->10456*/
/* 10442*/ OPC_EmitMergeInputChains1_0,
/* 10443*/ OPC_EmitInteger, MVT::i32, 2,
/* 10446*/ OPC_EmitInteger, MVT::i32, 3,
/* 10449*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 4:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 2:{ *:[i32] }, 3:{ *:[i32] })
/* 10456*/ 0, /*End of Scope*/
/* 10457*/ /*Scope*/ 23, /*->10481*/
/* 10458*/ OPC_CheckChild1Type, MVT::i64,
/* 10460*/ OPC_MoveChild2,
/* 10461*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10464*/ OPC_MoveParent,
/* 10465*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10467*/ OPC_EmitMergeInputChains1_0,
/* 10468*/ OPC_EmitInteger, MVT::i64, 2,
/* 10471*/ OPC_EmitInteger, MVT::i64, 3,
/* 10474*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 4:{ *:[i64] }, (timm:{ *:[i64] })) - Complexity = 11
// Dst: (FENCE 2:{ *:[i64] }, 3:{ *:[i64] })
/* 10481*/ 0, /*End of Scope*/
/* 10482*/ /*Scope*/ 70, /*->10553*/
/* 10483*/ OPC_CheckChild1Integer, 5,
/* 10485*/ OPC_Scope, 41, /*->10528*/ // 2 children in Scope
/* 10487*/ OPC_CheckChild1Type, MVT::i32,
/* 10489*/ OPC_MoveChild2,
/* 10490*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10493*/ OPC_MoveParent,
/* 10494*/ OPC_Scope, 16, /*->10512*/ // 2 children in Scope
/* 10496*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10498*/ OPC_EmitMergeInputChains1_0,
/* 10499*/ OPC_EmitInteger, MVT::i32, 3,
/* 10502*/ OPC_EmitInteger, MVT::i32, 1,
/* 10505*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 5:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i32] }, 1:{ *:[i32] })
/* 10512*/ /*Scope*/ 14, /*->10527*/
/* 10513*/ OPC_EmitMergeInputChains1_0,
/* 10514*/ OPC_EmitInteger, MVT::i32, 3,
/* 10517*/ OPC_EmitInteger, MVT::i32, 1,
/* 10520*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 5:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i32] }, 1:{ *:[i32] })
/* 10527*/ 0, /*End of Scope*/
/* 10528*/ /*Scope*/ 23, /*->10552*/
/* 10529*/ OPC_CheckChild1Type, MVT::i64,
/* 10531*/ OPC_MoveChild2,
/* 10532*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10535*/ OPC_MoveParent,
/* 10536*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10538*/ OPC_EmitMergeInputChains1_0,
/* 10539*/ OPC_EmitInteger, MVT::i64, 3,
/* 10542*/ OPC_EmitInteger, MVT::i64, 1,
/* 10545*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 5:{ *:[i64] }, (timm:{ *:[i64] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i64] }, 1:{ *:[i64] })
/* 10552*/ 0, /*End of Scope*/
/* 10553*/ /*Scope*/ 46, /*->10600*/
/* 10554*/ OPC_CheckChild1Integer, 6,
/* 10556*/ OPC_Scope, 25, /*->10583*/ // 2 children in Scope
/* 10558*/ OPC_CheckChild1Type, MVT::i32,
/* 10560*/ OPC_MoveChild2,
/* 10561*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10564*/ OPC_MoveParent,
/* 10565*/ OPC_Scope, 8, /*->10575*/ // 2 children in Scope
/* 10567*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10569*/ OPC_EmitMergeInputChains1_0,
/* 10570*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE_TSO), 0|OPFL_Chain,
0/*#Ops*/,
// Src: (atomic_fence 6:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE_TSO)
/* 10575*/ /*Scope*/ 6, /*->10582*/
/* 10576*/ OPC_EmitMergeInputChains1_0,
/* 10577*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE_TSO), 0|OPFL_Chain,
0/*#Ops*/,
// Src: (atomic_fence 6:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE_TSO)
/* 10582*/ 0, /*End of Scope*/
/* 10583*/ /*Scope*/ 15, /*->10599*/
/* 10584*/ OPC_CheckChild1Type, MVT::i64,
/* 10586*/ OPC_MoveChild2,
/* 10587*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10590*/ OPC_MoveParent,
/* 10591*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10593*/ OPC_EmitMergeInputChains1_0,
/* 10594*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE_TSO), 0|OPFL_Chain,
0/*#Ops*/,
// Src: (atomic_fence 6:{ *:[i64] }, (timm:{ *:[i64] })) - Complexity = 11
// Dst: (FENCE_TSO)
/* 10599*/ 0, /*End of Scope*/
/* 10600*/ /*Scope*/ 70, /*->10671*/
/* 10601*/ OPC_CheckChild1Integer, 7,
/* 10603*/ OPC_Scope, 41, /*->10646*/ // 2 children in Scope
/* 10605*/ OPC_CheckChild1Type, MVT::i32,
/* 10607*/ OPC_MoveChild2,
/* 10608*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10611*/ OPC_MoveParent,
/* 10612*/ OPC_Scope, 16, /*->10630*/ // 2 children in Scope
/* 10614*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 10616*/ OPC_EmitMergeInputChains1_0,
/* 10617*/ OPC_EmitInteger, MVT::i32, 3,
/* 10620*/ OPC_EmitInteger, MVT::i32, 3,
/* 10623*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 7:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i32] }, 3:{ *:[i32] })
/* 10630*/ /*Scope*/ 14, /*->10645*/
/* 10631*/ OPC_EmitMergeInputChains1_0,
/* 10632*/ OPC_EmitInteger, MVT::i32, 3,
/* 10635*/ OPC_EmitInteger, MVT::i32, 3,
/* 10638*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 7:{ *:[i32] }, (timm:{ *:[i32] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i32] }, 3:{ *:[i32] })
/* 10645*/ 0, /*End of Scope*/
/* 10646*/ /*Scope*/ 23, /*->10670*/
/* 10647*/ OPC_CheckChild1Type, MVT::i64,
/* 10649*/ OPC_MoveChild2,
/* 10650*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10653*/ OPC_MoveParent,
/* 10654*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 10656*/ OPC_EmitMergeInputChains1_0,
/* 10657*/ OPC_EmitInteger, MVT::i64, 3,
/* 10660*/ OPC_EmitInteger, MVT::i64, 3,
/* 10663*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::FENCE), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (atomic_fence 7:{ *:[i64] }, (timm:{ *:[i64] })) - Complexity = 11
// Dst: (FENCE 3:{ *:[i64] }, 3:{ *:[i64] })
/* 10670*/ 0, /*End of Scope*/
/* 10671*/ 0, /*End of Scope*/
/* 10672*/ /*SwitchOpcode*/ 17|128,1/*145*/, TARGET_VAL(ISD::SREM),// ->10821
/* 10676*/ OPC_Scope, 99, /*->10777*/ // 2 children in Scope
/* 10678*/ OPC_MoveChild0,
/* 10679*/ OPC_SwitchOpcode /*2 cases */, 45, TARGET_VAL(ISD::AssertSext),// ->10728
/* 10683*/ OPC_RecordChild0, // #0 = $rs1
/* 10684*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 10686*/ OPC_MoveParent,
/* 10687*/ OPC_MoveChild1,
/* 10688*/ OPC_SwitchOpcode /*2 cases */, 16, TARGET_VAL(ISD::AssertSext),// ->10708
/* 10692*/ OPC_RecordChild0, // #1 = $rs2
/* 10693*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 10695*/ OPC_MoveParent,
/* 10696*/ OPC_CheckType, MVT::i64,
/* 10698*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10700*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i64] } (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertsexti32>>, (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertsexti32>>) - Complexity = 11
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10708*/ /*SwitchOpcode*/ 16, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10727
/* 10711*/ OPC_RecordChild0, // #1 = $rs2
/* 10712*/ OPC_MoveChild1,
/* 10713*/ OPC_CheckValueType, MVT::i32,
/* 10715*/ OPC_MoveParent,
/* 10716*/ OPC_MoveParent,
/* 10717*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10719*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i64] } (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertsexti32>>, (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs2, i32:{ *:[Other] })) - Complexity = 10
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10727*/ 0, // EndSwitchOpcode
/* 10728*/ /*SwitchOpcode*/ 45, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10776
/* 10731*/ OPC_RecordChild0, // #0 = $rs1
/* 10732*/ OPC_MoveChild1,
/* 10733*/ OPC_CheckValueType, MVT::i32,
/* 10735*/ OPC_MoveParent,
/* 10736*/ OPC_MoveParent,
/* 10737*/ OPC_MoveChild1,
/* 10738*/ OPC_SwitchOpcode /*2 cases */, 14, TARGET_VAL(ISD::AssertSext),// ->10756
/* 10742*/ OPC_RecordChild0, // #1 = $rs2
/* 10743*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 10745*/ OPC_MoveParent,
/* 10746*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10748*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }), (assertsext:{ *:[i64] } GPR:{ *:[i64] }:$rs2)<<P:Predicate_assertsexti32>>) - Complexity = 10
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10756*/ /*SwitchOpcode*/ 16, TARGET_VAL(ISD::SIGN_EXTEND_INREG),// ->10775
/* 10759*/ OPC_RecordChild0, // #1 = $rs2
/* 10760*/ OPC_MoveChild1,
/* 10761*/ OPC_CheckValueType, MVT::i32,
/* 10763*/ OPC_MoveParent,
/* 10764*/ OPC_MoveParent,
/* 10765*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10767*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }), (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs2, i32:{ *:[Other] })) - Complexity = 9
// Dst: (REMW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10775*/ 0, // EndSwitchOpcode
/* 10776*/ 0, // EndSwitchOpcode
/* 10777*/ /*Scope*/ 42, /*->10820*/
/* 10778*/ OPC_RecordChild0, // #0 = $rs1
/* 10779*/ OPC_RecordChild1, // #1 = $rs2
/* 10780*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->10807
/* 10783*/ OPC_Scope, 10, /*->10795*/ // 2 children in Scope
/* 10785*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 10787*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REM), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REM:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 10795*/ /*Scope*/ 10, /*->10806*/
/* 10796*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 10798*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REM), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REM:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 10806*/ 0, /*End of Scope*/
/* 10807*/ /*SwitchType*/ 10, MVT::i64,// ->10819
/* 10809*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 10811*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REM), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srem:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (REM:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 10819*/ 0, // EndSwitchType
/* 10820*/ 0, /*End of Scope*/
/* 10821*/ /*SwitchOpcode*/ 12|128,6/*780*/, TARGET_VAL(ISD::INTRINSIC_W_CHAIN),// ->11605
/* 10825*/ OPC_RecordNode, // #0 = 'intrinsic_w_chain' chained node
/* 10826*/ OPC_Scope, 50, /*->10878*/ // 18 children in Scope
/* 10828*/ OPC_CheckChild1Integer, 37|128,47/*6053*/,
/* 10831*/ OPC_RecordChild2, // #1 = $addr
/* 10832*/ OPC_CheckChild2Type, MVT::i32,
/* 10834*/ OPC_RecordChild3, // #2 = $incr
/* 10835*/ OPC_RecordChild4, // #3 = $mask
/* 10836*/ OPC_RecordChild5, // #4 = $ordering
/* 10837*/ OPC_MoveChild5,
/* 10838*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10841*/ OPC_MoveParent,
/* 10842*/ OPC_Scope, 16, /*->10860*/ // 2 children in Scope
/* 10844*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 10846*/ OPC_EmitMergeInputChains1_0,
/* 10847*/ OPC_EmitConvertToTarget, 4,
/* 10849*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicSwap32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6053:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicSwap32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10860*/ /*Scope*/ 16, /*->10877*/
/* 10861*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 10863*/ OPC_EmitMergeInputChains1_0,
/* 10864*/ OPC_EmitConvertToTarget, 4,
/* 10866*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicSwap32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6053:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicSwap32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10877*/ 0, /*End of Scope*/
/* 10878*/ /*Scope*/ 50, /*->10929*/
/* 10879*/ OPC_CheckChild1Integer, 23|128,47/*6039*/,
/* 10882*/ OPC_RecordChild2, // #1 = $addr
/* 10883*/ OPC_CheckChild2Type, MVT::i32,
/* 10885*/ OPC_RecordChild3, // #2 = $incr
/* 10886*/ OPC_RecordChild4, // #3 = $mask
/* 10887*/ OPC_RecordChild5, // #4 = $ordering
/* 10888*/ OPC_MoveChild5,
/* 10889*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10892*/ OPC_MoveParent,
/* 10893*/ OPC_Scope, 16, /*->10911*/ // 2 children in Scope
/* 10895*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 10897*/ OPC_EmitMergeInputChains1_0,
/* 10898*/ OPC_EmitConvertToTarget, 4,
/* 10900*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadAdd32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6039:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadAdd32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10911*/ /*Scope*/ 16, /*->10928*/
/* 10912*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 10914*/ OPC_EmitMergeInputChains1_0,
/* 10915*/ OPC_EmitConvertToTarget, 4,
/* 10917*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadAdd32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6039:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadAdd32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10928*/ 0, /*End of Scope*/
/* 10929*/ /*Scope*/ 50, /*->10980*/
/* 10930*/ OPC_CheckChild1Integer, 31|128,47/*6047*/,
/* 10933*/ OPC_RecordChild2, // #1 = $addr
/* 10934*/ OPC_CheckChild2Type, MVT::i32,
/* 10936*/ OPC_RecordChild3, // #2 = $incr
/* 10937*/ OPC_RecordChild4, // #3 = $mask
/* 10938*/ OPC_RecordChild5, // #4 = $ordering
/* 10939*/ OPC_MoveChild5,
/* 10940*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10943*/ OPC_MoveParent,
/* 10944*/ OPC_Scope, 16, /*->10962*/ // 2 children in Scope
/* 10946*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 10948*/ OPC_EmitMergeInputChains1_0,
/* 10949*/ OPC_EmitConvertToTarget, 4,
/* 10951*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadSub32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6047:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadSub32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10962*/ /*Scope*/ 16, /*->10979*/
/* 10963*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 10965*/ OPC_EmitMergeInputChains1_0,
/* 10966*/ OPC_EmitConvertToTarget, 4,
/* 10968*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadSub32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6047:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadSub32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 10979*/ 0, /*End of Scope*/
/* 10980*/ /*Scope*/ 50, /*->11031*/
/* 10981*/ OPC_CheckChild1Integer, 29|128,47/*6045*/,
/* 10984*/ OPC_RecordChild2, // #1 = $addr
/* 10985*/ OPC_CheckChild2Type, MVT::i32,
/* 10987*/ OPC_RecordChild3, // #2 = $incr
/* 10988*/ OPC_RecordChild4, // #3 = $mask
/* 10989*/ OPC_RecordChild5, // #4 = $ordering
/* 10990*/ OPC_MoveChild5,
/* 10991*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 10994*/ OPC_MoveParent,
/* 10995*/ OPC_Scope, 16, /*->11013*/ // 2 children in Scope
/* 10997*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 10999*/ OPC_EmitMergeInputChains1_0,
/* 11000*/ OPC_EmitConvertToTarget, 4,
/* 11002*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadNand32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6045:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11013*/ /*Scope*/ 16, /*->11030*/
/* 11014*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11016*/ OPC_EmitMergeInputChains1_0,
/* 11017*/ OPC_EmitConvertToTarget, 4,
/* 11019*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadNand32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6045:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11030*/ 0, /*End of Scope*/
/* 11031*/ /*Scope*/ 57, /*->11089*/
/* 11032*/ OPC_CheckChild1Integer, 25|128,47/*6041*/,
/* 11035*/ OPC_RecordChild2, // #1 = $addr
/* 11036*/ OPC_CheckChild2Type, MVT::i32,
/* 11038*/ OPC_RecordChild3, // #2 = $incr
/* 11039*/ OPC_RecordChild4, // #3 = $mask
/* 11040*/ OPC_RecordChild5, // #4 = $shiftamt
/* 11041*/ OPC_RecordChild6, // #5 = $ordering
/* 11042*/ OPC_MoveChild6,
/* 11043*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11046*/ OPC_MoveParent,
/* 11047*/ OPC_Scope, 19, /*->11068*/ // 2 children in Scope
/* 11049*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 11051*/ OPC_EmitMergeInputChains1_0,
/* 11052*/ OPC_EmitConvertToTarget, 5,
/* 11054*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6041:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMax32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (imm:{ *:[i32] }):$ordering)
/* 11068*/ /*Scope*/ 19, /*->11088*/
/* 11069*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11071*/ OPC_EmitMergeInputChains1_0,
/* 11072*/ OPC_EmitConvertToTarget, 5,
/* 11074*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6041:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMax32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (imm:{ *:[i32] }):$ordering)
/* 11088*/ 0, /*End of Scope*/
/* 11089*/ /*Scope*/ 57, /*->11147*/
/* 11090*/ OPC_CheckChild1Integer, 27|128,47/*6043*/,
/* 11093*/ OPC_RecordChild2, // #1 = $addr
/* 11094*/ OPC_CheckChild2Type, MVT::i32,
/* 11096*/ OPC_RecordChild3, // #2 = $incr
/* 11097*/ OPC_RecordChild4, // #3 = $mask
/* 11098*/ OPC_RecordChild5, // #4 = $shiftamt
/* 11099*/ OPC_RecordChild6, // #5 = $ordering
/* 11100*/ OPC_MoveChild6,
/* 11101*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11104*/ OPC_MoveParent,
/* 11105*/ OPC_Scope, 19, /*->11126*/ // 2 children in Scope
/* 11107*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 11109*/ OPC_EmitMergeInputChains1_0,
/* 11110*/ OPC_EmitConvertToTarget, 5,
/* 11112*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6043:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMin32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (imm:{ *:[i32] }):$ordering)
/* 11126*/ /*Scope*/ 19, /*->11146*/
/* 11127*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11129*/ OPC_EmitMergeInputChains1_0,
/* 11130*/ OPC_EmitConvertToTarget, 5,
/* 11132*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6043:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMin32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, GPR:{ *:[i32] }:$shiftamt, (imm:{ *:[i32] }):$ordering)
/* 11146*/ 0, /*End of Scope*/
/* 11147*/ /*Scope*/ 54, /*->11202*/
/* 11148*/ OPC_CheckChild1Integer, 33|128,47/*6049*/,
/* 11151*/ OPC_RecordChild2, // #1 = $addr
/* 11152*/ OPC_CheckChild2Type, MVT::i32,
/* 11154*/ OPC_RecordChild3, // #2 = $incr
/* 11155*/ OPC_RecordChild4, // #3 = $mask
/* 11156*/ OPC_RecordChild5, // #4 = $ordering
/* 11157*/ OPC_MoveChild5,
/* 11158*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11161*/ OPC_MoveParent,
/* 11162*/ OPC_Scope, 18, /*->11182*/ // 2 children in Scope
/* 11164*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 11166*/ OPC_EmitMergeInputChains1_0,
/* 11167*/ OPC_EmitConvertToTarget, 4,
/* 11169*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6049:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMax32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11182*/ /*Scope*/ 18, /*->11201*/
/* 11183*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11185*/ OPC_EmitMergeInputChains1_0,
/* 11186*/ OPC_EmitConvertToTarget, 4,
/* 11188*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6049:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMax32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11201*/ 0, /*End of Scope*/
/* 11202*/ /*Scope*/ 54, /*->11257*/
/* 11203*/ OPC_CheckChild1Integer, 35|128,47/*6051*/,
/* 11206*/ OPC_RecordChild2, // #1 = $addr
/* 11207*/ OPC_CheckChild2Type, MVT::i32,
/* 11209*/ OPC_RecordChild3, // #2 = $incr
/* 11210*/ OPC_RecordChild4, // #3 = $mask
/* 11211*/ OPC_RecordChild5, // #4 = $ordering
/* 11212*/ OPC_MoveChild5,
/* 11213*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11216*/ OPC_MoveParent,
/* 11217*/ OPC_Scope, 18, /*->11237*/ // 2 children in Scope
/* 11219*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 11221*/ OPC_EmitMergeInputChains1_0,
/* 11222*/ OPC_EmitConvertToTarget, 4,
/* 11224*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6051:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMin32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11237*/ /*Scope*/ 18, /*->11256*/
/* 11238*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11240*/ OPC_EmitMergeInputChains1_0,
/* 11241*/ OPC_EmitConvertToTarget, 4,
/* 11243*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i32, MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i32] } 6051:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMin32:{ *:[i32] }:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11256*/ 0, /*End of Scope*/
/* 11257*/ /*Scope*/ 53, /*->11311*/
/* 11258*/ OPC_CheckChild1Integer, 39|128,47/*6055*/,
/* 11261*/ OPC_RecordChild2, // #1 = $addr
/* 11262*/ OPC_CheckChild2Type, MVT::i32,
/* 11264*/ OPC_RecordChild3, // #2 = $cmpval
/* 11265*/ OPC_RecordChild4, // #3 = $newval
/* 11266*/ OPC_RecordChild5, // #4 = $mask
/* 11267*/ OPC_RecordChild6, // #5 = $ordering
/* 11268*/ OPC_MoveChild6,
/* 11269*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11272*/ OPC_MoveParent,
/* 11273*/ OPC_Scope, 17, /*->11292*/ // 2 children in Scope
/* 11275*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 11277*/ OPC_EmitMergeInputChains1_0,
/* 11278*/ OPC_EmitConvertToTarget, 5,
/* 11280*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedCmpXchg32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6055:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmpval, GPR:{ *:[i32] }:$newval, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmpval, GPR:{ *:[i32] }:$newval, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11292*/ /*Scope*/ 17, /*->11310*/
/* 11293*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 11295*/ OPC_EmitMergeInputChains1_0,
/* 11296*/ OPC_EmitConvertToTarget, 5,
/* 11298*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedCmpXchg32), 0|OPFL_Chain,
MVT::i32, MVT::i32, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i32] } 6055:{ *:[iPTR] }, GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmpval, GPR:{ *:[i32] }:$newval, GPR:{ *:[i32] }:$mask, (timm:{ *:[i32] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmpval, GPR:{ *:[i32] }:$newval, GPR:{ *:[i32] }:$mask, (imm:{ *:[i32] }):$ordering)
/* 11310*/ 0, /*End of Scope*/
/* 11311*/ /*Scope*/ 30, /*->11342*/
/* 11312*/ OPC_CheckChild1Integer, 38|128,47/*6054*/,
/* 11315*/ OPC_RecordChild2, // #1 = $addr
/* 11316*/ OPC_CheckChild2Type, MVT::i64,
/* 11318*/ OPC_RecordChild3, // #2 = $incr
/* 11319*/ OPC_RecordChild4, // #3 = $mask
/* 11320*/ OPC_RecordChild5, // #4 = $ordering
/* 11321*/ OPC_MoveChild5,
/* 11322*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11325*/ OPC_MoveParent,
/* 11326*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11328*/ OPC_EmitMergeInputChains1_0,
/* 11329*/ OPC_EmitConvertToTarget, 4,
/* 11331*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicSwap32), 0|OPFL_Chain,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6054:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicSwap32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11342*/ /*Scope*/ 30, /*->11373*/
/* 11343*/ OPC_CheckChild1Integer, 24|128,47/*6040*/,
/* 11346*/ OPC_RecordChild2, // #1 = $addr
/* 11347*/ OPC_CheckChild2Type, MVT::i64,
/* 11349*/ OPC_RecordChild3, // #2 = $incr
/* 11350*/ OPC_RecordChild4, // #3 = $mask
/* 11351*/ OPC_RecordChild5, // #4 = $ordering
/* 11352*/ OPC_MoveChild5,
/* 11353*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11356*/ OPC_MoveParent,
/* 11357*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11359*/ OPC_EmitMergeInputChains1_0,
/* 11360*/ OPC_EmitConvertToTarget, 4,
/* 11362*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadAdd32), 0|OPFL_Chain,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6040:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadAdd32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11373*/ /*Scope*/ 30, /*->11404*/
/* 11374*/ OPC_CheckChild1Integer, 32|128,47/*6048*/,
/* 11377*/ OPC_RecordChild2, // #1 = $addr
/* 11378*/ OPC_CheckChild2Type, MVT::i64,
/* 11380*/ OPC_RecordChild3, // #2 = $incr
/* 11381*/ OPC_RecordChild4, // #3 = $mask
/* 11382*/ OPC_RecordChild5, // #4 = $ordering
/* 11383*/ OPC_MoveChild5,
/* 11384*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11387*/ OPC_MoveParent,
/* 11388*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11390*/ OPC_EmitMergeInputChains1_0,
/* 11391*/ OPC_EmitConvertToTarget, 4,
/* 11393*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadSub32), 0|OPFL_Chain,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6048:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadSub32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11404*/ /*Scope*/ 30, /*->11435*/
/* 11405*/ OPC_CheckChild1Integer, 30|128,47/*6046*/,
/* 11408*/ OPC_RecordChild2, // #1 = $addr
/* 11409*/ OPC_CheckChild2Type, MVT::i64,
/* 11411*/ OPC_RecordChild3, // #2 = $incr
/* 11412*/ OPC_RecordChild4, // #3 = $mask
/* 11413*/ OPC_RecordChild5, // #4 = $ordering
/* 11414*/ OPC_MoveChild5,
/* 11415*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11418*/ OPC_MoveParent,
/* 11419*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11421*/ OPC_EmitMergeInputChains1_0,
/* 11422*/ OPC_EmitConvertToTarget, 4,
/* 11424*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadNand32), 0|OPFL_Chain,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6046:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11435*/ /*Scope*/ 34, /*->11470*/
/* 11436*/ OPC_CheckChild1Integer, 26|128,47/*6042*/,
/* 11439*/ OPC_RecordChild2, // #1 = $addr
/* 11440*/ OPC_CheckChild2Type, MVT::i64,
/* 11442*/ OPC_RecordChild3, // #2 = $incr
/* 11443*/ OPC_RecordChild4, // #3 = $mask
/* 11444*/ OPC_RecordChild5, // #4 = $shiftamt
/* 11445*/ OPC_RecordChild6, // #5 = $ordering
/* 11446*/ OPC_MoveChild6,
/* 11447*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11450*/ OPC_MoveParent,
/* 11451*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11453*/ OPC_EmitMergeInputChains1_0,
/* 11454*/ OPC_EmitConvertToTarget, 5,
/* 11456*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i64, MVT::i64, MVT::i64, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i64] } 6042:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, GPR:{ *:[i64] }:$shiftamt, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMax32:{ *:[i64] }:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, GPR:{ *:[i64] }:$shiftamt, (imm:{ *:[i64] }):$ordering)
/* 11470*/ /*Scope*/ 34, /*->11505*/
/* 11471*/ OPC_CheckChild1Integer, 28|128,47/*6044*/,
/* 11474*/ OPC_RecordChild2, // #1 = $addr
/* 11475*/ OPC_CheckChild2Type, MVT::i64,
/* 11477*/ OPC_RecordChild3, // #2 = $incr
/* 11478*/ OPC_RecordChild4, // #3 = $mask
/* 11479*/ OPC_RecordChild5, // #4 = $shiftamt
/* 11480*/ OPC_RecordChild6, // #5 = $ordering
/* 11481*/ OPC_MoveChild6,
/* 11482*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11485*/ OPC_MoveParent,
/* 11486*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11488*/ OPC_EmitMergeInputChains1_0,
/* 11489*/ OPC_EmitConvertToTarget, 5,
/* 11491*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i64, MVT::i64, MVT::i64, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i64] } 6044:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, GPR:{ *:[i64] }:$shiftamt, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadMin32:{ *:[i64] }:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, GPR:{ *:[i64] }:$shiftamt, (imm:{ *:[i64] }):$ordering)
/* 11505*/ /*Scope*/ 32, /*->11538*/
/* 11506*/ OPC_CheckChild1Integer, 34|128,47/*6050*/,
/* 11509*/ OPC_RecordChild2, // #1 = $addr
/* 11510*/ OPC_CheckChild2Type, MVT::i64,
/* 11512*/ OPC_RecordChild3, // #2 = $incr
/* 11513*/ OPC_RecordChild4, // #3 = $mask
/* 11514*/ OPC_RecordChild5, // #4 = $ordering
/* 11515*/ OPC_MoveChild5,
/* 11516*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11519*/ OPC_MoveParent,
/* 11520*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11522*/ OPC_EmitMergeInputChains1_0,
/* 11523*/ OPC_EmitConvertToTarget, 4,
/* 11525*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMax32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i64, MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6050:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMax32:{ *:[i64] }:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11538*/ /*Scope*/ 32, /*->11571*/
/* 11539*/ OPC_CheckChild1Integer, 36|128,47/*6052*/,
/* 11542*/ OPC_RecordChild2, // #1 = $addr
/* 11543*/ OPC_CheckChild2Type, MVT::i64,
/* 11545*/ OPC_RecordChild3, // #2 = $incr
/* 11546*/ OPC_RecordChild4, // #3 = $mask
/* 11547*/ OPC_RecordChild5, // #4 = $ordering
/* 11548*/ OPC_MoveChild5,
/* 11549*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11552*/ OPC_MoveParent,
/* 11553*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11555*/ OPC_EmitMergeInputChains1_0,
/* 11556*/ OPC_EmitConvertToTarget, 4,
/* 11558*/ OPC_MorphNodeTo, TARGET_VAL(RISCV::PseudoMaskedAtomicLoadUMin32), 0|OPFL_Chain,
3/*#VTs*/, MVT::i64, MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 5,
// Src: (intrinsic_w_chain:{ *:[i64] } 6052:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedAtomicLoadUMin32:{ *:[i64] }:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11571*/ /*Scope*/ 32, /*->11604*/
/* 11572*/ OPC_CheckChild1Integer, 40|128,47/*6056*/,
/* 11575*/ OPC_RecordChild2, // #1 = $addr
/* 11576*/ OPC_CheckChild2Type, MVT::i64,
/* 11578*/ OPC_RecordChild3, // #2 = $cmpval
/* 11579*/ OPC_RecordChild4, // #3 = $newval
/* 11580*/ OPC_RecordChild5, // #4 = $mask
/* 11581*/ OPC_RecordChild6, // #5 = $ordering
/* 11582*/ OPC_MoveChild6,
/* 11583*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 11586*/ OPC_MoveParent,
/* 11587*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 11589*/ OPC_EmitMergeInputChains1_0,
/* 11590*/ OPC_EmitConvertToTarget, 5,
/* 11592*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoMaskedCmpXchg32), 0|OPFL_Chain,
MVT::i64, MVT::i64, 5/*#Ops*/, 1, 2, 3, 4, 6,
// Src: (intrinsic_w_chain:{ *:[i64] } 6056:{ *:[iPTR] }, GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmpval, GPR:{ *:[i64] }:$newval, GPR:{ *:[i64] }:$mask, (timm:{ *:[i64] }):$ordering) - Complexity = 11
// Dst: (PseudoMaskedCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmpval, GPR:{ *:[i64] }:$newval, GPR:{ *:[i64] }:$mask, (imm:{ *:[i64] }):$ordering)
/* 11604*/ 0, /*End of Scope*/
/* 11605*/ /*SwitchOpcode*/ 35|128,1/*163*/, TARGET_VAL(ISD::SHL),// ->11772
/* 11609*/ OPC_RecordChild0, // #0 = $rs1
/* 11610*/ OPC_Scope, 56, /*->11668*/ // 2 children in Scope
/* 11612*/ OPC_MoveChild1,
/* 11613*/ OPC_CheckOpcode, TARGET_VAL(ISD::AND),
/* 11616*/ OPC_RecordChild0, // #1 = $rs2
/* 11617*/ OPC_MoveChild1,
/* 11618*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 11621*/ OPC_CheckPredicate, 16, // Predicate_immbottomxlenset
/* 11623*/ OPC_MoveParent,
/* 11624*/ OPC_SwitchType /*2 cases */, 25, MVT::i32,// ->11652
/* 11627*/ OPC_MoveParent,
/* 11628*/ OPC_CheckType, MVT::i32,
/* 11630*/ OPC_Scope, 10, /*->11642*/ // 2 children in Scope
/* 11632*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11634*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SLL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11642*/ /*Scope*/ 8, /*->11651*/
/* 11643*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SLL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11651*/ 0, /*End of Scope*/
/* 11652*/ /*SwitchType*/ 13, MVT::i64,// ->11667
/* 11654*/ OPC_MoveParent,
/* 11655*/ OPC_CheckType, MVT::i64,
/* 11657*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11659*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, (imm:{ *:[i64] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SLL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 11667*/ 0, // EndSwitchType
/* 11668*/ /*Scope*/ 102, /*->11771*/
/* 11669*/ OPC_RecordChild1, // #1 = $shamt
/* 11670*/ OPC_Scope, 56, /*->11728*/ // 3 children in Scope
/* 11672*/ OPC_MoveChild1,
/* 11673*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 11676*/ OPC_CheckPredicate, 17, // Predicate_uimmlog2xlen
/* 11678*/ OPC_SwitchType /*2 cases */, 29, MVT::i32,// ->11710
/* 11681*/ OPC_MoveParent,
/* 11682*/ OPC_CheckType, MVT::i32,
/* 11684*/ OPC_Scope, 12, /*->11698*/ // 2 children in Scope
/* 11686*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11688*/ OPC_EmitConvertToTarget, 1,
/* 11690*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SLLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11698*/ /*Scope*/ 10, /*->11709*/
/* 11699*/ OPC_EmitConvertToTarget, 1,
/* 11701*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SLLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11709*/ 0, /*End of Scope*/
/* 11710*/ /*SwitchType*/ 15, MVT::i64,// ->11727
/* 11712*/ OPC_MoveParent,
/* 11713*/ OPC_CheckType, MVT::i64,
/* 11715*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11717*/ OPC_EmitConvertToTarget, 1,
/* 11719*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (shl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SLLI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11727*/ 0, // EndSwitchType
/* 11728*/ /*Scope*/ 26, /*->11755*/
/* 11729*/ OPC_CheckChild1Type, MVT::i32,
/* 11731*/ OPC_CheckType, MVT::i32,
/* 11733*/ OPC_Scope, 10, /*->11745*/ // 2 children in Scope
/* 11735*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11737*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SLL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11745*/ /*Scope*/ 8, /*->11754*/
/* 11746*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SLL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11754*/ 0, /*End of Scope*/
/* 11755*/ /*Scope*/ 14, /*->11770*/
/* 11756*/ OPC_CheckChild1Type, MVT::i64,
/* 11758*/ OPC_CheckType, MVT::i64,
/* 11760*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11762*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLL), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (shl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SLL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 11770*/ 0, /*End of Scope*/
/* 11771*/ 0, /*End of Scope*/
/* 11772*/ /*SwitchOpcode*/ 35|128,1/*163*/, TARGET_VAL(ISD::SRL),// ->11939
/* 11776*/ OPC_RecordChild0, // #0 = $rs1
/* 11777*/ OPC_Scope, 56, /*->11835*/ // 2 children in Scope
/* 11779*/ OPC_MoveChild1,
/* 11780*/ OPC_CheckOpcode, TARGET_VAL(ISD::AND),
/* 11783*/ OPC_RecordChild0, // #1 = $rs2
/* 11784*/ OPC_MoveChild1,
/* 11785*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 11788*/ OPC_CheckPredicate, 16, // Predicate_immbottomxlenset
/* 11790*/ OPC_MoveParent,
/* 11791*/ OPC_SwitchType /*2 cases */, 25, MVT::i32,// ->11819
/* 11794*/ OPC_MoveParent,
/* 11795*/ OPC_CheckType, MVT::i32,
/* 11797*/ OPC_Scope, 10, /*->11809*/ // 2 children in Scope
/* 11799*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11801*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11809*/ /*Scope*/ 8, /*->11818*/
/* 11810*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11818*/ 0, /*End of Scope*/
/* 11819*/ /*SwitchType*/ 13, MVT::i64,// ->11834
/* 11821*/ OPC_MoveParent,
/* 11822*/ OPC_CheckType, MVT::i64,
/* 11824*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11826*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, (imm:{ *:[i64] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 11834*/ 0, // EndSwitchType
/* 11835*/ /*Scope*/ 102, /*->11938*/
/* 11836*/ OPC_RecordChild1, // #1 = $shamt
/* 11837*/ OPC_Scope, 56, /*->11895*/ // 3 children in Scope
/* 11839*/ OPC_MoveChild1,
/* 11840*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 11843*/ OPC_CheckPredicate, 17, // Predicate_uimmlog2xlen
/* 11845*/ OPC_SwitchType /*2 cases */, 29, MVT::i32,// ->11877
/* 11848*/ OPC_MoveParent,
/* 11849*/ OPC_CheckType, MVT::i32,
/* 11851*/ OPC_Scope, 12, /*->11865*/ // 2 children in Scope
/* 11853*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11855*/ OPC_EmitConvertToTarget, 1,
/* 11857*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11865*/ /*Scope*/ 10, /*->11876*/
/* 11866*/ OPC_EmitConvertToTarget, 1,
/* 11868*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRLI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11876*/ 0, /*End of Scope*/
/* 11877*/ /*SwitchType*/ 15, MVT::i64,// ->11894
/* 11879*/ OPC_MoveParent,
/* 11880*/ OPC_CheckType, MVT::i64,
/* 11882*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11884*/ OPC_EmitConvertToTarget, 1,
/* 11886*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (srl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRLI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 11894*/ 0, // EndSwitchType
/* 11895*/ /*Scope*/ 26, /*->11922*/
/* 11896*/ OPC_CheckChild1Type, MVT::i32,
/* 11898*/ OPC_CheckType, MVT::i32,
/* 11900*/ OPC_Scope, 10, /*->11912*/ // 2 children in Scope
/* 11902*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11904*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11912*/ /*Scope*/ 8, /*->11921*/
/* 11913*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11921*/ 0, /*End of Scope*/
/* 11922*/ /*Scope*/ 14, /*->11937*/
/* 11923*/ OPC_CheckChild1Type, MVT::i64,
/* 11925*/ OPC_CheckType, MVT::i64,
/* 11927*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11929*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRL), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (srl:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SRL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 11937*/ 0, /*End of Scope*/
/* 11938*/ 0, /*End of Scope*/
/* 11939*/ /*SwitchOpcode*/ 69|128,1/*197*/, TARGET_VAL(ISD::SRA),// ->12140
/* 11943*/ OPC_Scope, 57, /*->12002*/ // 3 children in Scope
/* 11945*/ OPC_RecordChild0, // #0 = $rs1
/* 11946*/ OPC_MoveChild1,
/* 11947*/ OPC_CheckOpcode, TARGET_VAL(ISD::AND),
/* 11950*/ OPC_RecordChild0, // #1 = $rs2
/* 11951*/ OPC_MoveChild1,
/* 11952*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 11955*/ OPC_CheckPredicate, 16, // Predicate_immbottomxlenset
/* 11957*/ OPC_MoveParent,
/* 11958*/ OPC_SwitchType /*2 cases */, 25, MVT::i32,// ->11986
/* 11961*/ OPC_MoveParent,
/* 11962*/ OPC_CheckType, MVT::i32,
/* 11964*/ OPC_Scope, 10, /*->11976*/ // 2 children in Scope
/* 11966*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 11968*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRA:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11976*/ /*Scope*/ 8, /*->11985*/
/* 11977*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (and:{ *:[i32] } GPR:{ *:[i32] }:$rs2, (imm:{ *:[i32] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRA:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 11985*/ 0, /*End of Scope*/
/* 11986*/ /*SwitchType*/ 13, MVT::i64,// ->12001
/* 11988*/ OPC_MoveParent,
/* 11989*/ OPC_CheckType, MVT::i64,
/* 11991*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 11993*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (and:{ *:[i64] } GPR:{ *:[i64] }:$rs2, (imm:{ *:[i64] })<<P:Predicate_immbottomxlenset>>)) - Complexity = 10
// Dst: (SRA:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 12001*/ 0, // EndSwitchType
/* 12002*/ /*Scope*/ 32, /*->12035*/
/* 12003*/ OPC_MoveChild0,
/* 12004*/ OPC_CheckOpcode, TARGET_VAL(ISD::SIGN_EXTEND_INREG),
/* 12007*/ OPC_RecordChild0, // #0 = $rs1
/* 12008*/ OPC_MoveChild1,
/* 12009*/ OPC_CheckValueType, MVT::i32,
/* 12011*/ OPC_MoveParent,
/* 12012*/ OPC_MoveParent,
/* 12013*/ OPC_RecordChild1, // #1 = $shamt
/* 12014*/ OPC_MoveChild1,
/* 12015*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 12018*/ OPC_CheckPredicate, 15, // Predicate_uimm5
/* 12020*/ OPC_CheckType, MVT::i64,
/* 12022*/ OPC_MoveParent,
/* 12023*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 12025*/ OPC_EmitConvertToTarget, 1,
/* 12027*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAIW), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (sra:{ *:[i64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] }), (imm:{ *:[i64] })<<P:Predicate_uimm5>>:$shamt) - Complexity = 10
// Dst: (SRAIW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimm5>>:$shamt)
/* 12035*/ /*Scope*/ 103, /*->12139*/
/* 12036*/ OPC_RecordChild0, // #0 = $rs1
/* 12037*/ OPC_RecordChild1, // #1 = $shamt
/* 12038*/ OPC_Scope, 56, /*->12096*/ // 3 children in Scope
/* 12040*/ OPC_MoveChild1,
/* 12041*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 12044*/ OPC_CheckPredicate, 17, // Predicate_uimmlog2xlen
/* 12046*/ OPC_SwitchType /*2 cases */, 29, MVT::i32,// ->12078
/* 12049*/ OPC_MoveParent,
/* 12050*/ OPC_CheckType, MVT::i32,
/* 12052*/ OPC_Scope, 12, /*->12066*/ // 2 children in Scope
/* 12054*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12056*/ OPC_EmitConvertToTarget, 1,
/* 12058*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRAI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 12066*/ /*Scope*/ 10, /*->12077*/
/* 12067*/ OPC_EmitConvertToTarget, 1,
/* 12069*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRAI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 12077*/ 0, /*End of Scope*/
/* 12078*/ /*SwitchType*/ 15, MVT::i64,// ->12095
/* 12080*/ OPC_MoveParent,
/* 12081*/ OPC_CheckType, MVT::i64,
/* 12083*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12085*/ OPC_EmitConvertToTarget, 1,
/* 12087*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (sra:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt) - Complexity = 7
// Dst: (SRAI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_uimmlog2xlen>>:$shamt)
/* 12095*/ 0, // EndSwitchType
/* 12096*/ /*Scope*/ 26, /*->12123*/
/* 12097*/ OPC_CheckChild1Type, MVT::i32,
/* 12099*/ OPC_CheckType, MVT::i32,
/* 12101*/ OPC_Scope, 10, /*->12113*/ // 2 children in Scope
/* 12103*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12105*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRA:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12113*/ /*Scope*/ 8, /*->12122*/
/* 12114*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRA:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12122*/ 0, /*End of Scope*/
/* 12123*/ /*Scope*/ 14, /*->12138*/
/* 12124*/ OPC_CheckChild1Type, MVT::i64,
/* 12126*/ OPC_CheckType, MVT::i64,
/* 12128*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12130*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRA), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sra:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SRA:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 12138*/ 0, /*End of Scope*/
/* 12139*/ 0, /*End of Scope*/
/* 12140*/ /*SwitchOpcode*/ 114, TARGET_VAL(ISD::BRIND),// ->12257
/* 12143*/ OPC_RecordNode, // #0 = 'brind' chained node
/* 12144*/ OPC_Scope, 59, /*->12205*/ // 2 children in Scope
/* 12146*/ OPC_MoveChild1,
/* 12147*/ OPC_CheckOpcode, TARGET_VAL(ISD::ADD),
/* 12150*/ OPC_RecordChild0, // #1 = $rs1
/* 12151*/ OPC_RecordChild1, // #2 = $imm12
/* 12152*/ OPC_MoveChild1,
/* 12153*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 12156*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 12158*/ OPC_MoveParent,
/* 12159*/ OPC_SwitchType /*2 cases */, 27, MVT::i32,// ->12189
/* 12162*/ OPC_MoveParent,
/* 12163*/ OPC_Scope, 12, /*->12177*/ // 2 children in Scope
/* 12165*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12167*/ OPC_EmitMergeInputChains1_0,
/* 12168*/ OPC_EmitConvertToTarget, 2,
/* 12170*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 3,
// Src: (brind (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)) - Complexity = 10
// Dst: (PseudoBRIND GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12177*/ /*Scope*/ 10, /*->12188*/
/* 12178*/ OPC_EmitMergeInputChains1_0,
/* 12179*/ OPC_EmitConvertToTarget, 2,
/* 12181*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 3,
// Src: (brind (add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)) - Complexity = 10
// Dst: (PseudoBRIND GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12188*/ 0, /*End of Scope*/
/* 12189*/ /*SwitchType*/ 13, MVT::i64,// ->12204
/* 12191*/ OPC_MoveParent,
/* 12192*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12194*/ OPC_EmitMergeInputChains1_0,
/* 12195*/ OPC_EmitConvertToTarget, 2,
/* 12197*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 3,
// Src: (brind (add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)) - Complexity = 10
// Dst: (PseudoBRIND GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 12204*/ 0, // EndSwitchType
/* 12205*/ /*Scope*/ 50, /*->12256*/
/* 12206*/ OPC_RecordChild1, // #1 = $rs1
/* 12207*/ OPC_Scope, 30, /*->12239*/ // 2 children in Scope
/* 12209*/ OPC_CheckChild1Type, MVT::i32,
/* 12211*/ OPC_Scope, 13, /*->12226*/ // 2 children in Scope
/* 12213*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12215*/ OPC_EmitMergeInputChains1_0,
/* 12216*/ OPC_EmitInteger, MVT::i32, 0,
/* 12219*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (brind GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoBRIND GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 12226*/ /*Scope*/ 11, /*->12238*/
/* 12227*/ OPC_EmitMergeInputChains1_0,
/* 12228*/ OPC_EmitInteger, MVT::i32, 0,
/* 12231*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (brind GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoBRIND GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] })
/* 12238*/ 0, /*End of Scope*/
/* 12239*/ /*Scope*/ 15, /*->12255*/
/* 12240*/ OPC_CheckChild1Type, MVT::i64,
/* 12242*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12244*/ OPC_EmitMergeInputChains1_0,
/* 12245*/ OPC_EmitInteger, MVT::i64, 0,
/* 12248*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBRIND), 0|OPFL_Chain,
2/*#Ops*/, 1, 2,
// Src: (brind GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (PseudoBRIND GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] })
/* 12255*/ 0, /*End of Scope*/
/* 12256*/ 0, /*End of Scope*/
/* 12257*/ /*SwitchOpcode*/ 21, TARGET_VAL(ISD::CALLSEQ_START),// ->12281
/* 12260*/ OPC_RecordNode, // #0 = 'callseq_start' chained node
/* 12261*/ OPC_RecordChild1, // #1 = $amt1
/* 12262*/ OPC_MoveChild1,
/* 12263*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 12266*/ OPC_MoveParent,
/* 12267*/ OPC_RecordChild2, // #2 = $amt2
/* 12268*/ OPC_MoveChild2,
/* 12269*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 12272*/ OPC_MoveParent,
/* 12273*/ OPC_EmitMergeInputChains1_0,
/* 12274*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::ADJCALLSTACKDOWN), 0|OPFL_Chain|OPFL_GlueOutput,
2/*#Ops*/, 1, 2,
// Src: (callseq_start (timm:{ *:[i32] }):$amt1, (timm:{ *:[i32] }):$amt2) - Complexity = 9
// Dst: (ADJCALLSTACKDOWN (timm:{ *:[i32] }):$amt1, (timm:{ *:[i32] }):$amt2)
/* 12281*/ /*SwitchOpcode*/ 22, TARGET_VAL(ISD::CALLSEQ_END),// ->12306
/* 12284*/ OPC_RecordNode, // #0 = 'callseq_end' chained node
/* 12285*/ OPC_CaptureGlueInput,
/* 12286*/ OPC_RecordChild1, // #1 = $amt1
/* 12287*/ OPC_MoveChild1,
/* 12288*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 12291*/ OPC_MoveParent,
/* 12292*/ OPC_RecordChild2, // #2 = $amt2
/* 12293*/ OPC_MoveChild2,
/* 12294*/ OPC_CheckOpcode, TARGET_VAL(ISD::TargetConstant),
/* 12297*/ OPC_MoveParent,
/* 12298*/ OPC_EmitMergeInputChains1_0,
/* 12299*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::ADJCALLSTACKUP), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput,
2/*#Ops*/, 1, 2,
// Src: (callseq_end (timm:{ *:[i32] }):$amt1, (timm:{ *:[i32] }):$amt2) - Complexity = 9
// Dst: (ADJCALLSTACKUP (timm:{ *:[i32] }):$amt1, (timm:{ *:[i32] }):$amt2)
/* 12306*/ /*SwitchOpcode*/ 58|128,15/*1978*/, TARGET_VAL(ISD::SETCC),// ->14288
/* 12310*/ OPC_RecordChild0, // #0 = $rs1
/* 12311*/ OPC_Scope, 13|128,5/*653*/, /*->12967*/ // 4 children in Scope
/* 12314*/ OPC_CheckChild0Type, MVT::i32,
/* 12316*/ OPC_Scope, 68, /*->12386*/ // 2 children in Scope
/* 12318*/ OPC_CheckChild1Integer, 0,
/* 12320*/ OPC_CheckType, MVT::i32,
/* 12322*/ OPC_Scope, 30, /*->12354*/ // 2 children in Scope
/* 12324*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 12326*/ OPC_Scope, 13, /*->12341*/ // 2 children in Scope
/* 12328*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12330*/ OPC_EmitInteger, MVT::i32, 1,
/* 12333*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] }, SETEQ:{ *:[Other] }) - Complexity = 8
// Dst: (SLTIU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 1:{ *:[i32] })
/* 12341*/ /*Scope*/ 11, /*->12353*/
/* 12342*/ OPC_EmitInteger, MVT::i32, 1,
/* 12345*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] }, SETEQ:{ *:[Other] }) - Complexity = 8
// Dst: (SLTIU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 1:{ *:[i32] })
/* 12353*/ 0, /*End of Scope*/
/* 12354*/ /*Scope*/ 30, /*->12385*/
/* 12355*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 12357*/ OPC_Scope, 13, /*->12372*/ // 2 children in Scope
/* 12359*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12361*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12364*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] }, SETNE:{ *:[Other] }) - Complexity = 8
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$rs1)
/* 12372*/ /*Scope*/ 11, /*->12384*/
/* 12373*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12376*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 0:{ *:[i32] }, SETNE:{ *:[Other] }) - Complexity = 8
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$rs1)
/* 12384*/ 0, /*End of Scope*/
/* 12385*/ 0, /*End of Scope*/
/* 12386*/ /*Scope*/ 66|128,4/*578*/, /*->12966*/
/* 12388*/ OPC_RecordChild1, // #1 = $imm12
/* 12389*/ OPC_Scope, 43|128,1/*171*/, /*->12563*/ // 11 children in Scope
/* 12392*/ OPC_MoveChild1,
/* 12393*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 12396*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 12398*/ OPC_MoveParent,
/* 12399*/ OPC_CheckType, MVT::i32,
/* 12401*/ OPC_Scope, 28, /*->12431*/ // 4 children in Scope
/* 12403*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 12405*/ OPC_Scope, 12, /*->12419*/ // 2 children in Scope
/* 12407*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12409*/ OPC_EmitConvertToTarget, 1,
/* 12411*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETLT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12419*/ /*Scope*/ 10, /*->12430*/
/* 12420*/ OPC_EmitConvertToTarget, 1,
/* 12422*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETLT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12430*/ 0, /*End of Scope*/
/* 12431*/ /*Scope*/ 28, /*->12460*/
/* 12432*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 12434*/ OPC_Scope, 12, /*->12448*/ // 2 children in Scope
/* 12436*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12438*/ OPC_EmitConvertToTarget, 1,
/* 12440*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETULT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12448*/ /*Scope*/ 10, /*->12459*/
/* 12449*/ OPC_EmitConvertToTarget, 1,
/* 12451*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETULT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 12459*/ 0, /*End of Scope*/
/* 12460*/ /*Scope*/ 50, /*->12511*/
/* 12461*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 12463*/ OPC_Scope, 23, /*->12488*/ // 2 children in Scope
/* 12465*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12467*/ OPC_EmitConvertToTarget, 1,
/* 12469*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2, // Results = #3
/* 12477*/ OPC_EmitInteger, MVT::i32, 1,
/* 12480*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETEQ:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i32] } (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), 1:{ *:[i32] })
/* 12488*/ /*Scope*/ 21, /*->12510*/
/* 12489*/ OPC_EmitConvertToTarget, 1,
/* 12491*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2, // Results = #3
/* 12499*/ OPC_EmitInteger, MVT::i32, 1,
/* 12502*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 3, 4,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETEQ:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i32] } (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12), 1:{ *:[i32] })
/* 12510*/ 0, /*End of Scope*/
/* 12511*/ /*Scope*/ 50, /*->12562*/
/* 12512*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 12514*/ OPC_Scope, 23, /*->12539*/ // 2 children in Scope
/* 12516*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12518*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12521*/ OPC_EmitConvertToTarget, 1,
/* 12523*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 3, // Results = #4
/* 12531*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 2, 4,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETNE:{ *:[Other] }) - Complexity = 7
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))
/* 12539*/ /*Scope*/ 21, /*->12561*/
/* 12540*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12543*/ OPC_EmitConvertToTarget, 1,
/* 12545*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 3, // Results = #4
/* 12553*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 2, 4,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12, SETNE:{ *:[Other] }) - Complexity = 7
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12))
/* 12561*/ 0, /*End of Scope*/
/* 12562*/ 0, /*End of Scope*/
/* 12563*/ /*Scope*/ 26, /*->12590*/
/* 12564*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 12566*/ OPC_CheckType, MVT::i32,
/* 12568*/ OPC_Scope, 10, /*->12580*/ // 2 children in Scope
/* 12570*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12572*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12580*/ /*Scope*/ 8, /*->12589*/
/* 12581*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12589*/ 0, /*End of Scope*/
/* 12590*/ /*Scope*/ 26, /*->12617*/
/* 12591*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 12593*/ OPC_CheckType, MVT::i32,
/* 12595*/ OPC_Scope, 10, /*->12607*/ // 2 children in Scope
/* 12597*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12599*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12607*/ /*Scope*/ 8, /*->12616*/
/* 12608*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 12616*/ 0, /*End of Scope*/
/* 12617*/ /*Scope*/ 26, /*->12644*/
/* 12618*/ OPC_CheckChild2CondCode, ISD::SETUGT,
/* 12620*/ OPC_CheckType, MVT::i32,
/* 12622*/ OPC_Scope, 10, /*->12634*/ // 2 children in Scope
/* 12624*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12626*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)
/* 12634*/ /*Scope*/ 8, /*->12643*/
/* 12635*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)
/* 12643*/ 0, /*End of Scope*/
/* 12644*/ /*Scope*/ 26, /*->12671*/
/* 12645*/ OPC_CheckChild2CondCode, ISD::SETGT,
/* 12647*/ OPC_CheckType, MVT::i32,
/* 12649*/ OPC_Scope, 10, /*->12661*/ // 2 children in Scope
/* 12651*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12653*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)
/* 12661*/ /*Scope*/ 8, /*->12670*/
/* 12662*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1)
/* 12670*/ 0, /*End of Scope*/
/* 12671*/ /*Scope*/ 48, /*->12720*/
/* 12672*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 12674*/ OPC_CheckType, MVT::i32,
/* 12676*/ OPC_Scope, 21, /*->12699*/ // 2 children in Scope
/* 12678*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12680*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12688*/ OPC_EmitInteger, MVT::i32, 1,
/* 12691*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12699*/ /*Scope*/ 19, /*->12719*/
/* 12700*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12708*/ OPC_EmitInteger, MVT::i32, 1,
/* 12711*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12719*/ 0, /*End of Scope*/
/* 12720*/ /*Scope*/ 48, /*->12769*/
/* 12721*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 12723*/ OPC_CheckType, MVT::i32,
/* 12725*/ OPC_Scope, 21, /*->12748*/ // 2 children in Scope
/* 12727*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12729*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12732*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #3
/* 12740*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETNE:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2))
/* 12748*/ /*Scope*/ 19, /*->12768*/
/* 12749*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 12752*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #3
/* 12760*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETNE:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i32] } X0:{ *:[i32] }, (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2))
/* 12768*/ 0, /*End of Scope*/
/* 12769*/ /*Scope*/ 48, /*->12818*/
/* 12770*/ OPC_CheckChild2CondCode, ISD::SETUGE,
/* 12772*/ OPC_CheckType, MVT::i32,
/* 12774*/ OPC_Scope, 21, /*->12797*/ // 2 children in Scope
/* 12776*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12778*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12786*/ OPC_EmitInteger, MVT::i32, 1,
/* 12789*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12797*/ /*Scope*/ 19, /*->12817*/
/* 12798*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12806*/ OPC_EmitInteger, MVT::i32, 1,
/* 12809*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12817*/ 0, /*End of Scope*/
/* 12818*/ /*Scope*/ 48, /*->12867*/
/* 12819*/ OPC_CheckChild2CondCode, ISD::SETULE,
/* 12821*/ OPC_CheckType, MVT::i32,
/* 12823*/ OPC_Scope, 21, /*->12846*/ // 2 children in Scope
/* 12825*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12827*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0, // Results = #2
/* 12835*/ OPC_EmitInteger, MVT::i32, 1,
/* 12838*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1), 1:{ *:[i32] })
/* 12846*/ /*Scope*/ 19, /*->12866*/
/* 12847*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i32, 2/*#Ops*/, 1, 0, // Results = #2
/* 12855*/ OPC_EmitInteger, MVT::i32, 1,
/* 12858*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLTU:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1), 1:{ *:[i32] })
/* 12866*/ 0, /*End of Scope*/
/* 12867*/ /*Scope*/ 48, /*->12916*/
/* 12868*/ OPC_CheckChild2CondCode, ISD::SETGE,
/* 12870*/ OPC_CheckType, MVT::i32,
/* 12872*/ OPC_Scope, 21, /*->12895*/ // 2 children in Scope
/* 12874*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12876*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12884*/ OPC_EmitInteger, MVT::i32, 1,
/* 12887*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12895*/ /*Scope*/ 19, /*->12915*/
/* 12896*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 0, 1, // Results = #2
/* 12904*/ OPC_EmitInteger, MVT::i32, 1,
/* 12907*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2), 1:{ *:[i32] })
/* 12915*/ 0, /*End of Scope*/
/* 12916*/ /*Scope*/ 48, /*->12965*/
/* 12917*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 12919*/ OPC_CheckType, MVT::i32,
/* 12921*/ OPC_Scope, 21, /*->12944*/ // 2 children in Scope
/* 12923*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 12925*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 1, 0, // Results = #2
/* 12933*/ OPC_EmitInteger, MVT::i32, 1,
/* 12936*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1), 1:{ *:[i32] })
/* 12944*/ /*Scope*/ 19, /*->12964*/
/* 12945*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i32, 2/*#Ops*/, 1, 0, // Results = #2
/* 12953*/ OPC_EmitInteger, MVT::i32, 1,
/* 12956*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i32] } (SLT:{ *:[i32] } GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1), 1:{ *:[i32] })
/* 12964*/ 0, /*End of Scope*/
/* 12965*/ 0, /*End of Scope*/
/* 12966*/ 0, /*End of Scope*/
/* 12967*/ /*Scope*/ 102|128,2/*358*/, /*->13327*/
/* 12969*/ OPC_CheckChild0Type, MVT::i64,
/* 12971*/ OPC_Scope, 38, /*->13011*/ // 2 children in Scope
/* 12973*/ OPC_CheckChild1Integer, 0,
/* 12975*/ OPC_CheckType, MVT::i64,
/* 12977*/ OPC_Scope, 15, /*->12994*/ // 2 children in Scope
/* 12979*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 12981*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12983*/ OPC_EmitInteger, MVT::i64, 1,
/* 12986*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] }, SETEQ:{ *:[Other] }) - Complexity = 8
// Dst: (SLTIU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 1:{ *:[i64] })
/* 12994*/ /*Scope*/ 15, /*->13010*/
/* 12995*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 12997*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 12999*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 13002*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 0:{ *:[i64] }, SETNE:{ *:[Other] }) - Complexity = 8
// Dst: (SLTU:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$rs1)
/* 13010*/ 0, /*End of Scope*/
/* 13011*/ /*Scope*/ 57|128,2/*313*/, /*->13326*/
/* 13013*/ OPC_RecordChild1, // #1 = $imm12
/* 13014*/ OPC_Scope, 93, /*->13109*/ // 11 children in Scope
/* 13016*/ OPC_MoveChild1,
/* 13017*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 13020*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 13022*/ OPC_MoveParent,
/* 13023*/ OPC_CheckType, MVT::i64,
/* 13025*/ OPC_Scope, 14, /*->13041*/ // 4 children in Scope
/* 13027*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 13029*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13031*/ OPC_EmitConvertToTarget, 1,
/* 13033*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12, SETLT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 13041*/ /*Scope*/ 14, /*->13056*/
/* 13042*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 13044*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13046*/ OPC_EmitConvertToTarget, 1,
/* 13048*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12, SETULT:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 13056*/ /*Scope*/ 25, /*->13082*/
/* 13057*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 13059*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13061*/ OPC_EmitConvertToTarget, 1,
/* 13063*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 0, 2, // Results = #3
/* 13071*/ OPC_EmitInteger, MVT::i64, 1,
/* 13074*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 3, 4,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12, SETEQ:{ *:[Other] }) - Complexity = 7
// Dst: (SLTIU:{ *:[i64] } (XORI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12), 1:{ *:[i64] })
/* 13082*/ /*Scope*/ 25, /*->13108*/
/* 13083*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 13085*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13087*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 13090*/ OPC_EmitConvertToTarget, 1,
/* 13092*/ OPC_EmitNode1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 0, 3, // Results = #4
/* 13100*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 2, 4,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12, SETNE:{ *:[Other] }) - Complexity = 7
// Dst: (SLTU:{ *:[i64] } X0:{ *:[i64] }, (XORI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12))
/* 13108*/ 0, /*End of Scope*/
/* 13109*/ /*Scope*/ 14, /*->13124*/
/* 13110*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 13112*/ OPC_CheckType, MVT::i64,
/* 13114*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13116*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 13124*/ /*Scope*/ 14, /*->13139*/
/* 13125*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 13127*/ OPC_CheckType, MVT::i64,
/* 13129*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13131*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETULT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 13139*/ /*Scope*/ 14, /*->13154*/
/* 13140*/ OPC_CheckChild2CondCode, ISD::SETUGT,
/* 13142*/ OPC_CheckType, MVT::i64,
/* 13144*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13146*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETUGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i64] } GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)
/* 13154*/ /*Scope*/ 14, /*->13169*/
/* 13155*/ OPC_CheckChild2CondCode, ISD::SETGT,
/* 13157*/ OPC_CheckType, MVT::i64,
/* 13159*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13161*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLT), 0,
MVT::i64, 2/*#Ops*/, 1, 0,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETGT:{ *:[Other] }) - Complexity = 3
// Dst: (SLT:{ *:[i64] } GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1)
/* 13169*/ /*Scope*/ 25, /*->13195*/
/* 13170*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 13172*/ OPC_CheckType, MVT::i64,
/* 13174*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13176*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i64, 2/*#Ops*/, 0, 1, // Results = #2
/* 13184*/ OPC_EmitInteger, MVT::i64, 1,
/* 13187*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i64] } (XOR:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), 1:{ *:[i64] })
/* 13195*/ /*Scope*/ 25, /*->13221*/
/* 13196*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 13198*/ OPC_CheckType, MVT::i64,
/* 13200*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13202*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 13205*/ OPC_EmitNode1, TARGET_VAL(RISCV::XOR), 0,
MVT::i64, 2/*#Ops*/, 0, 1, // Results = #3
/* 13213*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETNE:{ *:[Other] }) - Complexity = 3
// Dst: (SLTU:{ *:[i64] } X0:{ *:[i64] }, (XOR:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2))
/* 13221*/ /*Scope*/ 25, /*->13247*/
/* 13222*/ OPC_CheckChild2CondCode, ISD::SETUGE,
/* 13224*/ OPC_CheckType, MVT::i64,
/* 13226*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13228*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 0, 1, // Results = #2
/* 13236*/ OPC_EmitInteger, MVT::i64, 1,
/* 13239*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETUGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i64] } (SLTU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), 1:{ *:[i64] })
/* 13247*/ /*Scope*/ 25, /*->13273*/
/* 13248*/ OPC_CheckChild2CondCode, ISD::SETULE,
/* 13250*/ OPC_CheckType, MVT::i64,
/* 13252*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13254*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLTU), 0,
MVT::i64, 2/*#Ops*/, 1, 0, // Results = #2
/* 13262*/ OPC_EmitInteger, MVT::i64, 1,
/* 13265*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETULE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i64] } (SLTU:{ *:[i64] } GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1), 1:{ *:[i64] })
/* 13273*/ /*Scope*/ 25, /*->13299*/
/* 13274*/ OPC_CheckChild2CondCode, ISD::SETGE,
/* 13276*/ OPC_CheckType, MVT::i64,
/* 13278*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13280*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i64, 2/*#Ops*/, 0, 1, // Results = #2
/* 13288*/ OPC_EmitInteger, MVT::i64, 1,
/* 13291*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETGE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i64] } (SLT:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2), 1:{ *:[i64] })
/* 13299*/ /*Scope*/ 25, /*->13325*/
/* 13300*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 13302*/ OPC_CheckType, MVT::i64,
/* 13304*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 13306*/ OPC_EmitNode1, TARGET_VAL(RISCV::SLT), 0,
MVT::i64, 2/*#Ops*/, 1, 0, // Results = #2
/* 13314*/ OPC_EmitInteger, MVT::i64, 1,
/* 13317*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (XORI:{ *:[i64] } (SLT:{ *:[i64] } GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1), 1:{ *:[i64] })
/* 13325*/ 0, /*End of Scope*/
/* 13326*/ 0, /*End of Scope*/
/* 13327*/ /*Scope*/ 94|128,3/*478*/, /*->13807*/
/* 13329*/ OPC_CheckChild0Type, MVT::f32,
/* 13331*/ OPC_RecordChild1, // #1 = $rs2
/* 13332*/ OPC_Scope, 42, /*->13376*/ // 8 children in Scope
/* 13334*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 13336*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13363
/* 13339*/ OPC_Scope, 10, /*->13351*/ // 2 children in Scope
/* 13341*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13343*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13351*/ /*Scope*/ 10, /*->13362*/
/* 13352*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13354*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13362*/ 0, /*End of Scope*/
/* 13363*/ /*SwitchType*/ 10, MVT::i64,// ->13375
/* 13365*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13367*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13375*/ 0, // EndSwitchType
/* 13376*/ /*Scope*/ 42, /*->13419*/
/* 13377*/ OPC_CheckChild2CondCode, ISD::SETOEQ,
/* 13379*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13406
/* 13382*/ OPC_Scope, 10, /*->13394*/ // 2 children in Scope
/* 13384*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13386*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13394*/ /*Scope*/ 10, /*->13405*/
/* 13395*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13397*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13405*/ 0, /*End of Scope*/
/* 13406*/ /*SwitchType*/ 10, MVT::i64,// ->13418
/* 13408*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13410*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13418*/ 0, // EndSwitchType
/* 13419*/ /*Scope*/ 42, /*->13462*/
/* 13420*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 13422*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13449
/* 13425*/ OPC_Scope, 10, /*->13437*/ // 2 children in Scope
/* 13427*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13429*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13437*/ /*Scope*/ 10, /*->13448*/
/* 13438*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13440*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13448*/ 0, /*End of Scope*/
/* 13449*/ /*SwitchType*/ 10, MVT::i64,// ->13461
/* 13451*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13453*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13461*/ 0, // EndSwitchType
/* 13462*/ /*Scope*/ 42, /*->13505*/
/* 13463*/ OPC_CheckChild2CondCode, ISD::SETOLT,
/* 13465*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13492
/* 13468*/ OPC_Scope, 10, /*->13480*/ // 2 children in Scope
/* 13470*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13472*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13480*/ /*Scope*/ 10, /*->13491*/
/* 13481*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13483*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13491*/ 0, /*End of Scope*/
/* 13492*/ /*SwitchType*/ 10, MVT::i64,// ->13504
/* 13494*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13496*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13504*/ 0, // EndSwitchType
/* 13505*/ /*Scope*/ 42, /*->13548*/
/* 13506*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 13508*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13535
/* 13511*/ OPC_Scope, 10, /*->13523*/ // 2 children in Scope
/* 13513*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13515*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13523*/ /*Scope*/ 10, /*->13534*/
/* 13524*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13526*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13534*/ 0, /*End of Scope*/
/* 13535*/ /*SwitchType*/ 10, MVT::i64,// ->13547
/* 13537*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13539*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13547*/ 0, // EndSwitchType
/* 13548*/ /*Scope*/ 42, /*->13591*/
/* 13549*/ OPC_CheckChild2CondCode, ISD::SETOLE,
/* 13551*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13578
/* 13554*/ OPC_Scope, 10, /*->13566*/ // 2 children in Scope
/* 13556*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13558*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13566*/ /*Scope*/ 10, /*->13577*/
/* 13567*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13569*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13577*/ 0, /*End of Scope*/
/* 13578*/ /*SwitchType*/ 10, MVT::i64,// ->13590
/* 13580*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13582*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 13590*/ 0, // EndSwitchType
/* 13591*/ /*Scope*/ 90, /*->13682*/
/* 13592*/ OPC_CheckChild2CondCode, ISD::SETO,
/* 13594*/ OPC_SwitchType /*2 cases */, 56, MVT::i32,// ->13653
/* 13597*/ OPC_Scope, 26, /*->13625*/ // 2 children in Scope
/* 13599*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13601*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 13609*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 13617*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i32] } (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2))
/* 13625*/ /*Scope*/ 26, /*->13652*/
/* 13626*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13628*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 13636*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 13644*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i32] } (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2))
/* 13652*/ 0, /*End of Scope*/
/* 13653*/ /*SwitchType*/ 26, MVT::i64,// ->13681
/* 13655*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13657*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 0, 0, // Results = #2
/* 13665*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 1, 1, // Results = #3
/* 13673*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i64] } (FEQ_S:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i64] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2))
/* 13681*/ 0, // EndSwitchType
/* 13682*/ /*Scope*/ 123, /*->13806*/
/* 13683*/ OPC_CheckChild2CondCode, ISD::SETUO,
/* 13685*/ OPC_SwitchType /*2 cases */, 78, MVT::i32,// ->13766
/* 13688*/ OPC_Scope, 37, /*->13727*/ // 2 children in Scope
/* 13690*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13692*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 13700*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 13708*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3, // Results = #4
/* 13716*/ OPC_EmitInteger, MVT::i32, 1,
/* 13719*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (AND:{ *:[i32] } (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2)), 1:{ *:[i32] })
/* 13727*/ /*Scope*/ 37, /*->13765*/
/* 13728*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 13730*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 13738*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 13746*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3, // Results = #4
/* 13754*/ OPC_EmitInteger, MVT::i32, 1,
/* 13757*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (AND:{ *:[i32] } (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i32] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2)), 1:{ *:[i32] })
/* 13765*/ 0, /*End of Scope*/
/* 13766*/ /*SwitchType*/ 37, MVT::i64,// ->13805
/* 13768*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13770*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 0, 0, // Results = #2
/* 13778*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_S), 0,
MVT::i64, 2/*#Ops*/, 1, 1, // Results = #3
/* 13786*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i64, 2/*#Ops*/, 2, 3, // Results = #4
/* 13794*/ OPC_EmitInteger, MVT::i64, 1,
/* 13797*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i64] } (AND:{ *:[i64] } (FEQ_S:{ *:[i64] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs1), (FEQ_S:{ *:[i64] } FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs2)), 1:{ *:[i64] })
/* 13805*/ 0, // EndSwitchType
/* 13806*/ 0, /*End of Scope*/
/* 13807*/ /*Scope*/ 94|128,3/*478*/, /*->14287*/
/* 13809*/ OPC_CheckChild0Type, MVT::f64,
/* 13811*/ OPC_RecordChild1, // #1 = $rs2
/* 13812*/ OPC_Scope, 42, /*->13856*/ // 8 children in Scope
/* 13814*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 13816*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13843
/* 13819*/ OPC_Scope, 10, /*->13831*/ // 2 children in Scope
/* 13821*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13823*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13831*/ /*Scope*/ 10, /*->13842*/
/* 13832*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 13834*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13842*/ 0, /*End of Scope*/
/* 13843*/ /*SwitchType*/ 10, MVT::i64,// ->13855
/* 13845*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13847*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13855*/ 0, // EndSwitchType
/* 13856*/ /*Scope*/ 42, /*->13899*/
/* 13857*/ OPC_CheckChild2CondCode, ISD::SETOEQ,
/* 13859*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13886
/* 13862*/ OPC_Scope, 10, /*->13874*/ // 2 children in Scope
/* 13864*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13866*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13874*/ /*Scope*/ 10, /*->13885*/
/* 13875*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 13877*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13885*/ 0, /*End of Scope*/
/* 13886*/ /*SwitchType*/ 10, MVT::i64,// ->13898
/* 13888*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13890*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOEQ:{ *:[Other] }) - Complexity = 3
// Dst: (FEQ_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13898*/ 0, // EndSwitchType
/* 13899*/ /*Scope*/ 42, /*->13942*/
/* 13900*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 13902*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13929
/* 13905*/ OPC_Scope, 10, /*->13917*/ // 2 children in Scope
/* 13907*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13909*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13917*/ /*Scope*/ 10, /*->13928*/
/* 13918*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 13920*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13928*/ 0, /*End of Scope*/
/* 13929*/ /*SwitchType*/ 10, MVT::i64,// ->13941
/* 13931*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13933*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13941*/ 0, // EndSwitchType
/* 13942*/ /*Scope*/ 42, /*->13985*/
/* 13943*/ OPC_CheckChild2CondCode, ISD::SETOLT,
/* 13945*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->13972
/* 13948*/ OPC_Scope, 10, /*->13960*/ // 2 children in Scope
/* 13950*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13952*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13960*/ /*Scope*/ 10, /*->13971*/
/* 13961*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 13963*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13971*/ 0, /*End of Scope*/
/* 13972*/ /*SwitchType*/ 10, MVT::i64,// ->13984
/* 13974*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 13976*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLT_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLT:{ *:[Other] }) - Complexity = 3
// Dst: (FLT_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 13984*/ 0, // EndSwitchType
/* 13985*/ /*Scope*/ 42, /*->14028*/
/* 13986*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 13988*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->14015
/* 13991*/ OPC_Scope, 10, /*->14003*/ // 2 children in Scope
/* 13993*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 13995*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14003*/ /*Scope*/ 10, /*->14014*/
/* 14004*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 14006*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14014*/ 0, /*End of Scope*/
/* 14015*/ /*SwitchType*/ 10, MVT::i64,// ->14027
/* 14017*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 14019*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14027*/ 0, // EndSwitchType
/* 14028*/ /*Scope*/ 42, /*->14071*/
/* 14029*/ OPC_CheckChild2CondCode, ISD::SETOLE,
/* 14031*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->14058
/* 14034*/ OPC_Scope, 10, /*->14046*/ // 2 children in Scope
/* 14036*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 14038*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14046*/ /*Scope*/ 10, /*->14057*/
/* 14047*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 14049*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i32] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14057*/ 0, /*End of Scope*/
/* 14058*/ /*SwitchType*/ 10, MVT::i64,// ->14070
/* 14060*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 14062*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FLE_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETOLE:{ *:[Other] }) - Complexity = 3
// Dst: (FLE_D:{ *:[i64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 14070*/ 0, // EndSwitchType
/* 14071*/ /*Scope*/ 90, /*->14162*/
/* 14072*/ OPC_CheckChild2CondCode, ISD::SETO,
/* 14074*/ OPC_SwitchType /*2 cases */, 56, MVT::i32,// ->14133
/* 14077*/ OPC_Scope, 26, /*->14105*/ // 2 children in Scope
/* 14079*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 14081*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 14089*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 14097*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i32] } (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2))
/* 14105*/ /*Scope*/ 26, /*->14132*/
/* 14106*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 14108*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 14116*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 14124*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i32] } (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2))
/* 14132*/ 0, /*End of Scope*/
/* 14133*/ /*SwitchType*/ 26, MVT::i64,// ->14161
/* 14135*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 14137*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 0, 0, // Results = #2
/* 14145*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 1, 1, // Results = #3
/* 14153*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AND), 0,
MVT::i64, 2/*#Ops*/, 2, 3,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETO:{ *:[Other] }) - Complexity = 3
// Dst: (AND:{ *:[i64] } (FEQ_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2))
/* 14161*/ 0, // EndSwitchType
/* 14162*/ /*Scope*/ 123, /*->14286*/
/* 14163*/ OPC_CheckChild2CondCode, ISD::SETUO,
/* 14165*/ OPC_SwitchType /*2 cases */, 78, MVT::i32,// ->14246
/* 14168*/ OPC_Scope, 37, /*->14207*/ // 2 children in Scope
/* 14170*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 14172*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 14180*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 14188*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3, // Results = #4
/* 14196*/ OPC_EmitInteger, MVT::i32, 1,
/* 14199*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (AND:{ *:[i32] } (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2)), 1:{ *:[i32] })
/* 14207*/ /*Scope*/ 37, /*->14245*/
/* 14208*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 14210*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 0, 0, // Results = #2
/* 14218*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i32, 2/*#Ops*/, 1, 1, // Results = #3
/* 14226*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i32, 2/*#Ops*/, 2, 3, // Results = #4
/* 14234*/ OPC_EmitInteger, MVT::i32, 1,
/* 14237*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i32, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i32] } (AND:{ *:[i32] } (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2)), 1:{ *:[i32] })
/* 14245*/ 0, /*End of Scope*/
/* 14246*/ /*SwitchType*/ 37, MVT::i64,// ->14285
/* 14248*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 14250*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 0, 0, // Results = #2
/* 14258*/ OPC_EmitNode1, TARGET_VAL(RISCV::FEQ_D), 0,
MVT::i64, 2/*#Ops*/, 1, 1, // Results = #3
/* 14266*/ OPC_EmitNode1, TARGET_VAL(RISCV::AND), 0,
MVT::i64, 2/*#Ops*/, 2, 3, // Results = #4
/* 14274*/ OPC_EmitInteger, MVT::i64, 1,
/* 14277*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLTIU), 0,
MVT::i64, 2/*#Ops*/, 4, 5,
// Src: (setcc:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, SETUO:{ *:[Other] }) - Complexity = 3
// Dst: (SLTIU:{ *:[i64] } (AND:{ *:[i64] } (FEQ_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs1), (FEQ_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs2)), 1:{ *:[i64] })
/* 14285*/ 0, // EndSwitchType
/* 14286*/ 0, /*End of Scope*/
/* 14287*/ 0, /*End of Scope*/
/* 14288*/ /*SwitchOpcode*/ 94, TARGET_VAL(ISD::XOR),// ->14385
/* 14291*/ OPC_RecordChild0, // #0 = $rs1
/* 14292*/ OPC_RecordChild1, // #1 = $imm12
/* 14293*/ OPC_Scope, 51, /*->14346*/ // 3 children in Scope
/* 14295*/ OPC_MoveChild1,
/* 14296*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 14299*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 14301*/ OPC_MoveParent,
/* 14302*/ OPC_SwitchType /*2 cases */, 26, MVT::i32,// ->14331
/* 14305*/ OPC_Scope, 12, /*->14319*/ // 2 children in Scope
/* 14307*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14309*/ OPC_EmitConvertToTarget, 1,
/* 14311*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 14319*/ /*Scope*/ 10, /*->14330*/
/* 14320*/ OPC_EmitConvertToTarget, 1,
/* 14322*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i32, 2/*#Ops*/, 0, 2,
// Src: (xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (XORI:{ *:[i32] } GPR:{ *:[i32] }:$rs1, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm12)
/* 14330*/ 0, /*End of Scope*/
/* 14331*/ /*SwitchType*/ 12, MVT::i64,// ->14345
/* 14333*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14335*/ OPC_EmitConvertToTarget, 1,
/* 14337*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XORI), 0,
MVT::i64, 2/*#Ops*/, 0, 2,
// Src: (xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12) - Complexity = 7
// Dst: (XORI:{ *:[i64] } GPR:{ *:[i64] }:$rs1, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm12)
/* 14345*/ 0, // EndSwitchType
/* 14346*/ /*Scope*/ 24, /*->14371*/
/* 14347*/ OPC_CheckType, MVT::i32,
/* 14349*/ OPC_Scope, 10, /*->14361*/ // 2 children in Scope
/* 14351*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14353*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 14361*/ /*Scope*/ 8, /*->14370*/
/* 14362*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XOR), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (XOR:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 14370*/ 0, /*End of Scope*/
/* 14371*/ /*Scope*/ 12, /*->14384*/
/* 14372*/ OPC_CheckType, MVT::i64,
/* 14374*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14376*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::XOR), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (XOR:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 14384*/ 0, /*End of Scope*/
/* 14385*/ /*SwitchOpcode*/ 17, TARGET_VAL(ISD::AssertSext),// ->14405
/* 14388*/ OPC_MoveChild0,
/* 14389*/ OPC_CheckOpcode, TARGET_VAL(RISCVISD::FMV_X_ANYEXTW_RV64),
/* 14392*/ OPC_RecordChild0, // #0 = $src
/* 14393*/ OPC_MoveParent,
/* 14394*/ OPC_CheckPredicate, 0, // Predicate_assertsexti32
/* 14396*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 14398*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i64, 1/*#Ops*/, 0,
// Src: (assertsext:{ *:[i64] } (riscv_fmv_x_anyextw_rv64:{ *:[i64] } FPR32:{ *:[f32] }:$src))<<P:Predicate_assertsexti32>> - Complexity = 7
// Dst: (FMV_X_W:{ *:[i64] } FPR32:{ *:[f32] }:$src)
/* 14405*/ /*SwitchOpcode*/ 4|128,5/*644*/, TARGET_VAL(ISD::BRCOND),// ->15053
/* 14409*/ OPC_RecordNode, // #0 = 'brcond' chained node
/* 14410*/ OPC_Scope, 61|128,4/*573*/, /*->14986*/ // 2 children in Scope
/* 14413*/ OPC_MoveChild1,
/* 14414*/ OPC_CheckOpcode, TARGET_VAL(ISD::SETCC),
/* 14417*/ OPC_RecordChild0, // #1 = $rs1
/* 14418*/ OPC_SwitchType /*2 cases */, 89|128,2/*345*/, MVT::i32,// ->14767
/* 14422*/ OPC_CheckChild0Type, MVT::i32,
/* 14424*/ OPC_RecordChild1, // #2 = $rs2
/* 14425*/ OPC_Scope, 33, /*->14460*/ // 10 children in Scope
/* 14427*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 14429*/ OPC_MoveParent,
/* 14430*/ OPC_RecordChild2, // #3 = $imm12
/* 14431*/ OPC_MoveChild2,
/* 14432*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14435*/ OPC_MoveParent,
/* 14436*/ OPC_Scope, 11, /*->14449*/ // 2 children in Scope
/* 14438*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14440*/ OPC_EmitMergeInputChains1_0,
/* 14441*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BEQ), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETEQ:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BEQ GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14449*/ /*Scope*/ 9, /*->14459*/
/* 14450*/ OPC_EmitMergeInputChains1_0,
/* 14451*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BEQ), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETEQ:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BEQ GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14459*/ 0, /*End of Scope*/
/* 14460*/ /*Scope*/ 33, /*->14494*/
/* 14461*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 14463*/ OPC_MoveParent,
/* 14464*/ OPC_RecordChild2, // #3 = $imm12
/* 14465*/ OPC_MoveChild2,
/* 14466*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14469*/ OPC_MoveParent,
/* 14470*/ OPC_Scope, 11, /*->14483*/ // 2 children in Scope
/* 14472*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14474*/ OPC_EmitMergeInputChains1_0,
/* 14475*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETNE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BNE GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14483*/ /*Scope*/ 9, /*->14493*/
/* 14484*/ OPC_EmitMergeInputChains1_0,
/* 14485*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETNE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BNE GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14493*/ 0, /*End of Scope*/
/* 14494*/ /*Scope*/ 33, /*->14528*/
/* 14495*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 14497*/ OPC_MoveParent,
/* 14498*/ OPC_RecordChild2, // #3 = $imm12
/* 14499*/ OPC_MoveChild2,
/* 14500*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14503*/ OPC_MoveParent,
/* 14504*/ OPC_Scope, 11, /*->14517*/ // 2 children in Scope
/* 14506*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14508*/ OPC_EmitMergeInputChains1_0,
/* 14509*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14517*/ /*Scope*/ 9, /*->14527*/
/* 14518*/ OPC_EmitMergeInputChains1_0,
/* 14519*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14527*/ 0, /*End of Scope*/
/* 14528*/ /*Scope*/ 33, /*->14562*/
/* 14529*/ OPC_CheckChild2CondCode, ISD::SETGE,
/* 14531*/ OPC_MoveParent,
/* 14532*/ OPC_RecordChild2, // #3 = $imm12
/* 14533*/ OPC_MoveChild2,
/* 14534*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14537*/ OPC_MoveParent,
/* 14538*/ OPC_Scope, 11, /*->14551*/ // 2 children in Scope
/* 14540*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14542*/ OPC_EmitMergeInputChains1_0,
/* 14543*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14551*/ /*Scope*/ 9, /*->14561*/
/* 14552*/ OPC_EmitMergeInputChains1_0,
/* 14553*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14561*/ 0, /*End of Scope*/
/* 14562*/ /*Scope*/ 33, /*->14596*/
/* 14563*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 14565*/ OPC_MoveParent,
/* 14566*/ OPC_RecordChild2, // #3 = $imm12
/* 14567*/ OPC_MoveChild2,
/* 14568*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14571*/ OPC_MoveParent,
/* 14572*/ OPC_Scope, 11, /*->14585*/ // 2 children in Scope
/* 14574*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14576*/ OPC_EmitMergeInputChains1_0,
/* 14577*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14585*/ /*Scope*/ 9, /*->14595*/
/* 14586*/ OPC_EmitMergeInputChains1_0,
/* 14587*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14595*/ 0, /*End of Scope*/
/* 14596*/ /*Scope*/ 33, /*->14630*/
/* 14597*/ OPC_CheckChild2CondCode, ISD::SETUGE,
/* 14599*/ OPC_MoveParent,
/* 14600*/ OPC_RecordChild2, // #3 = $imm12
/* 14601*/ OPC_MoveChild2,
/* 14602*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14605*/ OPC_MoveParent,
/* 14606*/ OPC_Scope, 11, /*->14619*/ // 2 children in Scope
/* 14608*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14610*/ OPC_EmitMergeInputChains1_0,
/* 14611*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14619*/ /*Scope*/ 9, /*->14629*/
/* 14620*/ OPC_EmitMergeInputChains1_0,
/* 14621*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14629*/ 0, /*End of Scope*/
/* 14630*/ /*Scope*/ 33, /*->14664*/
/* 14631*/ OPC_CheckChild2CondCode, ISD::SETGT,
/* 14633*/ OPC_MoveParent,
/* 14634*/ OPC_RecordChild2, // #3 = $imm12
/* 14635*/ OPC_MoveChild2,
/* 14636*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14639*/ OPC_MoveParent,
/* 14640*/ OPC_Scope, 11, /*->14653*/ // 2 children in Scope
/* 14642*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14644*/ OPC_EmitMergeInputChains1_0,
/* 14645*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14653*/ /*Scope*/ 9, /*->14663*/
/* 14654*/ OPC_EmitMergeInputChains1_0,
/* 14655*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14663*/ 0, /*End of Scope*/
/* 14664*/ /*Scope*/ 33, /*->14698*/
/* 14665*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 14667*/ OPC_MoveParent,
/* 14668*/ OPC_RecordChild2, // #3 = $imm12
/* 14669*/ OPC_MoveChild2,
/* 14670*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14673*/ OPC_MoveParent,
/* 14674*/ OPC_Scope, 11, /*->14687*/ // 2 children in Scope
/* 14676*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14678*/ OPC_EmitMergeInputChains1_0,
/* 14679*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14687*/ /*Scope*/ 9, /*->14697*/
/* 14688*/ OPC_EmitMergeInputChains1_0,
/* 14689*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETLE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14697*/ 0, /*End of Scope*/
/* 14698*/ /*Scope*/ 33, /*->14732*/
/* 14699*/ OPC_CheckChild2CondCode, ISD::SETUGT,
/* 14701*/ OPC_MoveParent,
/* 14702*/ OPC_RecordChild2, // #3 = $imm12
/* 14703*/ OPC_MoveChild2,
/* 14704*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14707*/ OPC_MoveParent,
/* 14708*/ OPC_Scope, 11, /*->14721*/ // 2 children in Scope
/* 14710*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14712*/ OPC_EmitMergeInputChains1_0,
/* 14713*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14721*/ /*Scope*/ 9, /*->14731*/
/* 14722*/ OPC_EmitMergeInputChains1_0,
/* 14723*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETUGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14731*/ 0, /*End of Scope*/
/* 14732*/ /*Scope*/ 33, /*->14766*/
/* 14733*/ OPC_CheckChild2CondCode, ISD::SETULE,
/* 14735*/ OPC_MoveParent,
/* 14736*/ OPC_RecordChild2, // #3 = $imm12
/* 14737*/ OPC_MoveChild2,
/* 14738*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14741*/ OPC_MoveParent,
/* 14742*/ OPC_Scope, 11, /*->14755*/ // 2 children in Scope
/* 14744*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 14746*/ OPC_EmitMergeInputChains1_0,
/* 14747*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14755*/ /*Scope*/ 9, /*->14765*/
/* 14756*/ OPC_EmitMergeInputChains1_0,
/* 14757*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2, SETULE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i32] }:$rs2, GPR:{ *:[i32] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14765*/ 0, /*End of Scope*/
/* 14766*/ 0, /*End of Scope*/
/* 14767*/ /*SwitchType*/ 87|128,1/*215*/, MVT::i64,// ->14985
/* 14770*/ OPC_CheckChild0Type, MVT::i64,
/* 14772*/ OPC_RecordChild1, // #2 = $rs2
/* 14773*/ OPC_Scope, 20, /*->14795*/ // 10 children in Scope
/* 14775*/ OPC_CheckChild2CondCode, ISD::SETEQ,
/* 14777*/ OPC_MoveParent,
/* 14778*/ OPC_RecordChild2, // #3 = $imm12
/* 14779*/ OPC_MoveChild2,
/* 14780*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14783*/ OPC_MoveParent,
/* 14784*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14786*/ OPC_EmitMergeInputChains1_0,
/* 14787*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BEQ), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETEQ:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BEQ GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14795*/ /*Scope*/ 20, /*->14816*/
/* 14796*/ OPC_CheckChild2CondCode, ISD::SETNE,
/* 14798*/ OPC_MoveParent,
/* 14799*/ OPC_RecordChild2, // #3 = $imm12
/* 14800*/ OPC_MoveChild2,
/* 14801*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14804*/ OPC_MoveParent,
/* 14805*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14807*/ OPC_EmitMergeInputChains1_0,
/* 14808*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETNE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BNE GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14816*/ /*Scope*/ 20, /*->14837*/
/* 14817*/ OPC_CheckChild2CondCode, ISD::SETLT,
/* 14819*/ OPC_MoveParent,
/* 14820*/ OPC_RecordChild2, // #3 = $imm12
/* 14821*/ OPC_MoveChild2,
/* 14822*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14825*/ OPC_MoveParent,
/* 14826*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14828*/ OPC_EmitMergeInputChains1_0,
/* 14829*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETLT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14837*/ /*Scope*/ 20, /*->14858*/
/* 14838*/ OPC_CheckChild2CondCode, ISD::SETGE,
/* 14840*/ OPC_MoveParent,
/* 14841*/ OPC_RecordChild2, // #3 = $imm12
/* 14842*/ OPC_MoveChild2,
/* 14843*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14846*/ OPC_MoveParent,
/* 14847*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14849*/ OPC_EmitMergeInputChains1_0,
/* 14850*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14858*/ /*Scope*/ 20, /*->14879*/
/* 14859*/ OPC_CheckChild2CondCode, ISD::SETULT,
/* 14861*/ OPC_MoveParent,
/* 14862*/ OPC_RecordChild2, // #3 = $imm12
/* 14863*/ OPC_MoveChild2,
/* 14864*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14867*/ OPC_MoveParent,
/* 14868*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14870*/ OPC_EmitMergeInputChains1_0,
/* 14871*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETULT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14879*/ /*Scope*/ 20, /*->14900*/
/* 14880*/ OPC_CheckChild2CondCode, ISD::SETUGE,
/* 14882*/ OPC_MoveParent,
/* 14883*/ OPC_RecordChild2, // #3 = $imm12
/* 14884*/ OPC_MoveChild2,
/* 14885*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14888*/ OPC_MoveParent,
/* 14889*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14891*/ OPC_EmitMergeInputChains1_0,
/* 14892*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 1, 2, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETUGE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, simm13_lsb0:{ *:[Other] }:$imm12)
/* 14900*/ /*Scope*/ 20, /*->14921*/
/* 14901*/ OPC_CheckChild2CondCode, ISD::SETGT,
/* 14903*/ OPC_MoveParent,
/* 14904*/ OPC_RecordChild2, // #3 = $imm12
/* 14905*/ OPC_MoveChild2,
/* 14906*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14909*/ OPC_MoveParent,
/* 14910*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14912*/ OPC_EmitMergeInputChains1_0,
/* 14913*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLT), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLT GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14921*/ /*Scope*/ 20, /*->14942*/
/* 14922*/ OPC_CheckChild2CondCode, ISD::SETLE,
/* 14924*/ OPC_MoveParent,
/* 14925*/ OPC_RecordChild2, // #3 = $imm12
/* 14926*/ OPC_MoveChild2,
/* 14927*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14930*/ OPC_MoveParent,
/* 14931*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14933*/ OPC_EmitMergeInputChains1_0,
/* 14934*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGE), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETLE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGE GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14942*/ /*Scope*/ 20, /*->14963*/
/* 14943*/ OPC_CheckChild2CondCode, ISD::SETUGT,
/* 14945*/ OPC_MoveParent,
/* 14946*/ OPC_RecordChild2, // #3 = $imm12
/* 14947*/ OPC_MoveChild2,
/* 14948*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14951*/ OPC_MoveParent,
/* 14952*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14954*/ OPC_EmitMergeInputChains1_0,
/* 14955*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BLTU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETUGT:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BLTU GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14963*/ /*Scope*/ 20, /*->14984*/
/* 14964*/ OPC_CheckChild2CondCode, ISD::SETULE,
/* 14966*/ OPC_MoveParent,
/* 14967*/ OPC_RecordChild2, // #3 = $imm12
/* 14968*/ OPC_MoveChild2,
/* 14969*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14972*/ OPC_MoveParent,
/* 14973*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 14975*/ OPC_EmitMergeInputChains1_0,
/* 14976*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BGEU), 0|OPFL_Chain,
3/*#Ops*/, 2, 1, 3,
// Src: (brcond (setcc:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2, SETULE:{ *:[Other] }), (bb:{ *:[Other] }):$imm12) - Complexity = 6
// Dst: (BGEU GPR:{ *:[i64] }:$rs2, GPR:{ *:[i64] }:$rs1, (bb:{ *:[Other] }):$imm12)
/* 14984*/ 0, /*End of Scope*/
/* 14985*/ 0, // EndSwitchType
/* 14986*/ /*Scope*/ 65, /*->15052*/
/* 14987*/ OPC_RecordChild1, // #1 = $cond
/* 14988*/ OPC_Scope, 38, /*->15028*/ // 2 children in Scope
/* 14990*/ OPC_CheckChild1Type, MVT::i32,
/* 14992*/ OPC_RecordChild2, // #2 = $imm12
/* 14993*/ OPC_MoveChild2,
/* 14994*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 14997*/ OPC_MoveParent,
/* 14998*/ OPC_Scope, 14, /*->15014*/ // 2 children in Scope
/* 15000*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15002*/ OPC_EmitMergeInputChains1_0,
/* 15003*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 15006*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 3, 2,
// Src: (brcond GPR:{ *:[i32] }:$cond, (bb:{ *:[Other] }):$imm12) - Complexity = 3
// Dst: (BNE GPR:{ *:[i32] }:$cond, X0:{ *:[i32] }, (bb:{ *:[Other] }):$imm12)
/* 15014*/ /*Scope*/ 12, /*->15027*/
/* 15015*/ OPC_EmitMergeInputChains1_0,
/* 15016*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 15019*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 3, 2,
// Src: (brcond GPR:{ *:[i32] }:$cond, (bb:{ *:[Other] }):$imm12) - Complexity = 3
// Dst: (BNE GPR:{ *:[i32] }:$cond, X0:{ *:[i32] }, (bb:{ *:[Other] }):$imm12)
/* 15027*/ 0, /*End of Scope*/
/* 15028*/ /*Scope*/ 22, /*->15051*/
/* 15029*/ OPC_CheckChild1Type, MVT::i64,
/* 15031*/ OPC_RecordChild2, // #2 = $imm12
/* 15032*/ OPC_MoveChild2,
/* 15033*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 15036*/ OPC_MoveParent,
/* 15037*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15039*/ OPC_EmitMergeInputChains1_0,
/* 15040*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 15043*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::BNE), 0|OPFL_Chain,
3/*#Ops*/, 1, 3, 2,
// Src: (brcond GPR:{ *:[i64] }:$cond, (bb:{ *:[Other] }):$imm12) - Complexity = 3
// Dst: (BNE GPR:{ *:[i64] }:$cond, X0:{ *:[i64] }, (bb:{ *:[Other] }):$imm12)
/* 15051*/ 0, /*End of Scope*/
/* 15052*/ 0, /*End of Scope*/
/* 15053*/ /*SwitchOpcode*/ 124, TARGET_VAL(RISCVISD::CALL),// ->15180
/* 15056*/ OPC_RecordNode, // #0 = 'riscv_call' chained node
/* 15057*/ OPC_CaptureGlueInput,
/* 15058*/ OPC_RecordChild1, // #1 = $func
/* 15059*/ OPC_Scope, 83, /*->15144*/ // 3 children in Scope
/* 15061*/ OPC_MoveChild1,
/* 15062*/ OPC_SwitchOpcode /*2 cases */, 37, TARGET_VAL(ISD::TargetGlobalAddress),// ->15103
/* 15066*/ OPC_SwitchType /*2 cases */, 21, MVT::i32,// ->15090
/* 15069*/ OPC_MoveParent,
/* 15070*/ OPC_Scope, 9, /*->15081*/ // 2 children in Scope
/* 15072*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15074*/ OPC_EmitMergeInputChains1_0,
/* 15075*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (tglobaladdr:{ *:[i32] }):$func) - Complexity = 6
// Dst: (PseudoCALL (tglobaladdr:{ *:[i32] }):$func)
/* 15081*/ /*Scope*/ 7, /*->15089*/
/* 15082*/ OPC_EmitMergeInputChains1_0,
/* 15083*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (tglobaladdr:{ *:[i32] }):$func) - Complexity = 6
// Dst: (PseudoCALL (tglobaladdr:{ *:[i32] }):$func)
/* 15089*/ 0, /*End of Scope*/
/* 15090*/ /*SwitchType*/ 10, MVT::i64,// ->15102
/* 15092*/ OPC_MoveParent,
/* 15093*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15095*/ OPC_EmitMergeInputChains1_0,
/* 15096*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (tglobaladdr:{ *:[i64] }):$func) - Complexity = 6
// Dst: (PseudoCALL (tglobaladdr:{ *:[i64] }):$func)
/* 15102*/ 0, // EndSwitchType
/* 15103*/ /*SwitchOpcode*/ 37, TARGET_VAL(ISD::TargetExternalSymbol),// ->15143
/* 15106*/ OPC_SwitchType /*2 cases */, 21, MVT::i32,// ->15130
/* 15109*/ OPC_MoveParent,
/* 15110*/ OPC_Scope, 9, /*->15121*/ // 2 children in Scope
/* 15112*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15114*/ OPC_EmitMergeInputChains1_0,
/* 15115*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (texternalsym:{ *:[i32] }):$func) - Complexity = 6
// Dst: (PseudoCALL (texternalsym:{ *:[i32] }):$func)
/* 15121*/ /*Scope*/ 7, /*->15129*/
/* 15122*/ OPC_EmitMergeInputChains1_0,
/* 15123*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (texternalsym:{ *:[i32] }):$func) - Complexity = 6
// Dst: (PseudoCALL (texternalsym:{ *:[i32] }):$func)
/* 15129*/ 0, /*End of Scope*/
/* 15130*/ /*SwitchType*/ 10, MVT::i64,// ->15142
/* 15132*/ OPC_MoveParent,
/* 15133*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15135*/ OPC_EmitMergeInputChains1_0,
/* 15136*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call (texternalsym:{ *:[i64] }):$func) - Complexity = 6
// Dst: (PseudoCALL (texternalsym:{ *:[i64] }):$func)
/* 15142*/ 0, // EndSwitchType
/* 15143*/ 0, // EndSwitchOpcode
/* 15144*/ /*Scope*/ 22, /*->15167*/
/* 15145*/ OPC_CheckChild1Type, MVT::i32,
/* 15147*/ OPC_Scope, 9, /*->15158*/ // 2 children in Scope
/* 15149*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15151*/ OPC_EmitMergeInputChains1_0,
/* 15152*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALLIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoCALLIndirect GPR:{ *:[i32] }:$rs1)
/* 15158*/ /*Scope*/ 7, /*->15166*/
/* 15159*/ OPC_EmitMergeInputChains1_0,
/* 15160*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALLIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoCALLIndirect GPR:{ *:[i32] }:$rs1)
/* 15166*/ 0, /*End of Scope*/
/* 15167*/ /*Scope*/ 11, /*->15179*/
/* 15168*/ OPC_CheckChild1Type, MVT::i64,
/* 15170*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15172*/ OPC_EmitMergeInputChains1_0,
/* 15173*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoCALLIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_call GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (PseudoCALLIndirect GPR:{ *:[i64] }:$rs1)
/* 15179*/ 0, /*End of Scope*/
/* 15180*/ /*SwitchOpcode*/ 124, TARGET_VAL(RISCVISD::TAIL),// ->15307
/* 15183*/ OPC_RecordNode, // #0 = 'riscv_tail' chained node
/* 15184*/ OPC_CaptureGlueInput,
/* 15185*/ OPC_RecordChild1, // #1 = $dst
/* 15186*/ OPC_Scope, 83, /*->15271*/ // 3 children in Scope
/* 15188*/ OPC_MoveChild1,
/* 15189*/ OPC_SwitchOpcode /*2 cases */, 37, TARGET_VAL(ISD::TargetGlobalAddress),// ->15230
/* 15193*/ OPC_SwitchType /*2 cases */, 21, MVT::i32,// ->15217
/* 15196*/ OPC_MoveParent,
/* 15197*/ OPC_Scope, 9, /*->15208*/ // 2 children in Scope
/* 15199*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15201*/ OPC_EmitMergeInputChains1_0,
/* 15202*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (tglobaladdr:{ *:[i32] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i32] }):$dst)
/* 15208*/ /*Scope*/ 7, /*->15216*/
/* 15209*/ OPC_EmitMergeInputChains1_0,
/* 15210*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (tglobaladdr:{ *:[i32] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i32] }):$dst)
/* 15216*/ 0, /*End of Scope*/
/* 15217*/ /*SwitchType*/ 10, MVT::i64,// ->15229
/* 15219*/ OPC_MoveParent,
/* 15220*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15222*/ OPC_EmitMergeInputChains1_0,
/* 15223*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (tglobaladdr:{ *:[i64] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i64] }):$dst)
/* 15229*/ 0, // EndSwitchType
/* 15230*/ /*SwitchOpcode*/ 37, TARGET_VAL(ISD::TargetExternalSymbol),// ->15270
/* 15233*/ OPC_SwitchType /*2 cases */, 21, MVT::i32,// ->15257
/* 15236*/ OPC_MoveParent,
/* 15237*/ OPC_Scope, 9, /*->15248*/ // 2 children in Scope
/* 15239*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15241*/ OPC_EmitMergeInputChains1_0,
/* 15242*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (texternalsym:{ *:[i32] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i32] }):$dst)
/* 15248*/ /*Scope*/ 7, /*->15256*/
/* 15249*/ OPC_EmitMergeInputChains1_0,
/* 15250*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (texternalsym:{ *:[i32] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i32] }):$dst)
/* 15256*/ 0, /*End of Scope*/
/* 15257*/ /*SwitchType*/ 10, MVT::i64,// ->15269
/* 15259*/ OPC_MoveParent,
/* 15260*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15262*/ OPC_EmitMergeInputChains1_0,
/* 15263*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAIL), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail (texternalsym:{ *:[i64] }):$dst) - Complexity = 6
// Dst: (PseudoTAIL (texternalsym:{ *:[i64] }):$dst)
/* 15269*/ 0, // EndSwitchType
/* 15270*/ 0, // EndSwitchOpcode
/* 15271*/ /*Scope*/ 22, /*->15294*/
/* 15272*/ OPC_CheckChild1Type, MVT::i32,
/* 15274*/ OPC_Scope, 9, /*->15285*/ // 2 children in Scope
/* 15276*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15278*/ OPC_EmitMergeInputChains1_0,
/* 15279*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAILIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail GPRTC:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoTAILIndirect GPRTC:{ *:[i32] }:$rs1)
/* 15285*/ /*Scope*/ 7, /*->15293*/
/* 15286*/ OPC_EmitMergeInputChains1_0,
/* 15287*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAILIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail GPRTC:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (PseudoTAILIndirect GPRTC:{ *:[i32] }:$rs1)
/* 15293*/ 0, /*End of Scope*/
/* 15294*/ /*Scope*/ 11, /*->15306*/
/* 15295*/ OPC_CheckChild1Type, MVT::i64,
/* 15297*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15299*/ OPC_EmitMergeInputChains1_0,
/* 15300*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoTAILIndirect), 0|OPFL_Chain|OPFL_GlueInput|OPFL_GlueOutput|OPFL_Variadic1,
1/*#Ops*/, 1,
// Src: (riscv_tail GPRTC:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (PseudoTAILIndirect GPRTC:{ *:[i64] }:$rs1)
/* 15306*/ 0, /*End of Scope*/
/* 15307*/ /*SwitchOpcode*/ 65|128,1/*193*/, TARGET_VAL(RISCVISD::SELECT_CC),// ->15504
/* 15311*/ OPC_CaptureGlueInput,
/* 15312*/ OPC_RecordChild0, // #0 = $lhs
/* 15313*/ OPC_Scope, 121, /*->15436*/ // 2 children in Scope
/* 15315*/ OPC_CheckChild0Type, MVT::i32,
/* 15317*/ OPC_RecordChild1, // #1 = $rhs
/* 15318*/ OPC_RecordChild2, // #2 = $imm
/* 15319*/ OPC_MoveChild2,
/* 15320*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 15323*/ OPC_CheckType, MVT::i32,
/* 15325*/ OPC_MoveParent,
/* 15326*/ OPC_RecordChild3, // #3 = $truev
/* 15327*/ OPC_RecordChild4, // #4 = $falsev
/* 15328*/ OPC_SwitchType /*3 cases */, 32, MVT::i32,// ->15363
/* 15331*/ OPC_Scope, 15, /*->15348*/ // 2 children in Scope
/* 15333*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15335*/ OPC_EmitConvertToTarget, 2,
/* 15337*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_GPR_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::i32, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[i32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, GPR:{ *:[i32] }:$truev, GPR:{ *:[i32] }:$falsev) - Complexity = 6
// Dst: (Select_GPR_Using_CC_GPR:{ *:[i32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, GPR:{ *:[i32] }:$truev, GPR:{ *:[i32] }:$falsev)
/* 15348*/ /*Scope*/ 13, /*->15362*/
/* 15349*/ OPC_EmitConvertToTarget, 2,
/* 15351*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_GPR_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::i32, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[i32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, GPR:{ *:[i32] }:$truev, GPR:{ *:[i32] }:$falsev) - Complexity = 6
// Dst: (Select_GPR_Using_CC_GPR:{ *:[i32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, GPR:{ *:[i32] }:$truev, GPR:{ *:[i32] }:$falsev)
/* 15362*/ 0, /*End of Scope*/
/* 15363*/ /*SwitchType*/ 34, MVT::f32,// ->15399
/* 15365*/ OPC_Scope, 15, /*->15382*/ // 2 children in Scope
/* 15367*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15369*/ OPC_EmitConvertToTarget, 2,
/* 15371*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR32_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f32, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev) - Complexity = 6
// Dst: (Select_FPR32_Using_CC_GPR:{ *:[f32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev)
/* 15382*/ /*Scope*/ 15, /*->15398*/
/* 15383*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 15385*/ OPC_EmitConvertToTarget, 2,
/* 15387*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR32_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f32, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev) - Complexity = 6
// Dst: (Select_FPR32_Using_CC_GPR:{ *:[f32] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev)
/* 15398*/ 0, /*End of Scope*/
/* 15399*/ /*SwitchType*/ 34, MVT::f64,// ->15435
/* 15401*/ OPC_Scope, 15, /*->15418*/ // 2 children in Scope
/* 15403*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15405*/ OPC_EmitConvertToTarget, 2,
/* 15407*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR64_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f64, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f64] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev) - Complexity = 6
// Dst: (Select_FPR64_Using_CC_GPR:{ *:[f64] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev)
/* 15418*/ /*Scope*/ 15, /*->15434*/
/* 15419*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 15421*/ OPC_EmitConvertToTarget, 2,
/* 15423*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR64_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f64, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f64] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev) - Complexity = 6
// Dst: (Select_FPR64_Using_CC_GPR:{ *:[f64] } GPR:{ *:[i32] }:$lhs, GPR:{ *:[i32] }:$rhs, (imm:{ *:[i32] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev)
/* 15434*/ 0, /*End of Scope*/
/* 15435*/ 0, // EndSwitchType
/* 15436*/ /*Scope*/ 66, /*->15503*/
/* 15437*/ OPC_CheckChild0Type, MVT::i64,
/* 15439*/ OPC_RecordChild1, // #1 = $rhs
/* 15440*/ OPC_RecordChild2, // #2 = $imm
/* 15441*/ OPC_MoveChild2,
/* 15442*/ OPC_CheckOpcode, TARGET_VAL(ISD::Constant),
/* 15445*/ OPC_CheckType, MVT::i64,
/* 15447*/ OPC_MoveParent,
/* 15448*/ OPC_RecordChild3, // #3 = $truev
/* 15449*/ OPC_RecordChild4, // #4 = $falsev
/* 15450*/ OPC_SwitchType /*3 cases */, 15, MVT::i64,// ->15468
/* 15453*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15455*/ OPC_EmitConvertToTarget, 2,
/* 15457*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_GPR_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::i64, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[i64] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, GPR:{ *:[i64] }:$truev, GPR:{ *:[i64] }:$falsev) - Complexity = 6
// Dst: (Select_GPR_Using_CC_GPR:{ *:[i64] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, GPR:{ *:[i64] }:$truev, GPR:{ *:[i64] }:$falsev)
/* 15468*/ /*SwitchType*/ 15, MVT::f32,// ->15485
/* 15470*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 15472*/ OPC_EmitConvertToTarget, 2,
/* 15474*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR32_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f32, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f32] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev) - Complexity = 6
// Dst: (Select_FPR32_Using_CC_GPR:{ *:[f32] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, FPR32:{ *:[f32] }:$truev, FPR32:{ *:[f32] }:$falsev)
/* 15485*/ /*SwitchType*/ 15, MVT::f64,// ->15502
/* 15487*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 15489*/ OPC_EmitConvertToTarget, 2,
/* 15491*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::Select_FPR64_Using_CC_GPR), 0|OPFL_GlueInput,
MVT::f64, 5/*#Ops*/, 0, 1, 5, 3, 4,
// Src: (riscv_selectcc:{ *:[f64] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev) - Complexity = 6
// Dst: (Select_FPR64_Using_CC_GPR:{ *:[f64] } GPR:{ *:[i64] }:$lhs, GPR:{ *:[i64] }:$rhs, (imm:{ *:[i64] }):$imm, FPR64:{ *:[f64] }:$truev, FPR64:{ *:[f64] }:$falsev)
/* 15502*/ 0, // EndSwitchType
/* 15503*/ 0, /*End of Scope*/
/* 15504*/ /*SwitchOpcode*/ 78|128,1/*206*/, TARGET_VAL(ISD::Constant),// ->15714
/* 15508*/ OPC_RecordNode, // #0 = $imm
/* 15509*/ OPC_Scope, 55, /*->15566*/ // 3 children in Scope
/* 15511*/ OPC_CheckPredicate, 1, // Predicate_simm12
/* 15513*/ OPC_SwitchType /*2 cases */, 32, MVT::i32,// ->15548
/* 15516*/ OPC_Scope, 15, /*->15533*/ // 2 children in Scope
/* 15518*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15520*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 15523*/ OPC_EmitConvertToTarget, 0,
/* 15525*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i32] } X0:{ *:[i32] }, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm)
/* 15533*/ /*Scope*/ 13, /*->15547*/
/* 15534*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 15537*/ OPC_EmitConvertToTarget, 0,
/* 15539*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i32] } X0:{ *:[i32] }, (imm:{ *:[i32] })<<P:Predicate_simm12>>:$imm)
/* 15547*/ 0, /*End of Scope*/
/* 15548*/ /*SwitchType*/ 15, MVT::i64,// ->15565
/* 15550*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15552*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 15555*/ OPC_EmitConvertToTarget, 0,
/* 15557*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i64] } X0:{ *:[i64] }, (imm:{ *:[i64] })<<P:Predicate_simm12>>:$imm)
/* 15565*/ 0, // EndSwitchType
/* 15566*/ /*Scope*/ 52, /*->15619*/
/* 15567*/ OPC_CheckPredicate, 18, // Predicate_simm32hi20
/* 15569*/ OPC_SwitchType /*2 cases */, 30, MVT::i32,// ->15602
/* 15572*/ OPC_Scope, 14, /*->15588*/ // 2 children in Scope
/* 15574*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 15576*/ OPC_EmitConvertToTarget, 0,
/* 15578*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15581*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LUI), 0,
MVT::i32, 1/*#Ops*/, 2,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm32hi20>>:$imm - Complexity = 4
// Dst: (LUI:{ *:[i32] } (HI20:{ *:[i32] } (imm:{ *:[i32] }):$imm))
/* 15588*/ /*Scope*/ 12, /*->15601*/
/* 15589*/ OPC_EmitConvertToTarget, 0,
/* 15591*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15594*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LUI), 0,
MVT::i32, 1/*#Ops*/, 2,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm32hi20>>:$imm - Complexity = 4
// Dst: (LUI:{ *:[i32] } (HI20:{ *:[i32] } (imm:{ *:[i32] }):$imm))
/* 15601*/ 0, /*End of Scope*/
/* 15602*/ /*SwitchType*/ 14, MVT::i64,// ->15618
/* 15604*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 15606*/ OPC_EmitConvertToTarget, 0,
/* 15608*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15611*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::LUI), 0,
MVT::i64, 1/*#Ops*/, 2,
// Src: (imm:{ *:[i64] })<<P:Predicate_simm32hi20>>:$imm - Complexity = 4
// Dst: (LUI:{ *:[i64] } (HI20:{ *:[i64] } (imm:{ *:[i64] }):$imm))
/* 15618*/ 0, // EndSwitchType
/* 15619*/ /*Scope*/ 93, /*->15713*/
/* 15620*/ OPC_CheckPredicate, 19, // Predicate_simm32
/* 15622*/ OPC_SwitchType /*2 cases */, 58, MVT::i32,// ->15683
/* 15625*/ OPC_Scope, 27, /*->15654*/ // 2 children in Scope
/* 15627*/ OPC_CheckPatternPredicate, 8, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15629*/ OPC_EmitConvertToTarget, 0,
/* 15631*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15634*/ OPC_EmitNode1, TARGET_VAL(RISCV::LUI), 0,
MVT::i32, 1/*#Ops*/, 2, // Results = #3
/* 15641*/ OPC_EmitConvertToTarget, 0,
/* 15643*/ OPC_EmitNodeXForm, 1, 4, // LO12Sext
/* 15646*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 3, 5,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm32>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i32] } (LUI:{ *:[i32] } (HI20:{ *:[i32] } (imm:{ *:[i32] }):$imm)), (LO12Sext:{ *:[i32] } (imm:{ *:[i32] }):$imm))
/* 15654*/ /*Scope*/ 27, /*->15682*/
/* 15655*/ OPC_CheckPatternPredicate, 9, // (!Subtarget->is64Bit())
/* 15657*/ OPC_EmitConvertToTarget, 0,
/* 15659*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15662*/ OPC_EmitNode1, TARGET_VAL(RISCV::LUI), 0,
MVT::i32, 1/*#Ops*/, 2, // Results = #3
/* 15669*/ OPC_EmitConvertToTarget, 0,
/* 15671*/ OPC_EmitNodeXForm, 1, 4, // LO12Sext
/* 15674*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i32, 2/*#Ops*/, 3, 5,
// Src: (imm:{ *:[i32] })<<P:Predicate_simm32>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i32] } (LUI:{ *:[i32] } (HI20:{ *:[i32] } (imm:{ *:[i32] }):$imm)), (LO12Sext:{ *:[i32] } (imm:{ *:[i32] }):$imm))
/* 15682*/ 0, /*End of Scope*/
/* 15683*/ /*SwitchType*/ 27, MVT::i64,// ->15712
/* 15685*/ OPC_CheckPatternPredicate, 10, // (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 15687*/ OPC_EmitConvertToTarget, 0,
/* 15689*/ OPC_EmitNodeXForm, 0, 1, // HI20
/* 15692*/ OPC_EmitNode1, TARGET_VAL(RISCV::LUI), 0,
MVT::i64, 1/*#Ops*/, 2, // Results = #3
/* 15699*/ OPC_EmitConvertToTarget, 0,
/* 15701*/ OPC_EmitNodeXForm, 1, 4, // LO12Sext
/* 15704*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::ADDI), 0,
MVT::i64, 2/*#Ops*/, 3, 5,
// Src: (imm:{ *:[i64] })<<P:Predicate_simm32>>:$imm - Complexity = 4
// Dst: (ADDI:{ *:[i64] } (LUI:{ *:[i64] } (HI20:{ *:[i64] } (imm:{ *:[i64] }):$imm)), (LO12Sext:{ *:[i64] } (imm:{ *:[i64] }):$imm))
/* 15712*/ 0, // EndSwitchType
/* 15713*/ 0, /*End of Scope*/
/* 15714*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_SWAP),// ->16191
/* 15718*/ OPC_RecordMemRef,
/* 15719*/ OPC_RecordNode, // #0 = 'atomic_swap' chained node
/* 15720*/ OPC_RecordChild1, // #1 = $rs1
/* 15721*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->16032
/* 15725*/ OPC_CheckChild1Type, MVT::i32,
/* 15727*/ OPC_RecordChild2, // #2 = $rs2
/* 15728*/ OPC_Scope, 21|128,1/*149*/, /*->15880*/ // 2 children in Scope
/* 15731*/ OPC_CheckPredicate, 10, // Predicate_atomic_swap_32
/* 15733*/ OPC_Scope, 28, /*->15763*/ // 5 children in Scope
/* 15735*/ OPC_CheckPredicate, 20, // Predicate_atomic_swap_32_monotonic
/* 15737*/ OPC_Scope, 11, /*->15750*/ // 2 children in Scope
/* 15739*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15741*/ OPC_EmitMergeInputChains1_0,
/* 15742*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15750*/ /*Scope*/ 11, /*->15762*/
/* 15751*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 15753*/ OPC_EmitMergeInputChains1_0,
/* 15754*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15762*/ 0, /*End of Scope*/
/* 15763*/ /*Scope*/ 28, /*->15792*/
/* 15764*/ OPC_CheckPredicate, 21, // Predicate_atomic_swap_32_acquire
/* 15766*/ OPC_Scope, 11, /*->15779*/ // 2 children in Scope
/* 15768*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15770*/ OPC_EmitMergeInputChains1_0,
/* 15771*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acquire>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15779*/ /*Scope*/ 11, /*->15791*/
/* 15780*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 15782*/ OPC_EmitMergeInputChains1_0,
/* 15783*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acquire>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15791*/ 0, /*End of Scope*/
/* 15792*/ /*Scope*/ 28, /*->15821*/
/* 15793*/ OPC_CheckPredicate, 22, // Predicate_atomic_swap_32_release
/* 15795*/ OPC_Scope, 11, /*->15808*/ // 2 children in Scope
/* 15797*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15799*/ OPC_EmitMergeInputChains1_0,
/* 15800*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_release>> - Complexity = 4
// Dst: (AMOSWAP_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15808*/ /*Scope*/ 11, /*->15820*/
/* 15809*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 15811*/ OPC_EmitMergeInputChains1_0,
/* 15812*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_release>> - Complexity = 4
// Dst: (AMOSWAP_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15820*/ 0, /*End of Scope*/
/* 15821*/ /*Scope*/ 28, /*->15850*/
/* 15822*/ OPC_CheckPredicate, 23, // Predicate_atomic_swap_32_acq_rel
/* 15824*/ OPC_Scope, 11, /*->15837*/ // 2 children in Scope
/* 15826*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15828*/ OPC_EmitMergeInputChains1_0,
/* 15829*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15837*/ /*Scope*/ 11, /*->15849*/
/* 15838*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 15840*/ OPC_EmitMergeInputChains1_0,
/* 15841*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15849*/ 0, /*End of Scope*/
/* 15850*/ /*Scope*/ 28, /*->15879*/
/* 15851*/ OPC_CheckPredicate, 24, // Predicate_atomic_swap_32_seq_cst
/* 15853*/ OPC_Scope, 11, /*->15866*/ // 2 children in Scope
/* 15855*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15857*/ OPC_EmitMergeInputChains1_0,
/* 15858*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15866*/ /*Scope*/ 11, /*->15878*/
/* 15867*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 15869*/ OPC_EmitMergeInputChains1_0,
/* 15870*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15878*/ 0, /*End of Scope*/
/* 15879*/ 0, /*End of Scope*/
/* 15880*/ /*Scope*/ 21|128,1/*149*/, /*->16031*/
/* 15882*/ OPC_CheckPredicate, 14, // Predicate_atomic_swap_64
/* 15884*/ OPC_Scope, 28, /*->15914*/ // 5 children in Scope
/* 15886*/ OPC_CheckPredicate, 20, // Predicate_atomic_swap_64_monotonic
/* 15888*/ OPC_Scope, 11, /*->15901*/ // 2 children in Scope
/* 15890*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15892*/ OPC_EmitMergeInputChains1_0,
/* 15893*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15901*/ /*Scope*/ 11, /*->15913*/
/* 15902*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 15904*/ OPC_EmitMergeInputChains1_0,
/* 15905*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15913*/ 0, /*End of Scope*/
/* 15914*/ /*Scope*/ 28, /*->15943*/
/* 15915*/ OPC_CheckPredicate, 21, // Predicate_atomic_swap_64_acquire
/* 15917*/ OPC_Scope, 11, /*->15930*/ // 2 children in Scope
/* 15919*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15921*/ OPC_EmitMergeInputChains1_0,
/* 15922*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acquire>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15930*/ /*Scope*/ 11, /*->15942*/
/* 15931*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 15933*/ OPC_EmitMergeInputChains1_0,
/* 15934*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acquire>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15942*/ 0, /*End of Scope*/
/* 15943*/ /*Scope*/ 28, /*->15972*/
/* 15944*/ OPC_CheckPredicate, 22, // Predicate_atomic_swap_64_release
/* 15946*/ OPC_Scope, 11, /*->15959*/ // 2 children in Scope
/* 15948*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15950*/ OPC_EmitMergeInputChains1_0,
/* 15951*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_release>> - Complexity = 4
// Dst: (AMOSWAP_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15959*/ /*Scope*/ 11, /*->15971*/
/* 15960*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 15962*/ OPC_EmitMergeInputChains1_0,
/* 15963*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_release>> - Complexity = 4
// Dst: (AMOSWAP_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15971*/ 0, /*End of Scope*/
/* 15972*/ /*Scope*/ 28, /*->16001*/
/* 15973*/ OPC_CheckPredicate, 23, // Predicate_atomic_swap_64_acq_rel
/* 15975*/ OPC_Scope, 11, /*->15988*/ // 2 children in Scope
/* 15977*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 15979*/ OPC_EmitMergeInputChains1_0,
/* 15980*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 15988*/ /*Scope*/ 11, /*->16000*/
/* 15989*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 15991*/ OPC_EmitMergeInputChains1_0,
/* 15992*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16000*/ 0, /*End of Scope*/
/* 16001*/ /*Scope*/ 28, /*->16030*/
/* 16002*/ OPC_CheckPredicate, 24, // Predicate_atomic_swap_64_seq_cst
/* 16004*/ OPC_Scope, 11, /*->16017*/ // 2 children in Scope
/* 16006*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16008*/ OPC_EmitMergeInputChains1_0,
/* 16009*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16017*/ /*Scope*/ 11, /*->16029*/
/* 16018*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16020*/ OPC_EmitMergeInputChains1_0,
/* 16021*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16029*/ 0, /*End of Scope*/
/* 16030*/ 0, /*End of Scope*/
/* 16031*/ 0, /*End of Scope*/
/* 16032*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->16190
/* 16035*/ OPC_CheckChild1Type, MVT::i64,
/* 16037*/ OPC_RecordChild2, // #2 = $rs2
/* 16038*/ OPC_Scope, 74, /*->16114*/ // 2 children in Scope
/* 16040*/ OPC_CheckPredicate, 10, // Predicate_atomic_swap_32
/* 16042*/ OPC_Scope, 13, /*->16057*/ // 5 children in Scope
/* 16044*/ OPC_CheckPredicate, 20, // Predicate_atomic_swap_32_monotonic
/* 16046*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16048*/ OPC_EmitMergeInputChains1_0,
/* 16049*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16057*/ /*Scope*/ 13, /*->16071*/
/* 16058*/ OPC_CheckPredicate, 21, // Predicate_atomic_swap_32_acquire
/* 16060*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16062*/ OPC_EmitMergeInputChains1_0,
/* 16063*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acquire>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16071*/ /*Scope*/ 13, /*->16085*/
/* 16072*/ OPC_CheckPredicate, 22, // Predicate_atomic_swap_32_release
/* 16074*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16076*/ OPC_EmitMergeInputChains1_0,
/* 16077*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_release>> - Complexity = 4
// Dst: (AMOSWAP_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16085*/ /*Scope*/ 13, /*->16099*/
/* 16086*/ OPC_CheckPredicate, 23, // Predicate_atomic_swap_32_acq_rel
/* 16088*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16090*/ OPC_EmitMergeInputChains1_0,
/* 16091*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16099*/ /*Scope*/ 13, /*->16113*/
/* 16100*/ OPC_CheckPredicate, 24, // Predicate_atomic_swap_32_seq_cst
/* 16102*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16104*/ OPC_EmitMergeInputChains1_0,
/* 16105*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_32>><<P:Predicate_atomic_swap_32_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16113*/ 0, /*End of Scope*/
/* 16114*/ /*Scope*/ 74, /*->16189*/
/* 16115*/ OPC_CheckPredicate, 14, // Predicate_atomic_swap_64
/* 16117*/ OPC_Scope, 13, /*->16132*/ // 5 children in Scope
/* 16119*/ OPC_CheckPredicate, 20, // Predicate_atomic_swap_64_monotonic
/* 16121*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16123*/ OPC_EmitMergeInputChains1_0,
/* 16124*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_monotonic>> - Complexity = 4
// Dst: (AMOSWAP_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16132*/ /*Scope*/ 13, /*->16146*/
/* 16133*/ OPC_CheckPredicate, 21, // Predicate_atomic_swap_64_acquire
/* 16135*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16137*/ OPC_EmitMergeInputChains1_0,
/* 16138*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acquire>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16146*/ /*Scope*/ 13, /*->16160*/
/* 16147*/ OPC_CheckPredicate, 22, // Predicate_atomic_swap_64_release
/* 16149*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16151*/ OPC_EmitMergeInputChains1_0,
/* 16152*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_release>> - Complexity = 4
// Dst: (AMOSWAP_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16160*/ /*Scope*/ 13, /*->16174*/
/* 16161*/ OPC_CheckPredicate, 23, // Predicate_atomic_swap_64_acq_rel
/* 16163*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16165*/ OPC_EmitMergeInputChains1_0,
/* 16166*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_acq_rel>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16174*/ /*Scope*/ 13, /*->16188*/
/* 16175*/ OPC_CheckPredicate, 24, // Predicate_atomic_swap_64_seq_cst
/* 16177*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16179*/ OPC_EmitMergeInputChains1_0,
/* 16180*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOSWAP_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_swap:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_swap_64>><<P:Predicate_atomic_swap_64_seq_cst>> - Complexity = 4
// Dst: (AMOSWAP_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16188*/ 0, /*End of Scope*/
/* 16189*/ 0, /*End of Scope*/
/* 16190*/ 0, // EndSwitchType
/* 16191*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_ADD),// ->16668
/* 16195*/ OPC_RecordMemRef,
/* 16196*/ OPC_RecordNode, // #0 = 'atomic_load_add' chained node
/* 16197*/ OPC_RecordChild1, // #1 = $rs1
/* 16198*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->16509
/* 16202*/ OPC_CheckChild1Type, MVT::i32,
/* 16204*/ OPC_RecordChild2, // #2 = $rs2
/* 16205*/ OPC_Scope, 21|128,1/*149*/, /*->16357*/ // 2 children in Scope
/* 16208*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_add_32
/* 16210*/ OPC_Scope, 28, /*->16240*/ // 5 children in Scope
/* 16212*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_add_32_monotonic
/* 16214*/ OPC_Scope, 11, /*->16227*/ // 2 children in Scope
/* 16216*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16218*/ OPC_EmitMergeInputChains1_0,
/* 16219*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16227*/ /*Scope*/ 11, /*->16239*/
/* 16228*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16230*/ OPC_EmitMergeInputChains1_0,
/* 16231*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16239*/ 0, /*End of Scope*/
/* 16240*/ /*Scope*/ 28, /*->16269*/
/* 16241*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_add_32_acquire
/* 16243*/ OPC_Scope, 11, /*->16256*/ // 2 children in Scope
/* 16245*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16247*/ OPC_EmitMergeInputChains1_0,
/* 16248*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16256*/ /*Scope*/ 11, /*->16268*/
/* 16257*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16259*/ OPC_EmitMergeInputChains1_0,
/* 16260*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16268*/ 0, /*End of Scope*/
/* 16269*/ /*Scope*/ 28, /*->16298*/
/* 16270*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_add_32_release
/* 16272*/ OPC_Scope, 11, /*->16285*/ // 2 children in Scope
/* 16274*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16276*/ OPC_EmitMergeInputChains1_0,
/* 16277*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16285*/ /*Scope*/ 11, /*->16297*/
/* 16286*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16288*/ OPC_EmitMergeInputChains1_0,
/* 16289*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16297*/ 0, /*End of Scope*/
/* 16298*/ /*Scope*/ 28, /*->16327*/
/* 16299*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_add_32_acq_rel
/* 16301*/ OPC_Scope, 11, /*->16314*/ // 2 children in Scope
/* 16303*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16305*/ OPC_EmitMergeInputChains1_0,
/* 16306*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16314*/ /*Scope*/ 11, /*->16326*/
/* 16315*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16317*/ OPC_EmitMergeInputChains1_0,
/* 16318*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16326*/ 0, /*End of Scope*/
/* 16327*/ /*Scope*/ 28, /*->16356*/
/* 16328*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_add_32_seq_cst
/* 16330*/ OPC_Scope, 11, /*->16343*/ // 2 children in Scope
/* 16332*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16334*/ OPC_EmitMergeInputChains1_0,
/* 16335*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16343*/ /*Scope*/ 11, /*->16355*/
/* 16344*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16346*/ OPC_EmitMergeInputChains1_0,
/* 16347*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16355*/ 0, /*End of Scope*/
/* 16356*/ 0, /*End of Scope*/
/* 16357*/ /*Scope*/ 21|128,1/*149*/, /*->16508*/
/* 16359*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_add_64
/* 16361*/ OPC_Scope, 28, /*->16391*/ // 5 children in Scope
/* 16363*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_add_64_monotonic
/* 16365*/ OPC_Scope, 11, /*->16378*/ // 2 children in Scope
/* 16367*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16369*/ OPC_EmitMergeInputChains1_0,
/* 16370*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16378*/ /*Scope*/ 11, /*->16390*/
/* 16379*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16381*/ OPC_EmitMergeInputChains1_0,
/* 16382*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16390*/ 0, /*End of Scope*/
/* 16391*/ /*Scope*/ 28, /*->16420*/
/* 16392*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_add_64_acquire
/* 16394*/ OPC_Scope, 11, /*->16407*/ // 2 children in Scope
/* 16396*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16398*/ OPC_EmitMergeInputChains1_0,
/* 16399*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16407*/ /*Scope*/ 11, /*->16419*/
/* 16408*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16410*/ OPC_EmitMergeInputChains1_0,
/* 16411*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16419*/ 0, /*End of Scope*/
/* 16420*/ /*Scope*/ 28, /*->16449*/
/* 16421*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_add_64_release
/* 16423*/ OPC_Scope, 11, /*->16436*/ // 2 children in Scope
/* 16425*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16427*/ OPC_EmitMergeInputChains1_0,
/* 16428*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16436*/ /*Scope*/ 11, /*->16448*/
/* 16437*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16439*/ OPC_EmitMergeInputChains1_0,
/* 16440*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16448*/ 0, /*End of Scope*/
/* 16449*/ /*Scope*/ 28, /*->16478*/
/* 16450*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_add_64_acq_rel
/* 16452*/ OPC_Scope, 11, /*->16465*/ // 2 children in Scope
/* 16454*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16456*/ OPC_EmitMergeInputChains1_0,
/* 16457*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16465*/ /*Scope*/ 11, /*->16477*/
/* 16466*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16468*/ OPC_EmitMergeInputChains1_0,
/* 16469*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16477*/ 0, /*End of Scope*/
/* 16478*/ /*Scope*/ 28, /*->16507*/
/* 16479*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_add_64_seq_cst
/* 16481*/ OPC_Scope, 11, /*->16494*/ // 2 children in Scope
/* 16483*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16485*/ OPC_EmitMergeInputChains1_0,
/* 16486*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16494*/ /*Scope*/ 11, /*->16506*/
/* 16495*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16497*/ OPC_EmitMergeInputChains1_0,
/* 16498*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16506*/ 0, /*End of Scope*/
/* 16507*/ 0, /*End of Scope*/
/* 16508*/ 0, /*End of Scope*/
/* 16509*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->16667
/* 16512*/ OPC_CheckChild1Type, MVT::i64,
/* 16514*/ OPC_RecordChild2, // #2 = $rs2
/* 16515*/ OPC_Scope, 74, /*->16591*/ // 2 children in Scope
/* 16517*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_add_32
/* 16519*/ OPC_Scope, 13, /*->16534*/ // 5 children in Scope
/* 16521*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_add_32_monotonic
/* 16523*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16525*/ OPC_EmitMergeInputChains1_0,
/* 16526*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16534*/ /*Scope*/ 13, /*->16548*/
/* 16535*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_add_32_acquire
/* 16537*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16539*/ OPC_EmitMergeInputChains1_0,
/* 16540*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16548*/ /*Scope*/ 13, /*->16562*/
/* 16549*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_add_32_release
/* 16551*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16553*/ OPC_EmitMergeInputChains1_0,
/* 16554*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16562*/ /*Scope*/ 13, /*->16576*/
/* 16563*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_add_32_acq_rel
/* 16565*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16567*/ OPC_EmitMergeInputChains1_0,
/* 16568*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16576*/ /*Scope*/ 13, /*->16590*/
/* 16577*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_add_32_seq_cst
/* 16579*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16581*/ OPC_EmitMergeInputChains1_0,
/* 16582*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_32>><<P:Predicate_atomic_load_add_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16590*/ 0, /*End of Scope*/
/* 16591*/ /*Scope*/ 74, /*->16666*/
/* 16592*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_add_64
/* 16594*/ OPC_Scope, 13, /*->16609*/ // 5 children in Scope
/* 16596*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_add_64_monotonic
/* 16598*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16600*/ OPC_EmitMergeInputChains1_0,
/* 16601*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16609*/ /*Scope*/ 13, /*->16623*/
/* 16610*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_add_64_acquire
/* 16612*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16614*/ OPC_EmitMergeInputChains1_0,
/* 16615*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16623*/ /*Scope*/ 13, /*->16637*/
/* 16624*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_add_64_release
/* 16626*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16628*/ OPC_EmitMergeInputChains1_0,
/* 16629*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16637*/ /*Scope*/ 13, /*->16651*/
/* 16638*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_add_64_acq_rel
/* 16640*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16642*/ OPC_EmitMergeInputChains1_0,
/* 16643*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16651*/ /*Scope*/ 13, /*->16665*/
/* 16652*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_add_64_seq_cst
/* 16654*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 16656*/ OPC_EmitMergeInputChains1_0,
/* 16657*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_add:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_add_64>><<P:Predicate_atomic_load_add_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 16665*/ 0, /*End of Scope*/
/* 16666*/ 0, /*End of Scope*/
/* 16667*/ 0, // EndSwitchType
/* 16668*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_AND),// ->17145
/* 16672*/ OPC_RecordMemRef,
/* 16673*/ OPC_RecordNode, // #0 = 'atomic_load_and' chained node
/* 16674*/ OPC_RecordChild1, // #1 = $rs1
/* 16675*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->16986
/* 16679*/ OPC_CheckChild1Type, MVT::i32,
/* 16681*/ OPC_RecordChild2, // #2 = $rs2
/* 16682*/ OPC_Scope, 21|128,1/*149*/, /*->16834*/ // 2 children in Scope
/* 16685*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_and_32
/* 16687*/ OPC_Scope, 28, /*->16717*/ // 5 children in Scope
/* 16689*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_and_32_monotonic
/* 16691*/ OPC_Scope, 11, /*->16704*/ // 2 children in Scope
/* 16693*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16695*/ OPC_EmitMergeInputChains1_0,
/* 16696*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_monotonic>> - Complexity = 4
// Dst: (AMOAND_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16704*/ /*Scope*/ 11, /*->16716*/
/* 16705*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16707*/ OPC_EmitMergeInputChains1_0,
/* 16708*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_monotonic>> - Complexity = 4
// Dst: (AMOAND_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16716*/ 0, /*End of Scope*/
/* 16717*/ /*Scope*/ 28, /*->16746*/
/* 16718*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_and_32_acquire
/* 16720*/ OPC_Scope, 11, /*->16733*/ // 2 children in Scope
/* 16722*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16724*/ OPC_EmitMergeInputChains1_0,
/* 16725*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acquire>> - Complexity = 4
// Dst: (AMOAND_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16733*/ /*Scope*/ 11, /*->16745*/
/* 16734*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16736*/ OPC_EmitMergeInputChains1_0,
/* 16737*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acquire>> - Complexity = 4
// Dst: (AMOAND_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16745*/ 0, /*End of Scope*/
/* 16746*/ /*Scope*/ 28, /*->16775*/
/* 16747*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_and_32_release
/* 16749*/ OPC_Scope, 11, /*->16762*/ // 2 children in Scope
/* 16751*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16753*/ OPC_EmitMergeInputChains1_0,
/* 16754*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_release>> - Complexity = 4
// Dst: (AMOAND_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16762*/ /*Scope*/ 11, /*->16774*/
/* 16763*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16765*/ OPC_EmitMergeInputChains1_0,
/* 16766*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_release>> - Complexity = 4
// Dst: (AMOAND_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16774*/ 0, /*End of Scope*/
/* 16775*/ /*Scope*/ 28, /*->16804*/
/* 16776*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_and_32_acq_rel
/* 16778*/ OPC_Scope, 11, /*->16791*/ // 2 children in Scope
/* 16780*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16782*/ OPC_EmitMergeInputChains1_0,
/* 16783*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acq_rel>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16791*/ /*Scope*/ 11, /*->16803*/
/* 16792*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16794*/ OPC_EmitMergeInputChains1_0,
/* 16795*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acq_rel>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16803*/ 0, /*End of Scope*/
/* 16804*/ /*Scope*/ 28, /*->16833*/
/* 16805*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_and_32_seq_cst
/* 16807*/ OPC_Scope, 11, /*->16820*/ // 2 children in Scope
/* 16809*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16811*/ OPC_EmitMergeInputChains1_0,
/* 16812*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_seq_cst>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16820*/ /*Scope*/ 11, /*->16832*/
/* 16821*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 16823*/ OPC_EmitMergeInputChains1_0,
/* 16824*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_seq_cst>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16832*/ 0, /*End of Scope*/
/* 16833*/ 0, /*End of Scope*/
/* 16834*/ /*Scope*/ 21|128,1/*149*/, /*->16985*/
/* 16836*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_and_64
/* 16838*/ OPC_Scope, 28, /*->16868*/ // 5 children in Scope
/* 16840*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_and_64_monotonic
/* 16842*/ OPC_Scope, 11, /*->16855*/ // 2 children in Scope
/* 16844*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16846*/ OPC_EmitMergeInputChains1_0,
/* 16847*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_monotonic>> - Complexity = 4
// Dst: (AMOAND_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16855*/ /*Scope*/ 11, /*->16867*/
/* 16856*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16858*/ OPC_EmitMergeInputChains1_0,
/* 16859*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_monotonic>> - Complexity = 4
// Dst: (AMOAND_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16867*/ 0, /*End of Scope*/
/* 16868*/ /*Scope*/ 28, /*->16897*/
/* 16869*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_and_64_acquire
/* 16871*/ OPC_Scope, 11, /*->16884*/ // 2 children in Scope
/* 16873*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16875*/ OPC_EmitMergeInputChains1_0,
/* 16876*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acquire>> - Complexity = 4
// Dst: (AMOAND_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16884*/ /*Scope*/ 11, /*->16896*/
/* 16885*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16887*/ OPC_EmitMergeInputChains1_0,
/* 16888*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acquire>> - Complexity = 4
// Dst: (AMOAND_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16896*/ 0, /*End of Scope*/
/* 16897*/ /*Scope*/ 28, /*->16926*/
/* 16898*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_and_64_release
/* 16900*/ OPC_Scope, 11, /*->16913*/ // 2 children in Scope
/* 16902*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16904*/ OPC_EmitMergeInputChains1_0,
/* 16905*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_release>> - Complexity = 4
// Dst: (AMOAND_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16913*/ /*Scope*/ 11, /*->16925*/
/* 16914*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16916*/ OPC_EmitMergeInputChains1_0,
/* 16917*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_release>> - Complexity = 4
// Dst: (AMOAND_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16925*/ 0, /*End of Scope*/
/* 16926*/ /*Scope*/ 28, /*->16955*/
/* 16927*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_and_64_acq_rel
/* 16929*/ OPC_Scope, 11, /*->16942*/ // 2 children in Scope
/* 16931*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16933*/ OPC_EmitMergeInputChains1_0,
/* 16934*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acq_rel>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16942*/ /*Scope*/ 11, /*->16954*/
/* 16943*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16945*/ OPC_EmitMergeInputChains1_0,
/* 16946*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acq_rel>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16954*/ 0, /*End of Scope*/
/* 16955*/ /*Scope*/ 28, /*->16984*/
/* 16956*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_and_64_seq_cst
/* 16958*/ OPC_Scope, 11, /*->16971*/ // 2 children in Scope
/* 16960*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 16962*/ OPC_EmitMergeInputChains1_0,
/* 16963*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_seq_cst>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16971*/ /*Scope*/ 11, /*->16983*/
/* 16972*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 16974*/ OPC_EmitMergeInputChains1_0,
/* 16975*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_seq_cst>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 16983*/ 0, /*End of Scope*/
/* 16984*/ 0, /*End of Scope*/
/* 16985*/ 0, /*End of Scope*/
/* 16986*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->17144
/* 16989*/ OPC_CheckChild1Type, MVT::i64,
/* 16991*/ OPC_RecordChild2, // #2 = $rs2
/* 16992*/ OPC_Scope, 74, /*->17068*/ // 2 children in Scope
/* 16994*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_and_32
/* 16996*/ OPC_Scope, 13, /*->17011*/ // 5 children in Scope
/* 16998*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_and_32_monotonic
/* 17000*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17002*/ OPC_EmitMergeInputChains1_0,
/* 17003*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_monotonic>> - Complexity = 4
// Dst: (AMOAND_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17011*/ /*Scope*/ 13, /*->17025*/
/* 17012*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_and_32_acquire
/* 17014*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17016*/ OPC_EmitMergeInputChains1_0,
/* 17017*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acquire>> - Complexity = 4
// Dst: (AMOAND_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17025*/ /*Scope*/ 13, /*->17039*/
/* 17026*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_and_32_release
/* 17028*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17030*/ OPC_EmitMergeInputChains1_0,
/* 17031*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_release>> - Complexity = 4
// Dst: (AMOAND_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17039*/ /*Scope*/ 13, /*->17053*/
/* 17040*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_and_32_acq_rel
/* 17042*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17044*/ OPC_EmitMergeInputChains1_0,
/* 17045*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_acq_rel>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17053*/ /*Scope*/ 13, /*->17067*/
/* 17054*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_and_32_seq_cst
/* 17056*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17058*/ OPC_EmitMergeInputChains1_0,
/* 17059*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_32>><<P:Predicate_atomic_load_and_32_seq_cst>> - Complexity = 4
// Dst: (AMOAND_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17067*/ 0, /*End of Scope*/
/* 17068*/ /*Scope*/ 74, /*->17143*/
/* 17069*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_and_64
/* 17071*/ OPC_Scope, 13, /*->17086*/ // 5 children in Scope
/* 17073*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_and_64_monotonic
/* 17075*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17077*/ OPC_EmitMergeInputChains1_0,
/* 17078*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_monotonic>> - Complexity = 4
// Dst: (AMOAND_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17086*/ /*Scope*/ 13, /*->17100*/
/* 17087*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_and_64_acquire
/* 17089*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17091*/ OPC_EmitMergeInputChains1_0,
/* 17092*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acquire>> - Complexity = 4
// Dst: (AMOAND_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17100*/ /*Scope*/ 13, /*->17114*/
/* 17101*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_and_64_release
/* 17103*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17105*/ OPC_EmitMergeInputChains1_0,
/* 17106*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_release>> - Complexity = 4
// Dst: (AMOAND_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17114*/ /*Scope*/ 13, /*->17128*/
/* 17115*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_and_64_acq_rel
/* 17117*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17119*/ OPC_EmitMergeInputChains1_0,
/* 17120*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_acq_rel>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17128*/ /*Scope*/ 13, /*->17142*/
/* 17129*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_and_64_seq_cst
/* 17131*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17133*/ OPC_EmitMergeInputChains1_0,
/* 17134*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOAND_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_and_64>><<P:Predicate_atomic_load_and_64_seq_cst>> - Complexity = 4
// Dst: (AMOAND_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17142*/ 0, /*End of Scope*/
/* 17143*/ 0, /*End of Scope*/
/* 17144*/ 0, // EndSwitchType
/* 17145*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_OR),// ->17622
/* 17149*/ OPC_RecordMemRef,
/* 17150*/ OPC_RecordNode, // #0 = 'atomic_load_or' chained node
/* 17151*/ OPC_RecordChild1, // #1 = $rs1
/* 17152*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->17463
/* 17156*/ OPC_CheckChild1Type, MVT::i32,
/* 17158*/ OPC_RecordChild2, // #2 = $rs2
/* 17159*/ OPC_Scope, 21|128,1/*149*/, /*->17311*/ // 2 children in Scope
/* 17162*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_or_32
/* 17164*/ OPC_Scope, 28, /*->17194*/ // 5 children in Scope
/* 17166*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_or_32_monotonic
/* 17168*/ OPC_Scope, 11, /*->17181*/ // 2 children in Scope
/* 17170*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17172*/ OPC_EmitMergeInputChains1_0,
/* 17173*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_monotonic>> - Complexity = 4
// Dst: (AMOOR_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17181*/ /*Scope*/ 11, /*->17193*/
/* 17182*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17184*/ OPC_EmitMergeInputChains1_0,
/* 17185*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_monotonic>> - Complexity = 4
// Dst: (AMOOR_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17193*/ 0, /*End of Scope*/
/* 17194*/ /*Scope*/ 28, /*->17223*/
/* 17195*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_or_32_acquire
/* 17197*/ OPC_Scope, 11, /*->17210*/ // 2 children in Scope
/* 17199*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17201*/ OPC_EmitMergeInputChains1_0,
/* 17202*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acquire>> - Complexity = 4
// Dst: (AMOOR_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17210*/ /*Scope*/ 11, /*->17222*/
/* 17211*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17213*/ OPC_EmitMergeInputChains1_0,
/* 17214*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acquire>> - Complexity = 4
// Dst: (AMOOR_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17222*/ 0, /*End of Scope*/
/* 17223*/ /*Scope*/ 28, /*->17252*/
/* 17224*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_or_32_release
/* 17226*/ OPC_Scope, 11, /*->17239*/ // 2 children in Scope
/* 17228*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17230*/ OPC_EmitMergeInputChains1_0,
/* 17231*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_release>> - Complexity = 4
// Dst: (AMOOR_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17239*/ /*Scope*/ 11, /*->17251*/
/* 17240*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17242*/ OPC_EmitMergeInputChains1_0,
/* 17243*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_release>> - Complexity = 4
// Dst: (AMOOR_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17251*/ 0, /*End of Scope*/
/* 17252*/ /*Scope*/ 28, /*->17281*/
/* 17253*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_or_32_acq_rel
/* 17255*/ OPC_Scope, 11, /*->17268*/ // 2 children in Scope
/* 17257*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17259*/ OPC_EmitMergeInputChains1_0,
/* 17260*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acq_rel>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17268*/ /*Scope*/ 11, /*->17280*/
/* 17269*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17271*/ OPC_EmitMergeInputChains1_0,
/* 17272*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acq_rel>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17280*/ 0, /*End of Scope*/
/* 17281*/ /*Scope*/ 28, /*->17310*/
/* 17282*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_or_32_seq_cst
/* 17284*/ OPC_Scope, 11, /*->17297*/ // 2 children in Scope
/* 17286*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17288*/ OPC_EmitMergeInputChains1_0,
/* 17289*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_seq_cst>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17297*/ /*Scope*/ 11, /*->17309*/
/* 17298*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17300*/ OPC_EmitMergeInputChains1_0,
/* 17301*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_seq_cst>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17309*/ 0, /*End of Scope*/
/* 17310*/ 0, /*End of Scope*/
/* 17311*/ /*Scope*/ 21|128,1/*149*/, /*->17462*/
/* 17313*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_or_64
/* 17315*/ OPC_Scope, 28, /*->17345*/ // 5 children in Scope
/* 17317*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_or_64_monotonic
/* 17319*/ OPC_Scope, 11, /*->17332*/ // 2 children in Scope
/* 17321*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17323*/ OPC_EmitMergeInputChains1_0,
/* 17324*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_monotonic>> - Complexity = 4
// Dst: (AMOOR_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17332*/ /*Scope*/ 11, /*->17344*/
/* 17333*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17335*/ OPC_EmitMergeInputChains1_0,
/* 17336*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_monotonic>> - Complexity = 4
// Dst: (AMOOR_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17344*/ 0, /*End of Scope*/
/* 17345*/ /*Scope*/ 28, /*->17374*/
/* 17346*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_or_64_acquire
/* 17348*/ OPC_Scope, 11, /*->17361*/ // 2 children in Scope
/* 17350*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17352*/ OPC_EmitMergeInputChains1_0,
/* 17353*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acquire>> - Complexity = 4
// Dst: (AMOOR_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17361*/ /*Scope*/ 11, /*->17373*/
/* 17362*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17364*/ OPC_EmitMergeInputChains1_0,
/* 17365*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acquire>> - Complexity = 4
// Dst: (AMOOR_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17373*/ 0, /*End of Scope*/
/* 17374*/ /*Scope*/ 28, /*->17403*/
/* 17375*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_or_64_release
/* 17377*/ OPC_Scope, 11, /*->17390*/ // 2 children in Scope
/* 17379*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17381*/ OPC_EmitMergeInputChains1_0,
/* 17382*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_release>> - Complexity = 4
// Dst: (AMOOR_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17390*/ /*Scope*/ 11, /*->17402*/
/* 17391*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17393*/ OPC_EmitMergeInputChains1_0,
/* 17394*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_release>> - Complexity = 4
// Dst: (AMOOR_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17402*/ 0, /*End of Scope*/
/* 17403*/ /*Scope*/ 28, /*->17432*/
/* 17404*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_or_64_acq_rel
/* 17406*/ OPC_Scope, 11, /*->17419*/ // 2 children in Scope
/* 17408*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17410*/ OPC_EmitMergeInputChains1_0,
/* 17411*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acq_rel>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17419*/ /*Scope*/ 11, /*->17431*/
/* 17420*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17422*/ OPC_EmitMergeInputChains1_0,
/* 17423*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acq_rel>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17431*/ 0, /*End of Scope*/
/* 17432*/ /*Scope*/ 28, /*->17461*/
/* 17433*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_or_64_seq_cst
/* 17435*/ OPC_Scope, 11, /*->17448*/ // 2 children in Scope
/* 17437*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17439*/ OPC_EmitMergeInputChains1_0,
/* 17440*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_seq_cst>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17448*/ /*Scope*/ 11, /*->17460*/
/* 17449*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17451*/ OPC_EmitMergeInputChains1_0,
/* 17452*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_seq_cst>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17460*/ 0, /*End of Scope*/
/* 17461*/ 0, /*End of Scope*/
/* 17462*/ 0, /*End of Scope*/
/* 17463*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->17621
/* 17466*/ OPC_CheckChild1Type, MVT::i64,
/* 17468*/ OPC_RecordChild2, // #2 = $rs2
/* 17469*/ OPC_Scope, 74, /*->17545*/ // 2 children in Scope
/* 17471*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_or_32
/* 17473*/ OPC_Scope, 13, /*->17488*/ // 5 children in Scope
/* 17475*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_or_32_monotonic
/* 17477*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17479*/ OPC_EmitMergeInputChains1_0,
/* 17480*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_monotonic>> - Complexity = 4
// Dst: (AMOOR_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17488*/ /*Scope*/ 13, /*->17502*/
/* 17489*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_or_32_acquire
/* 17491*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17493*/ OPC_EmitMergeInputChains1_0,
/* 17494*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acquire>> - Complexity = 4
// Dst: (AMOOR_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17502*/ /*Scope*/ 13, /*->17516*/
/* 17503*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_or_32_release
/* 17505*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17507*/ OPC_EmitMergeInputChains1_0,
/* 17508*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_release>> - Complexity = 4
// Dst: (AMOOR_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17516*/ /*Scope*/ 13, /*->17530*/
/* 17517*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_or_32_acq_rel
/* 17519*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17521*/ OPC_EmitMergeInputChains1_0,
/* 17522*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_acq_rel>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17530*/ /*Scope*/ 13, /*->17544*/
/* 17531*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_or_32_seq_cst
/* 17533*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17535*/ OPC_EmitMergeInputChains1_0,
/* 17536*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_32>><<P:Predicate_atomic_load_or_32_seq_cst>> - Complexity = 4
// Dst: (AMOOR_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17544*/ 0, /*End of Scope*/
/* 17545*/ /*Scope*/ 74, /*->17620*/
/* 17546*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_or_64
/* 17548*/ OPC_Scope, 13, /*->17563*/ // 5 children in Scope
/* 17550*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_or_64_monotonic
/* 17552*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17554*/ OPC_EmitMergeInputChains1_0,
/* 17555*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_monotonic>> - Complexity = 4
// Dst: (AMOOR_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17563*/ /*Scope*/ 13, /*->17577*/
/* 17564*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_or_64_acquire
/* 17566*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17568*/ OPC_EmitMergeInputChains1_0,
/* 17569*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acquire>> - Complexity = 4
// Dst: (AMOOR_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17577*/ /*Scope*/ 13, /*->17591*/
/* 17578*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_or_64_release
/* 17580*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17582*/ OPC_EmitMergeInputChains1_0,
/* 17583*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_release>> - Complexity = 4
// Dst: (AMOOR_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17591*/ /*Scope*/ 13, /*->17605*/
/* 17592*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_or_64_acq_rel
/* 17594*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17596*/ OPC_EmitMergeInputChains1_0,
/* 17597*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_acq_rel>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17605*/ /*Scope*/ 13, /*->17619*/
/* 17606*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_or_64_seq_cst
/* 17608*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17610*/ OPC_EmitMergeInputChains1_0,
/* 17611*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_or:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_or_64>><<P:Predicate_atomic_load_or_64_seq_cst>> - Complexity = 4
// Dst: (AMOOR_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17619*/ 0, /*End of Scope*/
/* 17620*/ 0, /*End of Scope*/
/* 17621*/ 0, // EndSwitchType
/* 17622*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_XOR),// ->18099
/* 17626*/ OPC_RecordMemRef,
/* 17627*/ OPC_RecordNode, // #0 = 'atomic_load_xor' chained node
/* 17628*/ OPC_RecordChild1, // #1 = $rs1
/* 17629*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->17940
/* 17633*/ OPC_CheckChild1Type, MVT::i32,
/* 17635*/ OPC_RecordChild2, // #2 = $rs2
/* 17636*/ OPC_Scope, 21|128,1/*149*/, /*->17788*/ // 2 children in Scope
/* 17639*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_xor_32
/* 17641*/ OPC_Scope, 28, /*->17671*/ // 5 children in Scope
/* 17643*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_xor_32_monotonic
/* 17645*/ OPC_Scope, 11, /*->17658*/ // 2 children in Scope
/* 17647*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17649*/ OPC_EmitMergeInputChains1_0,
/* 17650*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_monotonic>> - Complexity = 4
// Dst: (AMOXOR_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17658*/ /*Scope*/ 11, /*->17670*/
/* 17659*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17661*/ OPC_EmitMergeInputChains1_0,
/* 17662*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_monotonic>> - Complexity = 4
// Dst: (AMOXOR_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17670*/ 0, /*End of Scope*/
/* 17671*/ /*Scope*/ 28, /*->17700*/
/* 17672*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_xor_32_acquire
/* 17674*/ OPC_Scope, 11, /*->17687*/ // 2 children in Scope
/* 17676*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17678*/ OPC_EmitMergeInputChains1_0,
/* 17679*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acquire>> - Complexity = 4
// Dst: (AMOXOR_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17687*/ /*Scope*/ 11, /*->17699*/
/* 17688*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17690*/ OPC_EmitMergeInputChains1_0,
/* 17691*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acquire>> - Complexity = 4
// Dst: (AMOXOR_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17699*/ 0, /*End of Scope*/
/* 17700*/ /*Scope*/ 28, /*->17729*/
/* 17701*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_xor_32_release
/* 17703*/ OPC_Scope, 11, /*->17716*/ // 2 children in Scope
/* 17705*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17707*/ OPC_EmitMergeInputChains1_0,
/* 17708*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_release>> - Complexity = 4
// Dst: (AMOXOR_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17716*/ /*Scope*/ 11, /*->17728*/
/* 17717*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17719*/ OPC_EmitMergeInputChains1_0,
/* 17720*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_release>> - Complexity = 4
// Dst: (AMOXOR_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17728*/ 0, /*End of Scope*/
/* 17729*/ /*Scope*/ 28, /*->17758*/
/* 17730*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_xor_32_acq_rel
/* 17732*/ OPC_Scope, 11, /*->17745*/ // 2 children in Scope
/* 17734*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17736*/ OPC_EmitMergeInputChains1_0,
/* 17737*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17745*/ /*Scope*/ 11, /*->17757*/
/* 17746*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17748*/ OPC_EmitMergeInputChains1_0,
/* 17749*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17757*/ 0, /*End of Scope*/
/* 17758*/ /*Scope*/ 28, /*->17787*/
/* 17759*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_xor_32_seq_cst
/* 17761*/ OPC_Scope, 11, /*->17774*/ // 2 children in Scope
/* 17763*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17765*/ OPC_EmitMergeInputChains1_0,
/* 17766*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17774*/ /*Scope*/ 11, /*->17786*/
/* 17775*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 17777*/ OPC_EmitMergeInputChains1_0,
/* 17778*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17786*/ 0, /*End of Scope*/
/* 17787*/ 0, /*End of Scope*/
/* 17788*/ /*Scope*/ 21|128,1/*149*/, /*->17939*/
/* 17790*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_xor_64
/* 17792*/ OPC_Scope, 28, /*->17822*/ // 5 children in Scope
/* 17794*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_xor_64_monotonic
/* 17796*/ OPC_Scope, 11, /*->17809*/ // 2 children in Scope
/* 17798*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17800*/ OPC_EmitMergeInputChains1_0,
/* 17801*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_monotonic>> - Complexity = 4
// Dst: (AMOXOR_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17809*/ /*Scope*/ 11, /*->17821*/
/* 17810*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17812*/ OPC_EmitMergeInputChains1_0,
/* 17813*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_monotonic>> - Complexity = 4
// Dst: (AMOXOR_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17821*/ 0, /*End of Scope*/
/* 17822*/ /*Scope*/ 28, /*->17851*/
/* 17823*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_xor_64_acquire
/* 17825*/ OPC_Scope, 11, /*->17838*/ // 2 children in Scope
/* 17827*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17829*/ OPC_EmitMergeInputChains1_0,
/* 17830*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acquire>> - Complexity = 4
// Dst: (AMOXOR_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17838*/ /*Scope*/ 11, /*->17850*/
/* 17839*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17841*/ OPC_EmitMergeInputChains1_0,
/* 17842*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acquire>> - Complexity = 4
// Dst: (AMOXOR_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17850*/ 0, /*End of Scope*/
/* 17851*/ /*Scope*/ 28, /*->17880*/
/* 17852*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_xor_64_release
/* 17854*/ OPC_Scope, 11, /*->17867*/ // 2 children in Scope
/* 17856*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17858*/ OPC_EmitMergeInputChains1_0,
/* 17859*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_release>> - Complexity = 4
// Dst: (AMOXOR_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17867*/ /*Scope*/ 11, /*->17879*/
/* 17868*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17870*/ OPC_EmitMergeInputChains1_0,
/* 17871*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_release>> - Complexity = 4
// Dst: (AMOXOR_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17879*/ 0, /*End of Scope*/
/* 17880*/ /*Scope*/ 28, /*->17909*/
/* 17881*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_xor_64_acq_rel
/* 17883*/ OPC_Scope, 11, /*->17896*/ // 2 children in Scope
/* 17885*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17887*/ OPC_EmitMergeInputChains1_0,
/* 17888*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17896*/ /*Scope*/ 11, /*->17908*/
/* 17897*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17899*/ OPC_EmitMergeInputChains1_0,
/* 17900*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17908*/ 0, /*End of Scope*/
/* 17909*/ /*Scope*/ 28, /*->17938*/
/* 17910*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_xor_64_seq_cst
/* 17912*/ OPC_Scope, 11, /*->17925*/ // 2 children in Scope
/* 17914*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 17916*/ OPC_EmitMergeInputChains1_0,
/* 17917*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17925*/ /*Scope*/ 11, /*->17937*/
/* 17926*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 17928*/ OPC_EmitMergeInputChains1_0,
/* 17929*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 17937*/ 0, /*End of Scope*/
/* 17938*/ 0, /*End of Scope*/
/* 17939*/ 0, /*End of Scope*/
/* 17940*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->18098
/* 17943*/ OPC_CheckChild1Type, MVT::i64,
/* 17945*/ OPC_RecordChild2, // #2 = $rs2
/* 17946*/ OPC_Scope, 74, /*->18022*/ // 2 children in Scope
/* 17948*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_xor_32
/* 17950*/ OPC_Scope, 13, /*->17965*/ // 5 children in Scope
/* 17952*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_xor_32_monotonic
/* 17954*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17956*/ OPC_EmitMergeInputChains1_0,
/* 17957*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_monotonic>> - Complexity = 4
// Dst: (AMOXOR_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17965*/ /*Scope*/ 13, /*->17979*/
/* 17966*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_xor_32_acquire
/* 17968*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17970*/ OPC_EmitMergeInputChains1_0,
/* 17971*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acquire>> - Complexity = 4
// Dst: (AMOXOR_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17979*/ /*Scope*/ 13, /*->17993*/
/* 17980*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_xor_32_release
/* 17982*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17984*/ OPC_EmitMergeInputChains1_0,
/* 17985*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_release>> - Complexity = 4
// Dst: (AMOXOR_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 17993*/ /*Scope*/ 13, /*->18007*/
/* 17994*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_xor_32_acq_rel
/* 17996*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 17998*/ OPC_EmitMergeInputChains1_0,
/* 17999*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18007*/ /*Scope*/ 13, /*->18021*/
/* 18008*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_xor_32_seq_cst
/* 18010*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18012*/ OPC_EmitMergeInputChains1_0,
/* 18013*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_32>><<P:Predicate_atomic_load_xor_32_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18021*/ 0, /*End of Scope*/
/* 18022*/ /*Scope*/ 74, /*->18097*/
/* 18023*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_xor_64
/* 18025*/ OPC_Scope, 13, /*->18040*/ // 5 children in Scope
/* 18027*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_xor_64_monotonic
/* 18029*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18031*/ OPC_EmitMergeInputChains1_0,
/* 18032*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_monotonic>> - Complexity = 4
// Dst: (AMOXOR_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18040*/ /*Scope*/ 13, /*->18054*/
/* 18041*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_xor_64_acquire
/* 18043*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18045*/ OPC_EmitMergeInputChains1_0,
/* 18046*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acquire>> - Complexity = 4
// Dst: (AMOXOR_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18054*/ /*Scope*/ 13, /*->18068*/
/* 18055*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_xor_64_release
/* 18057*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18059*/ OPC_EmitMergeInputChains1_0,
/* 18060*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_release>> - Complexity = 4
// Dst: (AMOXOR_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18068*/ /*Scope*/ 13, /*->18082*/
/* 18069*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_xor_64_acq_rel
/* 18071*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18073*/ OPC_EmitMergeInputChains1_0,
/* 18074*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_acq_rel>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18082*/ /*Scope*/ 13, /*->18096*/
/* 18083*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_xor_64_seq_cst
/* 18085*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18087*/ OPC_EmitMergeInputChains1_0,
/* 18088*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOXOR_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_xor:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_xor_64>><<P:Predicate_atomic_load_xor_64_seq_cst>> - Complexity = 4
// Dst: (AMOXOR_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18096*/ 0, /*End of Scope*/
/* 18097*/ 0, /*End of Scope*/
/* 18098*/ 0, // EndSwitchType
/* 18099*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_MAX),// ->18576
/* 18103*/ OPC_RecordMemRef,
/* 18104*/ OPC_RecordNode, // #0 = 'atomic_load_max' chained node
/* 18105*/ OPC_RecordChild1, // #1 = $rs1
/* 18106*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->18417
/* 18110*/ OPC_CheckChild1Type, MVT::i32,
/* 18112*/ OPC_RecordChild2, // #2 = $rs2
/* 18113*/ OPC_Scope, 21|128,1/*149*/, /*->18265*/ // 2 children in Scope
/* 18116*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_max_32
/* 18118*/ OPC_Scope, 28, /*->18148*/ // 5 children in Scope
/* 18120*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_max_32_monotonic
/* 18122*/ OPC_Scope, 11, /*->18135*/ // 2 children in Scope
/* 18124*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18126*/ OPC_EmitMergeInputChains1_0,
/* 18127*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_monotonic>> - Complexity = 4
// Dst: (AMOMAX_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18135*/ /*Scope*/ 11, /*->18147*/
/* 18136*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18138*/ OPC_EmitMergeInputChains1_0,
/* 18139*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_monotonic>> - Complexity = 4
// Dst: (AMOMAX_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18147*/ 0, /*End of Scope*/
/* 18148*/ /*Scope*/ 28, /*->18177*/
/* 18149*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_max_32_acquire
/* 18151*/ OPC_Scope, 11, /*->18164*/ // 2 children in Scope
/* 18153*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18155*/ OPC_EmitMergeInputChains1_0,
/* 18156*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acquire>> - Complexity = 4
// Dst: (AMOMAX_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18164*/ /*Scope*/ 11, /*->18176*/
/* 18165*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18167*/ OPC_EmitMergeInputChains1_0,
/* 18168*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acquire>> - Complexity = 4
// Dst: (AMOMAX_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18176*/ 0, /*End of Scope*/
/* 18177*/ /*Scope*/ 28, /*->18206*/
/* 18178*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_max_32_release
/* 18180*/ OPC_Scope, 11, /*->18193*/ // 2 children in Scope
/* 18182*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18184*/ OPC_EmitMergeInputChains1_0,
/* 18185*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_release>> - Complexity = 4
// Dst: (AMOMAX_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18193*/ /*Scope*/ 11, /*->18205*/
/* 18194*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18196*/ OPC_EmitMergeInputChains1_0,
/* 18197*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_release>> - Complexity = 4
// Dst: (AMOMAX_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18205*/ 0, /*End of Scope*/
/* 18206*/ /*Scope*/ 28, /*->18235*/
/* 18207*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_max_32_acq_rel
/* 18209*/ OPC_Scope, 11, /*->18222*/ // 2 children in Scope
/* 18211*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18213*/ OPC_EmitMergeInputChains1_0,
/* 18214*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18222*/ /*Scope*/ 11, /*->18234*/
/* 18223*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18225*/ OPC_EmitMergeInputChains1_0,
/* 18226*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18234*/ 0, /*End of Scope*/
/* 18235*/ /*Scope*/ 28, /*->18264*/
/* 18236*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_max_32_seq_cst
/* 18238*/ OPC_Scope, 11, /*->18251*/ // 2 children in Scope
/* 18240*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18242*/ OPC_EmitMergeInputChains1_0,
/* 18243*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18251*/ /*Scope*/ 11, /*->18263*/
/* 18252*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18254*/ OPC_EmitMergeInputChains1_0,
/* 18255*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18263*/ 0, /*End of Scope*/
/* 18264*/ 0, /*End of Scope*/
/* 18265*/ /*Scope*/ 21|128,1/*149*/, /*->18416*/
/* 18267*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_max_64
/* 18269*/ OPC_Scope, 28, /*->18299*/ // 5 children in Scope
/* 18271*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_max_64_monotonic
/* 18273*/ OPC_Scope, 11, /*->18286*/ // 2 children in Scope
/* 18275*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18277*/ OPC_EmitMergeInputChains1_0,
/* 18278*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_monotonic>> - Complexity = 4
// Dst: (AMOMAX_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18286*/ /*Scope*/ 11, /*->18298*/
/* 18287*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18289*/ OPC_EmitMergeInputChains1_0,
/* 18290*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_monotonic>> - Complexity = 4
// Dst: (AMOMAX_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18298*/ 0, /*End of Scope*/
/* 18299*/ /*Scope*/ 28, /*->18328*/
/* 18300*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_max_64_acquire
/* 18302*/ OPC_Scope, 11, /*->18315*/ // 2 children in Scope
/* 18304*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18306*/ OPC_EmitMergeInputChains1_0,
/* 18307*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acquire>> - Complexity = 4
// Dst: (AMOMAX_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18315*/ /*Scope*/ 11, /*->18327*/
/* 18316*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18318*/ OPC_EmitMergeInputChains1_0,
/* 18319*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acquire>> - Complexity = 4
// Dst: (AMOMAX_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18327*/ 0, /*End of Scope*/
/* 18328*/ /*Scope*/ 28, /*->18357*/
/* 18329*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_max_64_release
/* 18331*/ OPC_Scope, 11, /*->18344*/ // 2 children in Scope
/* 18333*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18335*/ OPC_EmitMergeInputChains1_0,
/* 18336*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_release>> - Complexity = 4
// Dst: (AMOMAX_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18344*/ /*Scope*/ 11, /*->18356*/
/* 18345*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18347*/ OPC_EmitMergeInputChains1_0,
/* 18348*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_release>> - Complexity = 4
// Dst: (AMOMAX_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18356*/ 0, /*End of Scope*/
/* 18357*/ /*Scope*/ 28, /*->18386*/
/* 18358*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_max_64_acq_rel
/* 18360*/ OPC_Scope, 11, /*->18373*/ // 2 children in Scope
/* 18362*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18364*/ OPC_EmitMergeInputChains1_0,
/* 18365*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18373*/ /*Scope*/ 11, /*->18385*/
/* 18374*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18376*/ OPC_EmitMergeInputChains1_0,
/* 18377*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18385*/ 0, /*End of Scope*/
/* 18386*/ /*Scope*/ 28, /*->18415*/
/* 18387*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_max_64_seq_cst
/* 18389*/ OPC_Scope, 11, /*->18402*/ // 2 children in Scope
/* 18391*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18393*/ OPC_EmitMergeInputChains1_0,
/* 18394*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18402*/ /*Scope*/ 11, /*->18414*/
/* 18403*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18405*/ OPC_EmitMergeInputChains1_0,
/* 18406*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18414*/ 0, /*End of Scope*/
/* 18415*/ 0, /*End of Scope*/
/* 18416*/ 0, /*End of Scope*/
/* 18417*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->18575
/* 18420*/ OPC_CheckChild1Type, MVT::i64,
/* 18422*/ OPC_RecordChild2, // #2 = $rs2
/* 18423*/ OPC_Scope, 74, /*->18499*/ // 2 children in Scope
/* 18425*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_max_32
/* 18427*/ OPC_Scope, 13, /*->18442*/ // 5 children in Scope
/* 18429*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_max_32_monotonic
/* 18431*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18433*/ OPC_EmitMergeInputChains1_0,
/* 18434*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_monotonic>> - Complexity = 4
// Dst: (AMOMAX_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18442*/ /*Scope*/ 13, /*->18456*/
/* 18443*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_max_32_acquire
/* 18445*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18447*/ OPC_EmitMergeInputChains1_0,
/* 18448*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acquire>> - Complexity = 4
// Dst: (AMOMAX_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18456*/ /*Scope*/ 13, /*->18470*/
/* 18457*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_max_32_release
/* 18459*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18461*/ OPC_EmitMergeInputChains1_0,
/* 18462*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_release>> - Complexity = 4
// Dst: (AMOMAX_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18470*/ /*Scope*/ 13, /*->18484*/
/* 18471*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_max_32_acq_rel
/* 18473*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18475*/ OPC_EmitMergeInputChains1_0,
/* 18476*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18484*/ /*Scope*/ 13, /*->18498*/
/* 18485*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_max_32_seq_cst
/* 18487*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18489*/ OPC_EmitMergeInputChains1_0,
/* 18490*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_32>><<P:Predicate_atomic_load_max_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18498*/ 0, /*End of Scope*/
/* 18499*/ /*Scope*/ 74, /*->18574*/
/* 18500*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_max_64
/* 18502*/ OPC_Scope, 13, /*->18517*/ // 5 children in Scope
/* 18504*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_max_64_monotonic
/* 18506*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18508*/ OPC_EmitMergeInputChains1_0,
/* 18509*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_monotonic>> - Complexity = 4
// Dst: (AMOMAX_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18517*/ /*Scope*/ 13, /*->18531*/
/* 18518*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_max_64_acquire
/* 18520*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18522*/ OPC_EmitMergeInputChains1_0,
/* 18523*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acquire>> - Complexity = 4
// Dst: (AMOMAX_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18531*/ /*Scope*/ 13, /*->18545*/
/* 18532*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_max_64_release
/* 18534*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18536*/ OPC_EmitMergeInputChains1_0,
/* 18537*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_release>> - Complexity = 4
// Dst: (AMOMAX_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18545*/ /*Scope*/ 13, /*->18559*/
/* 18546*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_max_64_acq_rel
/* 18548*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18550*/ OPC_EmitMergeInputChains1_0,
/* 18551*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18559*/ /*Scope*/ 13, /*->18573*/
/* 18560*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_max_64_seq_cst
/* 18562*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18564*/ OPC_EmitMergeInputChains1_0,
/* 18565*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAX_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_max:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_max_64>><<P:Predicate_atomic_load_max_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAX_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18573*/ 0, /*End of Scope*/
/* 18574*/ 0, /*End of Scope*/
/* 18575*/ 0, // EndSwitchType
/* 18576*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_MIN),// ->19053
/* 18580*/ OPC_RecordMemRef,
/* 18581*/ OPC_RecordNode, // #0 = 'atomic_load_min' chained node
/* 18582*/ OPC_RecordChild1, // #1 = $rs1
/* 18583*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->18894
/* 18587*/ OPC_CheckChild1Type, MVT::i32,
/* 18589*/ OPC_RecordChild2, // #2 = $rs2
/* 18590*/ OPC_Scope, 21|128,1/*149*/, /*->18742*/ // 2 children in Scope
/* 18593*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_min_32
/* 18595*/ OPC_Scope, 28, /*->18625*/ // 5 children in Scope
/* 18597*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_min_32_monotonic
/* 18599*/ OPC_Scope, 11, /*->18612*/ // 2 children in Scope
/* 18601*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18603*/ OPC_EmitMergeInputChains1_0,
/* 18604*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_monotonic>> - Complexity = 4
// Dst: (AMOMIN_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18612*/ /*Scope*/ 11, /*->18624*/
/* 18613*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18615*/ OPC_EmitMergeInputChains1_0,
/* 18616*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_monotonic>> - Complexity = 4
// Dst: (AMOMIN_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18624*/ 0, /*End of Scope*/
/* 18625*/ /*Scope*/ 28, /*->18654*/
/* 18626*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_min_32_acquire
/* 18628*/ OPC_Scope, 11, /*->18641*/ // 2 children in Scope
/* 18630*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18632*/ OPC_EmitMergeInputChains1_0,
/* 18633*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acquire>> - Complexity = 4
// Dst: (AMOMIN_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18641*/ /*Scope*/ 11, /*->18653*/
/* 18642*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18644*/ OPC_EmitMergeInputChains1_0,
/* 18645*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acquire>> - Complexity = 4
// Dst: (AMOMIN_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18653*/ 0, /*End of Scope*/
/* 18654*/ /*Scope*/ 28, /*->18683*/
/* 18655*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_min_32_release
/* 18657*/ OPC_Scope, 11, /*->18670*/ // 2 children in Scope
/* 18659*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18661*/ OPC_EmitMergeInputChains1_0,
/* 18662*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_release>> - Complexity = 4
// Dst: (AMOMIN_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18670*/ /*Scope*/ 11, /*->18682*/
/* 18671*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18673*/ OPC_EmitMergeInputChains1_0,
/* 18674*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_release>> - Complexity = 4
// Dst: (AMOMIN_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18682*/ 0, /*End of Scope*/
/* 18683*/ /*Scope*/ 28, /*->18712*/
/* 18684*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_min_32_acq_rel
/* 18686*/ OPC_Scope, 11, /*->18699*/ // 2 children in Scope
/* 18688*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18690*/ OPC_EmitMergeInputChains1_0,
/* 18691*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18699*/ /*Scope*/ 11, /*->18711*/
/* 18700*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18702*/ OPC_EmitMergeInputChains1_0,
/* 18703*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18711*/ 0, /*End of Scope*/
/* 18712*/ /*Scope*/ 28, /*->18741*/
/* 18713*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_min_32_seq_cst
/* 18715*/ OPC_Scope, 11, /*->18728*/ // 2 children in Scope
/* 18717*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18719*/ OPC_EmitMergeInputChains1_0,
/* 18720*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18728*/ /*Scope*/ 11, /*->18740*/
/* 18729*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 18731*/ OPC_EmitMergeInputChains1_0,
/* 18732*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18740*/ 0, /*End of Scope*/
/* 18741*/ 0, /*End of Scope*/
/* 18742*/ /*Scope*/ 21|128,1/*149*/, /*->18893*/
/* 18744*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_min_64
/* 18746*/ OPC_Scope, 28, /*->18776*/ // 5 children in Scope
/* 18748*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_min_64_monotonic
/* 18750*/ OPC_Scope, 11, /*->18763*/ // 2 children in Scope
/* 18752*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18754*/ OPC_EmitMergeInputChains1_0,
/* 18755*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_monotonic>> - Complexity = 4
// Dst: (AMOMIN_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18763*/ /*Scope*/ 11, /*->18775*/
/* 18764*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18766*/ OPC_EmitMergeInputChains1_0,
/* 18767*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_monotonic>> - Complexity = 4
// Dst: (AMOMIN_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18775*/ 0, /*End of Scope*/
/* 18776*/ /*Scope*/ 28, /*->18805*/
/* 18777*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_min_64_acquire
/* 18779*/ OPC_Scope, 11, /*->18792*/ // 2 children in Scope
/* 18781*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18783*/ OPC_EmitMergeInputChains1_0,
/* 18784*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acquire>> - Complexity = 4
// Dst: (AMOMIN_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18792*/ /*Scope*/ 11, /*->18804*/
/* 18793*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18795*/ OPC_EmitMergeInputChains1_0,
/* 18796*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acquire>> - Complexity = 4
// Dst: (AMOMIN_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18804*/ 0, /*End of Scope*/
/* 18805*/ /*Scope*/ 28, /*->18834*/
/* 18806*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_min_64_release
/* 18808*/ OPC_Scope, 11, /*->18821*/ // 2 children in Scope
/* 18810*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18812*/ OPC_EmitMergeInputChains1_0,
/* 18813*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_release>> - Complexity = 4
// Dst: (AMOMIN_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18821*/ /*Scope*/ 11, /*->18833*/
/* 18822*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18824*/ OPC_EmitMergeInputChains1_0,
/* 18825*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_release>> - Complexity = 4
// Dst: (AMOMIN_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18833*/ 0, /*End of Scope*/
/* 18834*/ /*Scope*/ 28, /*->18863*/
/* 18835*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_min_64_acq_rel
/* 18837*/ OPC_Scope, 11, /*->18850*/ // 2 children in Scope
/* 18839*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18841*/ OPC_EmitMergeInputChains1_0,
/* 18842*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18850*/ /*Scope*/ 11, /*->18862*/
/* 18851*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18853*/ OPC_EmitMergeInputChains1_0,
/* 18854*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18862*/ 0, /*End of Scope*/
/* 18863*/ /*Scope*/ 28, /*->18892*/
/* 18864*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_min_64_seq_cst
/* 18866*/ OPC_Scope, 11, /*->18879*/ // 2 children in Scope
/* 18868*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 18870*/ OPC_EmitMergeInputChains1_0,
/* 18871*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18879*/ /*Scope*/ 11, /*->18891*/
/* 18880*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 18882*/ OPC_EmitMergeInputChains1_0,
/* 18883*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 18891*/ 0, /*End of Scope*/
/* 18892*/ 0, /*End of Scope*/
/* 18893*/ 0, /*End of Scope*/
/* 18894*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->19052
/* 18897*/ OPC_CheckChild1Type, MVT::i64,
/* 18899*/ OPC_RecordChild2, // #2 = $rs2
/* 18900*/ OPC_Scope, 74, /*->18976*/ // 2 children in Scope
/* 18902*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_min_32
/* 18904*/ OPC_Scope, 13, /*->18919*/ // 5 children in Scope
/* 18906*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_min_32_monotonic
/* 18908*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18910*/ OPC_EmitMergeInputChains1_0,
/* 18911*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_monotonic>> - Complexity = 4
// Dst: (AMOMIN_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18919*/ /*Scope*/ 13, /*->18933*/
/* 18920*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_min_32_acquire
/* 18922*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18924*/ OPC_EmitMergeInputChains1_0,
/* 18925*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acquire>> - Complexity = 4
// Dst: (AMOMIN_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18933*/ /*Scope*/ 13, /*->18947*/
/* 18934*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_min_32_release
/* 18936*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18938*/ OPC_EmitMergeInputChains1_0,
/* 18939*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_release>> - Complexity = 4
// Dst: (AMOMIN_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18947*/ /*Scope*/ 13, /*->18961*/
/* 18948*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_min_32_acq_rel
/* 18950*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18952*/ OPC_EmitMergeInputChains1_0,
/* 18953*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18961*/ /*Scope*/ 13, /*->18975*/
/* 18962*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_min_32_seq_cst
/* 18964*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18966*/ OPC_EmitMergeInputChains1_0,
/* 18967*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_32>><<P:Predicate_atomic_load_min_32_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18975*/ 0, /*End of Scope*/
/* 18976*/ /*Scope*/ 74, /*->19051*/
/* 18977*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_min_64
/* 18979*/ OPC_Scope, 13, /*->18994*/ // 5 children in Scope
/* 18981*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_min_64_monotonic
/* 18983*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18985*/ OPC_EmitMergeInputChains1_0,
/* 18986*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_monotonic>> - Complexity = 4
// Dst: (AMOMIN_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 18994*/ /*Scope*/ 13, /*->19008*/
/* 18995*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_min_64_acquire
/* 18997*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 18999*/ OPC_EmitMergeInputChains1_0,
/* 19000*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acquire>> - Complexity = 4
// Dst: (AMOMIN_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19008*/ /*Scope*/ 13, /*->19022*/
/* 19009*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_min_64_release
/* 19011*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19013*/ OPC_EmitMergeInputChains1_0,
/* 19014*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_release>> - Complexity = 4
// Dst: (AMOMIN_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19022*/ /*Scope*/ 13, /*->19036*/
/* 19023*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_min_64_acq_rel
/* 19025*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19027*/ OPC_EmitMergeInputChains1_0,
/* 19028*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_acq_rel>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19036*/ /*Scope*/ 13, /*->19050*/
/* 19037*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_min_64_seq_cst
/* 19039*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19041*/ OPC_EmitMergeInputChains1_0,
/* 19042*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMIN_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_min:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_min_64>><<P:Predicate_atomic_load_min_64_seq_cst>> - Complexity = 4
// Dst: (AMOMIN_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19050*/ 0, /*End of Scope*/
/* 19051*/ 0, /*End of Scope*/
/* 19052*/ 0, // EndSwitchType
/* 19053*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_UMAX),// ->19530
/* 19057*/ OPC_RecordMemRef,
/* 19058*/ OPC_RecordNode, // #0 = 'atomic_load_umax' chained node
/* 19059*/ OPC_RecordChild1, // #1 = $rs1
/* 19060*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->19371
/* 19064*/ OPC_CheckChild1Type, MVT::i32,
/* 19066*/ OPC_RecordChild2, // #2 = $rs2
/* 19067*/ OPC_Scope, 21|128,1/*149*/, /*->19219*/ // 2 children in Scope
/* 19070*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_umax_32
/* 19072*/ OPC_Scope, 28, /*->19102*/ // 5 children in Scope
/* 19074*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umax_32_monotonic
/* 19076*/ OPC_Scope, 11, /*->19089*/ // 2 children in Scope
/* 19078*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19080*/ OPC_EmitMergeInputChains1_0,
/* 19081*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19089*/ /*Scope*/ 11, /*->19101*/
/* 19090*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19092*/ OPC_EmitMergeInputChains1_0,
/* 19093*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19101*/ 0, /*End of Scope*/
/* 19102*/ /*Scope*/ 28, /*->19131*/
/* 19103*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umax_32_acquire
/* 19105*/ OPC_Scope, 11, /*->19118*/ // 2 children in Scope
/* 19107*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19109*/ OPC_EmitMergeInputChains1_0,
/* 19110*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acquire>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19118*/ /*Scope*/ 11, /*->19130*/
/* 19119*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19121*/ OPC_EmitMergeInputChains1_0,
/* 19122*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acquire>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19130*/ 0, /*End of Scope*/
/* 19131*/ /*Scope*/ 28, /*->19160*/
/* 19132*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umax_32_release
/* 19134*/ OPC_Scope, 11, /*->19147*/ // 2 children in Scope
/* 19136*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19138*/ OPC_EmitMergeInputChains1_0,
/* 19139*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_release>> - Complexity = 4
// Dst: (AMOMAXU_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19147*/ /*Scope*/ 11, /*->19159*/
/* 19148*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19150*/ OPC_EmitMergeInputChains1_0,
/* 19151*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_release>> - Complexity = 4
// Dst: (AMOMAXU_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19159*/ 0, /*End of Scope*/
/* 19160*/ /*Scope*/ 28, /*->19189*/
/* 19161*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umax_32_acq_rel
/* 19163*/ OPC_Scope, 11, /*->19176*/ // 2 children in Scope
/* 19165*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19167*/ OPC_EmitMergeInputChains1_0,
/* 19168*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19176*/ /*Scope*/ 11, /*->19188*/
/* 19177*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19179*/ OPC_EmitMergeInputChains1_0,
/* 19180*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19188*/ 0, /*End of Scope*/
/* 19189*/ /*Scope*/ 28, /*->19218*/
/* 19190*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umax_32_seq_cst
/* 19192*/ OPC_Scope, 11, /*->19205*/ // 2 children in Scope
/* 19194*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19196*/ OPC_EmitMergeInputChains1_0,
/* 19197*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19205*/ /*Scope*/ 11, /*->19217*/
/* 19206*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19208*/ OPC_EmitMergeInputChains1_0,
/* 19209*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19217*/ 0, /*End of Scope*/
/* 19218*/ 0, /*End of Scope*/
/* 19219*/ /*Scope*/ 21|128,1/*149*/, /*->19370*/
/* 19221*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_umax_64
/* 19223*/ OPC_Scope, 28, /*->19253*/ // 5 children in Scope
/* 19225*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umax_64_monotonic
/* 19227*/ OPC_Scope, 11, /*->19240*/ // 2 children in Scope
/* 19229*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19231*/ OPC_EmitMergeInputChains1_0,
/* 19232*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19240*/ /*Scope*/ 11, /*->19252*/
/* 19241*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19243*/ OPC_EmitMergeInputChains1_0,
/* 19244*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19252*/ 0, /*End of Scope*/
/* 19253*/ /*Scope*/ 28, /*->19282*/
/* 19254*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umax_64_acquire
/* 19256*/ OPC_Scope, 11, /*->19269*/ // 2 children in Scope
/* 19258*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19260*/ OPC_EmitMergeInputChains1_0,
/* 19261*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acquire>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19269*/ /*Scope*/ 11, /*->19281*/
/* 19270*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19272*/ OPC_EmitMergeInputChains1_0,
/* 19273*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acquire>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19281*/ 0, /*End of Scope*/
/* 19282*/ /*Scope*/ 28, /*->19311*/
/* 19283*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umax_64_release
/* 19285*/ OPC_Scope, 11, /*->19298*/ // 2 children in Scope
/* 19287*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19289*/ OPC_EmitMergeInputChains1_0,
/* 19290*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_release>> - Complexity = 4
// Dst: (AMOMAXU_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19298*/ /*Scope*/ 11, /*->19310*/
/* 19299*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19301*/ OPC_EmitMergeInputChains1_0,
/* 19302*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_release>> - Complexity = 4
// Dst: (AMOMAXU_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19310*/ 0, /*End of Scope*/
/* 19311*/ /*Scope*/ 28, /*->19340*/
/* 19312*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umax_64_acq_rel
/* 19314*/ OPC_Scope, 11, /*->19327*/ // 2 children in Scope
/* 19316*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19318*/ OPC_EmitMergeInputChains1_0,
/* 19319*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19327*/ /*Scope*/ 11, /*->19339*/
/* 19328*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19330*/ OPC_EmitMergeInputChains1_0,
/* 19331*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19339*/ 0, /*End of Scope*/
/* 19340*/ /*Scope*/ 28, /*->19369*/
/* 19341*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umax_64_seq_cst
/* 19343*/ OPC_Scope, 11, /*->19356*/ // 2 children in Scope
/* 19345*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19347*/ OPC_EmitMergeInputChains1_0,
/* 19348*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19356*/ /*Scope*/ 11, /*->19368*/
/* 19357*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19359*/ OPC_EmitMergeInputChains1_0,
/* 19360*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19368*/ 0, /*End of Scope*/
/* 19369*/ 0, /*End of Scope*/
/* 19370*/ 0, /*End of Scope*/
/* 19371*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->19529
/* 19374*/ OPC_CheckChild1Type, MVT::i64,
/* 19376*/ OPC_RecordChild2, // #2 = $rs2
/* 19377*/ OPC_Scope, 74, /*->19453*/ // 2 children in Scope
/* 19379*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_umax_32
/* 19381*/ OPC_Scope, 13, /*->19396*/ // 5 children in Scope
/* 19383*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umax_32_monotonic
/* 19385*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19387*/ OPC_EmitMergeInputChains1_0,
/* 19388*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19396*/ /*Scope*/ 13, /*->19410*/
/* 19397*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umax_32_acquire
/* 19399*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19401*/ OPC_EmitMergeInputChains1_0,
/* 19402*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acquire>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19410*/ /*Scope*/ 13, /*->19424*/
/* 19411*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umax_32_release
/* 19413*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19415*/ OPC_EmitMergeInputChains1_0,
/* 19416*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_release>> - Complexity = 4
// Dst: (AMOMAXU_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19424*/ /*Scope*/ 13, /*->19438*/
/* 19425*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umax_32_acq_rel
/* 19427*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19429*/ OPC_EmitMergeInputChains1_0,
/* 19430*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19438*/ /*Scope*/ 13, /*->19452*/
/* 19439*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umax_32_seq_cst
/* 19441*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19443*/ OPC_EmitMergeInputChains1_0,
/* 19444*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_32>><<P:Predicate_atomic_load_umax_32_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19452*/ 0, /*End of Scope*/
/* 19453*/ /*Scope*/ 74, /*->19528*/
/* 19454*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_umax_64
/* 19456*/ OPC_Scope, 13, /*->19471*/ // 5 children in Scope
/* 19458*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umax_64_monotonic
/* 19460*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19462*/ OPC_EmitMergeInputChains1_0,
/* 19463*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_monotonic>> - Complexity = 4
// Dst: (AMOMAXU_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19471*/ /*Scope*/ 13, /*->19485*/
/* 19472*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umax_64_acquire
/* 19474*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19476*/ OPC_EmitMergeInputChains1_0,
/* 19477*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acquire>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19485*/ /*Scope*/ 13, /*->19499*/
/* 19486*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umax_64_release
/* 19488*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19490*/ OPC_EmitMergeInputChains1_0,
/* 19491*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_release>> - Complexity = 4
// Dst: (AMOMAXU_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19499*/ /*Scope*/ 13, /*->19513*/
/* 19500*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umax_64_acq_rel
/* 19502*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19504*/ OPC_EmitMergeInputChains1_0,
/* 19505*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_acq_rel>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19513*/ /*Scope*/ 13, /*->19527*/
/* 19514*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umax_64_seq_cst
/* 19516*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19518*/ OPC_EmitMergeInputChains1_0,
/* 19519*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMAXU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umax:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umax_64>><<P:Predicate_atomic_load_umax_64_seq_cst>> - Complexity = 4
// Dst: (AMOMAXU_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19527*/ 0, /*End of Scope*/
/* 19528*/ 0, /*End of Scope*/
/* 19529*/ 0, // EndSwitchType
/* 19530*/ /*SwitchOpcode*/ 89|128,3/*473*/, TARGET_VAL(ISD::ATOMIC_LOAD_UMIN),// ->20007
/* 19534*/ OPC_RecordMemRef,
/* 19535*/ OPC_RecordNode, // #0 = 'atomic_load_umin' chained node
/* 19536*/ OPC_RecordChild1, // #1 = $rs1
/* 19537*/ OPC_SwitchType /*2 cases */, 51|128,2/*307*/, MVT::i32,// ->19848
/* 19541*/ OPC_CheckChild1Type, MVT::i32,
/* 19543*/ OPC_RecordChild2, // #2 = $rs2
/* 19544*/ OPC_Scope, 21|128,1/*149*/, /*->19696*/ // 2 children in Scope
/* 19547*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_umin_32
/* 19549*/ OPC_Scope, 28, /*->19579*/ // 5 children in Scope
/* 19551*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umin_32_monotonic
/* 19553*/ OPC_Scope, 11, /*->19566*/ // 2 children in Scope
/* 19555*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19557*/ OPC_EmitMergeInputChains1_0,
/* 19558*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_monotonic>> - Complexity = 4
// Dst: (AMOMINU_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19566*/ /*Scope*/ 11, /*->19578*/
/* 19567*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19569*/ OPC_EmitMergeInputChains1_0,
/* 19570*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_monotonic>> - Complexity = 4
// Dst: (AMOMINU_W:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19578*/ 0, /*End of Scope*/
/* 19579*/ /*Scope*/ 28, /*->19608*/
/* 19580*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umin_32_acquire
/* 19582*/ OPC_Scope, 11, /*->19595*/ // 2 children in Scope
/* 19584*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19586*/ OPC_EmitMergeInputChains1_0,
/* 19587*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acquire>> - Complexity = 4
// Dst: (AMOMINU_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19595*/ /*Scope*/ 11, /*->19607*/
/* 19596*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19598*/ OPC_EmitMergeInputChains1_0,
/* 19599*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acquire>> - Complexity = 4
// Dst: (AMOMINU_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19607*/ 0, /*End of Scope*/
/* 19608*/ /*Scope*/ 28, /*->19637*/
/* 19609*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umin_32_release
/* 19611*/ OPC_Scope, 11, /*->19624*/ // 2 children in Scope
/* 19613*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19615*/ OPC_EmitMergeInputChains1_0,
/* 19616*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_release>> - Complexity = 4
// Dst: (AMOMINU_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19624*/ /*Scope*/ 11, /*->19636*/
/* 19625*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19627*/ OPC_EmitMergeInputChains1_0,
/* 19628*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_release>> - Complexity = 4
// Dst: (AMOMINU_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19636*/ 0, /*End of Scope*/
/* 19637*/ /*Scope*/ 28, /*->19666*/
/* 19638*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umin_32_acq_rel
/* 19640*/ OPC_Scope, 11, /*->19653*/ // 2 children in Scope
/* 19642*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19644*/ OPC_EmitMergeInputChains1_0,
/* 19645*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19653*/ /*Scope*/ 11, /*->19665*/
/* 19654*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19656*/ OPC_EmitMergeInputChains1_0,
/* 19657*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19665*/ 0, /*End of Scope*/
/* 19666*/ /*Scope*/ 28, /*->19695*/
/* 19667*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umin_32_seq_cst
/* 19669*/ OPC_Scope, 11, /*->19682*/ // 2 children in Scope
/* 19671*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19673*/ OPC_EmitMergeInputChains1_0,
/* 19674*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19682*/ /*Scope*/ 11, /*->19694*/
/* 19683*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 19685*/ OPC_EmitMergeInputChains1_0,
/* 19686*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19694*/ 0, /*End of Scope*/
/* 19695*/ 0, /*End of Scope*/
/* 19696*/ /*Scope*/ 21|128,1/*149*/, /*->19847*/
/* 19698*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_umin_64
/* 19700*/ OPC_Scope, 28, /*->19730*/ // 5 children in Scope
/* 19702*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umin_64_monotonic
/* 19704*/ OPC_Scope, 11, /*->19717*/ // 2 children in Scope
/* 19706*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19708*/ OPC_EmitMergeInputChains1_0,
/* 19709*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_monotonic>> - Complexity = 4
// Dst: (AMOMINU_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19717*/ /*Scope*/ 11, /*->19729*/
/* 19718*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19720*/ OPC_EmitMergeInputChains1_0,
/* 19721*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_monotonic>> - Complexity = 4
// Dst: (AMOMINU_D:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19729*/ 0, /*End of Scope*/
/* 19730*/ /*Scope*/ 28, /*->19759*/
/* 19731*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umin_64_acquire
/* 19733*/ OPC_Scope, 11, /*->19746*/ // 2 children in Scope
/* 19735*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19737*/ OPC_EmitMergeInputChains1_0,
/* 19738*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acquire>> - Complexity = 4
// Dst: (AMOMINU_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19746*/ /*Scope*/ 11, /*->19758*/
/* 19747*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19749*/ OPC_EmitMergeInputChains1_0,
/* 19750*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acquire>> - Complexity = 4
// Dst: (AMOMINU_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19758*/ 0, /*End of Scope*/
/* 19759*/ /*Scope*/ 28, /*->19788*/
/* 19760*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umin_64_release
/* 19762*/ OPC_Scope, 11, /*->19775*/ // 2 children in Scope
/* 19764*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19766*/ OPC_EmitMergeInputChains1_0,
/* 19767*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_release>> - Complexity = 4
// Dst: (AMOMINU_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19775*/ /*Scope*/ 11, /*->19787*/
/* 19776*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19778*/ OPC_EmitMergeInputChains1_0,
/* 19779*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_release>> - Complexity = 4
// Dst: (AMOMINU_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19787*/ 0, /*End of Scope*/
/* 19788*/ /*Scope*/ 28, /*->19817*/
/* 19789*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umin_64_acq_rel
/* 19791*/ OPC_Scope, 11, /*->19804*/ // 2 children in Scope
/* 19793*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19795*/ OPC_EmitMergeInputChains1_0,
/* 19796*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19804*/ /*Scope*/ 11, /*->19816*/
/* 19805*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19807*/ OPC_EmitMergeInputChains1_0,
/* 19808*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19816*/ 0, /*End of Scope*/
/* 19817*/ /*Scope*/ 28, /*->19846*/
/* 19818*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umin_64_seq_cst
/* 19820*/ OPC_Scope, 11, /*->19833*/ // 2 children in Scope
/* 19822*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 19824*/ OPC_EmitMergeInputChains1_0,
/* 19825*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19833*/ /*Scope*/ 11, /*->19845*/
/* 19834*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 19836*/ OPC_EmitMergeInputChains1_0,
/* 19837*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 19845*/ 0, /*End of Scope*/
/* 19846*/ 0, /*End of Scope*/
/* 19847*/ 0, /*End of Scope*/
/* 19848*/ /*SwitchType*/ 27|128,1/*155*/, MVT::i64,// ->20006
/* 19851*/ OPC_CheckChild1Type, MVT::i64,
/* 19853*/ OPC_RecordChild2, // #2 = $rs2
/* 19854*/ OPC_Scope, 74, /*->19930*/ // 2 children in Scope
/* 19856*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_umin_32
/* 19858*/ OPC_Scope, 13, /*->19873*/ // 5 children in Scope
/* 19860*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umin_32_monotonic
/* 19862*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19864*/ OPC_EmitMergeInputChains1_0,
/* 19865*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_monotonic>> - Complexity = 4
// Dst: (AMOMINU_W:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19873*/ /*Scope*/ 13, /*->19887*/
/* 19874*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umin_32_acquire
/* 19876*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19878*/ OPC_EmitMergeInputChains1_0,
/* 19879*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acquire>> - Complexity = 4
// Dst: (AMOMINU_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19887*/ /*Scope*/ 13, /*->19901*/
/* 19888*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umin_32_release
/* 19890*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19892*/ OPC_EmitMergeInputChains1_0,
/* 19893*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_release>> - Complexity = 4
// Dst: (AMOMINU_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19901*/ /*Scope*/ 13, /*->19915*/
/* 19902*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umin_32_acq_rel
/* 19904*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19906*/ OPC_EmitMergeInputChains1_0,
/* 19907*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19915*/ /*Scope*/ 13, /*->19929*/
/* 19916*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umin_32_seq_cst
/* 19918*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19920*/ OPC_EmitMergeInputChains1_0,
/* 19921*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_32>><<P:Predicate_atomic_load_umin_32_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19929*/ 0, /*End of Scope*/
/* 19930*/ /*Scope*/ 74, /*->20005*/
/* 19931*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_umin_64
/* 19933*/ OPC_Scope, 13, /*->19948*/ // 5 children in Scope
/* 19935*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_umin_64_monotonic
/* 19937*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19939*/ OPC_EmitMergeInputChains1_0,
/* 19940*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_monotonic>> - Complexity = 4
// Dst: (AMOMINU_D:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19948*/ /*Scope*/ 13, /*->19962*/
/* 19949*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_umin_64_acquire
/* 19951*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19953*/ OPC_EmitMergeInputChains1_0,
/* 19954*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acquire>> - Complexity = 4
// Dst: (AMOMINU_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19962*/ /*Scope*/ 13, /*->19976*/
/* 19963*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_umin_64_release
/* 19965*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19967*/ OPC_EmitMergeInputChains1_0,
/* 19968*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_release>> - Complexity = 4
// Dst: (AMOMINU_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19976*/ /*Scope*/ 13, /*->19990*/
/* 19977*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_umin_64_acq_rel
/* 19979*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19981*/ OPC_EmitMergeInputChains1_0,
/* 19982*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_acq_rel>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 19990*/ /*Scope*/ 13, /*->20004*/
/* 19991*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_umin_64_seq_cst
/* 19993*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 19995*/ OPC_EmitMergeInputChains1_0,
/* 19996*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOMINU_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (atomic_load_umin:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)<<P:Predicate_atomic_load_umin_64>><<P:Predicate_atomic_load_umin_64_seq_cst>> - Complexity = 4
// Dst: (AMOMINU_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 20004*/ 0, /*End of Scope*/
/* 20005*/ 0, /*End of Scope*/
/* 20006*/ 0, // EndSwitchType
/* 20007*/ /*SwitchOpcode*/ 111|128,4/*623*/, TARGET_VAL(ISD::ATOMIC_LOAD_NAND),// ->20634
/* 20011*/ OPC_RecordMemRef,
/* 20012*/ OPC_RecordNode, // #0 = 'atomic_load_nand' chained node
/* 20013*/ OPC_RecordChild1, // #1 = $addr
/* 20014*/ OPC_SwitchType /*2 cases */, 23|128,3/*407*/, MVT::i32,// ->20425
/* 20018*/ OPC_CheckChild1Type, MVT::i32,
/* 20020*/ OPC_RecordChild2, // #2 = $incr
/* 20021*/ OPC_Scope, 71|128,1/*199*/, /*->20223*/ // 2 children in Scope
/* 20024*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_nand_32
/* 20026*/ OPC_Scope, 38, /*->20066*/ // 5 children in Scope
/* 20028*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_nand_32_monotonic
/* 20030*/ OPC_Scope, 16, /*->20048*/ // 2 children in Scope
/* 20032*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20034*/ OPC_EmitMergeInputChains1_0,
/* 20035*/ OPC_EmitInteger, MVT::i32, 2,
/* 20038*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 2:{ *:[i32] })
/* 20048*/ /*Scope*/ 16, /*->20065*/
/* 20049*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20051*/ OPC_EmitMergeInputChains1_0,
/* 20052*/ OPC_EmitInteger, MVT::i32, 2,
/* 20055*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 2:{ *:[i32] })
/* 20065*/ 0, /*End of Scope*/
/* 20066*/ /*Scope*/ 38, /*->20105*/
/* 20067*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_nand_32_acquire
/* 20069*/ OPC_Scope, 16, /*->20087*/ // 2 children in Scope
/* 20071*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20073*/ OPC_EmitMergeInputChains1_0,
/* 20074*/ OPC_EmitInteger, MVT::i32, 4,
/* 20077*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 4:{ *:[i32] })
/* 20087*/ /*Scope*/ 16, /*->20104*/
/* 20088*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20090*/ OPC_EmitMergeInputChains1_0,
/* 20091*/ OPC_EmitInteger, MVT::i32, 4,
/* 20094*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 4:{ *:[i32] })
/* 20104*/ 0, /*End of Scope*/
/* 20105*/ /*Scope*/ 38, /*->20144*/
/* 20106*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_nand_32_release
/* 20108*/ OPC_Scope, 16, /*->20126*/ // 2 children in Scope
/* 20110*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20112*/ OPC_EmitMergeInputChains1_0,
/* 20113*/ OPC_EmitInteger, MVT::i32, 5,
/* 20116*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 5:{ *:[i32] })
/* 20126*/ /*Scope*/ 16, /*->20143*/
/* 20127*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20129*/ OPC_EmitMergeInputChains1_0,
/* 20130*/ OPC_EmitInteger, MVT::i32, 5,
/* 20133*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 5:{ *:[i32] })
/* 20143*/ 0, /*End of Scope*/
/* 20144*/ /*Scope*/ 38, /*->20183*/
/* 20145*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_nand_32_acq_rel
/* 20147*/ OPC_Scope, 16, /*->20165*/ // 2 children in Scope
/* 20149*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20151*/ OPC_EmitMergeInputChains1_0,
/* 20152*/ OPC_EmitInteger, MVT::i32, 6,
/* 20155*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 6:{ *:[i32] })
/* 20165*/ /*Scope*/ 16, /*->20182*/
/* 20166*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20168*/ OPC_EmitMergeInputChains1_0,
/* 20169*/ OPC_EmitInteger, MVT::i32, 6,
/* 20172*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 6:{ *:[i32] })
/* 20182*/ 0, /*End of Scope*/
/* 20183*/ /*Scope*/ 38, /*->20222*/
/* 20184*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_nand_32_seq_cst
/* 20186*/ OPC_Scope, 16, /*->20204*/ // 2 children in Scope
/* 20188*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20190*/ OPC_EmitMergeInputChains1_0,
/* 20191*/ OPC_EmitInteger, MVT::i32, 7,
/* 20194*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 7:{ *:[i32] })
/* 20204*/ /*Scope*/ 16, /*->20221*/
/* 20205*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20207*/ OPC_EmitMergeInputChains1_0,
/* 20208*/ OPC_EmitInteger, MVT::i32, 7,
/* 20211*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 7:{ *:[i32] })
/* 20221*/ 0, /*End of Scope*/
/* 20222*/ 0, /*End of Scope*/
/* 20223*/ /*Scope*/ 71|128,1/*199*/, /*->20424*/
/* 20225*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_nand_64
/* 20227*/ OPC_Scope, 38, /*->20267*/ // 5 children in Scope
/* 20229*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_nand_64_monotonic
/* 20231*/ OPC_Scope, 16, /*->20249*/ // 2 children in Scope
/* 20233*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20235*/ OPC_EmitMergeInputChains1_0,
/* 20236*/ OPC_EmitInteger, MVT::i32, 2,
/* 20239*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 2:{ *:[i32] })
/* 20249*/ /*Scope*/ 16, /*->20266*/
/* 20250*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20252*/ OPC_EmitMergeInputChains1_0,
/* 20253*/ OPC_EmitInteger, MVT::i32, 2,
/* 20256*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 2:{ *:[i32] })
/* 20266*/ 0, /*End of Scope*/
/* 20267*/ /*Scope*/ 38, /*->20306*/
/* 20268*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_nand_64_acquire
/* 20270*/ OPC_Scope, 16, /*->20288*/ // 2 children in Scope
/* 20272*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20274*/ OPC_EmitMergeInputChains1_0,
/* 20275*/ OPC_EmitInteger, MVT::i32, 4,
/* 20278*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 4:{ *:[i32] })
/* 20288*/ /*Scope*/ 16, /*->20305*/
/* 20289*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20291*/ OPC_EmitMergeInputChains1_0,
/* 20292*/ OPC_EmitInteger, MVT::i32, 4,
/* 20295*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 4:{ *:[i32] })
/* 20305*/ 0, /*End of Scope*/
/* 20306*/ /*Scope*/ 38, /*->20345*/
/* 20307*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_nand_64_release
/* 20309*/ OPC_Scope, 16, /*->20327*/ // 2 children in Scope
/* 20311*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20313*/ OPC_EmitMergeInputChains1_0,
/* 20314*/ OPC_EmitInteger, MVT::i32, 5,
/* 20317*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 5:{ *:[i32] })
/* 20327*/ /*Scope*/ 16, /*->20344*/
/* 20328*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20330*/ OPC_EmitMergeInputChains1_0,
/* 20331*/ OPC_EmitInteger, MVT::i32, 5,
/* 20334*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 5:{ *:[i32] })
/* 20344*/ 0, /*End of Scope*/
/* 20345*/ /*Scope*/ 38, /*->20384*/
/* 20346*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_nand_64_acq_rel
/* 20348*/ OPC_Scope, 16, /*->20366*/ // 2 children in Scope
/* 20350*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20352*/ OPC_EmitMergeInputChains1_0,
/* 20353*/ OPC_EmitInteger, MVT::i32, 6,
/* 20356*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 6:{ *:[i32] })
/* 20366*/ /*Scope*/ 16, /*->20383*/
/* 20367*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20369*/ OPC_EmitMergeInputChains1_0,
/* 20370*/ OPC_EmitInteger, MVT::i32, 6,
/* 20373*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 6:{ *:[i32] })
/* 20383*/ 0, /*End of Scope*/
/* 20384*/ /*Scope*/ 38, /*->20423*/
/* 20385*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_nand_64_seq_cst
/* 20387*/ OPC_Scope, 16, /*->20405*/ // 2 children in Scope
/* 20389*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20391*/ OPC_EmitMergeInputChains1_0,
/* 20392*/ OPC_EmitInteger, MVT::i32, 7,
/* 20395*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 7:{ *:[i32] })
/* 20405*/ /*Scope*/ 16, /*->20422*/
/* 20406*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20408*/ OPC_EmitMergeInputChains1_0,
/* 20409*/ OPC_EmitInteger, MVT::i32, 7,
/* 20412*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr, 7:{ *:[i32] })
/* 20422*/ 0, /*End of Scope*/
/* 20423*/ 0, /*End of Scope*/
/* 20424*/ 0, /*End of Scope*/
/* 20425*/ /*SwitchType*/ 77|128,1/*205*/, MVT::i64,// ->20633
/* 20428*/ OPC_CheckChild1Type, MVT::i64,
/* 20430*/ OPC_RecordChild2, // #2 = $incr
/* 20431*/ OPC_Scope, 99, /*->20532*/ // 2 children in Scope
/* 20433*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_nand_32
/* 20435*/ OPC_Scope, 18, /*->20455*/ // 5 children in Scope
/* 20437*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_nand_32_monotonic
/* 20439*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20441*/ OPC_EmitMergeInputChains1_0,
/* 20442*/ OPC_EmitInteger, MVT::i64, 2,
/* 20445*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 2:{ *:[i64] })
/* 20455*/ /*Scope*/ 18, /*->20474*/
/* 20456*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_nand_32_acquire
/* 20458*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20460*/ OPC_EmitMergeInputChains1_0,
/* 20461*/ OPC_EmitInteger, MVT::i64, 4,
/* 20464*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 4:{ *:[i64] })
/* 20474*/ /*Scope*/ 18, /*->20493*/
/* 20475*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_nand_32_release
/* 20477*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20479*/ OPC_EmitMergeInputChains1_0,
/* 20480*/ OPC_EmitInteger, MVT::i64, 5,
/* 20483*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 5:{ *:[i64] })
/* 20493*/ /*Scope*/ 18, /*->20512*/
/* 20494*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_nand_32_acq_rel
/* 20496*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20498*/ OPC_EmitMergeInputChains1_0,
/* 20499*/ OPC_EmitInteger, MVT::i64, 6,
/* 20502*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 6:{ *:[i64] })
/* 20512*/ /*Scope*/ 18, /*->20531*/
/* 20513*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_nand_32_seq_cst
/* 20515*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20517*/ OPC_EmitMergeInputChains1_0,
/* 20518*/ OPC_EmitInteger, MVT::i64, 7,
/* 20521*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_32>><<P:Predicate_atomic_load_nand_32_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 7:{ *:[i64] })
/* 20531*/ 0, /*End of Scope*/
/* 20532*/ /*Scope*/ 99, /*->20632*/
/* 20533*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_nand_64
/* 20535*/ OPC_Scope, 18, /*->20555*/ // 5 children in Scope
/* 20537*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_nand_64_monotonic
/* 20539*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20541*/ OPC_EmitMergeInputChains1_0,
/* 20542*/ OPC_EmitInteger, MVT::i64, 2,
/* 20545*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_monotonic>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 2:{ *:[i64] })
/* 20555*/ /*Scope*/ 18, /*->20574*/
/* 20556*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_nand_64_acquire
/* 20558*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20560*/ OPC_EmitMergeInputChains1_0,
/* 20561*/ OPC_EmitInteger, MVT::i64, 4,
/* 20564*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acquire>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 4:{ *:[i64] })
/* 20574*/ /*Scope*/ 18, /*->20593*/
/* 20575*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_nand_64_release
/* 20577*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20579*/ OPC_EmitMergeInputChains1_0,
/* 20580*/ OPC_EmitInteger, MVT::i64, 5,
/* 20583*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_release>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 5:{ *:[i64] })
/* 20593*/ /*Scope*/ 18, /*->20612*/
/* 20594*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_nand_64_acq_rel
/* 20596*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20598*/ OPC_EmitMergeInputChains1_0,
/* 20599*/ OPC_EmitInteger, MVT::i64, 6,
/* 20602*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_acq_rel>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 6:{ *:[i64] })
/* 20612*/ /*Scope*/ 18, /*->20631*/
/* 20613*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_nand_64_seq_cst
/* 20615*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 20617*/ OPC_EmitMergeInputChains1_0,
/* 20618*/ OPC_EmitInteger, MVT::i64, 7,
/* 20621*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoAtomicLoadNand64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 3/*#Ops*/, 1, 2, 3,
// Src: (atomic_load_nand:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_nand_64>><<P:Predicate_atomic_load_nand_64_seq_cst>> - Complexity = 4
// Dst: (PseudoAtomicLoadNand64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr, 7:{ *:[i64] })
/* 20631*/ 0, /*End of Scope*/
/* 20632*/ 0, /*End of Scope*/
/* 20633*/ 0, // EndSwitchType
/* 20634*/ /*SwitchOpcode*/ 15|128,5/*655*/, TARGET_VAL(ISD::ATOMIC_CMP_SWAP),// ->21293
/* 20638*/ OPC_RecordMemRef,
/* 20639*/ OPC_RecordNode, // #0 = 'atomic_cmp_swap' chained node
/* 20640*/ OPC_RecordChild1, // #1 = $addr
/* 20641*/ OPC_SwitchType /*2 cases */, 44|128,3/*428*/, MVT::i32,// ->21073
/* 20645*/ OPC_CheckChild1Type, MVT::i32,
/* 20647*/ OPC_RecordChild2, // #2 = $cmp
/* 20648*/ OPC_RecordChild3, // #3 = $new
/* 20649*/ OPC_Scope, 81|128,1/*209*/, /*->20861*/ // 2 children in Scope
/* 20652*/ OPC_CheckPredicate, 10, // Predicate_atomic_cmp_swap_32
/* 20654*/ OPC_Scope, 40, /*->20696*/ // 5 children in Scope
/* 20656*/ OPC_CheckPredicate, 20, // Predicate_atomic_cmp_swap_32_monotonic
/* 20658*/ OPC_Scope, 17, /*->20677*/ // 2 children in Scope
/* 20660*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20662*/ OPC_EmitMergeInputChains1_0,
/* 20663*/ OPC_EmitInteger, MVT::i32, 2,
/* 20666*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 2:{ *:[i32] })
/* 20677*/ /*Scope*/ 17, /*->20695*/
/* 20678*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20680*/ OPC_EmitMergeInputChains1_0,
/* 20681*/ OPC_EmitInteger, MVT::i32, 2,
/* 20684*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 2:{ *:[i32] })
/* 20695*/ 0, /*End of Scope*/
/* 20696*/ /*Scope*/ 40, /*->20737*/
/* 20697*/ OPC_CheckPredicate, 21, // Predicate_atomic_cmp_swap_32_acquire
/* 20699*/ OPC_Scope, 17, /*->20718*/ // 2 children in Scope
/* 20701*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20703*/ OPC_EmitMergeInputChains1_0,
/* 20704*/ OPC_EmitInteger, MVT::i32, 4,
/* 20707*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 4:{ *:[i32] })
/* 20718*/ /*Scope*/ 17, /*->20736*/
/* 20719*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20721*/ OPC_EmitMergeInputChains1_0,
/* 20722*/ OPC_EmitInteger, MVT::i32, 4,
/* 20725*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 4:{ *:[i32] })
/* 20736*/ 0, /*End of Scope*/
/* 20737*/ /*Scope*/ 40, /*->20778*/
/* 20738*/ OPC_CheckPredicate, 22, // Predicate_atomic_cmp_swap_32_release
/* 20740*/ OPC_Scope, 17, /*->20759*/ // 2 children in Scope
/* 20742*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20744*/ OPC_EmitMergeInputChains1_0,
/* 20745*/ OPC_EmitInteger, MVT::i32, 5,
/* 20748*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_release>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 5:{ *:[i32] })
/* 20759*/ /*Scope*/ 17, /*->20777*/
/* 20760*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20762*/ OPC_EmitMergeInputChains1_0,
/* 20763*/ OPC_EmitInteger, MVT::i32, 5,
/* 20766*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_release>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 5:{ *:[i32] })
/* 20777*/ 0, /*End of Scope*/
/* 20778*/ /*Scope*/ 40, /*->20819*/
/* 20779*/ OPC_CheckPredicate, 23, // Predicate_atomic_cmp_swap_32_acq_rel
/* 20781*/ OPC_Scope, 17, /*->20800*/ // 2 children in Scope
/* 20783*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20785*/ OPC_EmitMergeInputChains1_0,
/* 20786*/ OPC_EmitInteger, MVT::i32, 6,
/* 20789*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 6:{ *:[i32] })
/* 20800*/ /*Scope*/ 17, /*->20818*/
/* 20801*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20803*/ OPC_EmitMergeInputChains1_0,
/* 20804*/ OPC_EmitInteger, MVT::i32, 6,
/* 20807*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 6:{ *:[i32] })
/* 20818*/ 0, /*End of Scope*/
/* 20819*/ /*Scope*/ 40, /*->20860*/
/* 20820*/ OPC_CheckPredicate, 24, // Predicate_atomic_cmp_swap_32_seq_cst
/* 20822*/ OPC_Scope, 17, /*->20841*/ // 2 children in Scope
/* 20824*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20826*/ OPC_EmitMergeInputChains1_0,
/* 20827*/ OPC_EmitInteger, MVT::i32, 7,
/* 20830*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 7:{ *:[i32] })
/* 20841*/ /*Scope*/ 17, /*->20859*/
/* 20842*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 20844*/ OPC_EmitMergeInputChains1_0,
/* 20845*/ OPC_EmitInteger, MVT::i32, 7,
/* 20848*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 7:{ *:[i32] })
/* 20859*/ 0, /*End of Scope*/
/* 20860*/ 0, /*End of Scope*/
/* 20861*/ /*Scope*/ 81|128,1/*209*/, /*->21072*/
/* 20863*/ OPC_CheckPredicate, 14, // Predicate_atomic_cmp_swap_64
/* 20865*/ OPC_Scope, 40, /*->20907*/ // 5 children in Scope
/* 20867*/ OPC_CheckPredicate, 20, // Predicate_atomic_cmp_swap_64_monotonic
/* 20869*/ OPC_Scope, 17, /*->20888*/ // 2 children in Scope
/* 20871*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20873*/ OPC_EmitMergeInputChains1_0,
/* 20874*/ OPC_EmitInteger, MVT::i32, 2,
/* 20877*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 2:{ *:[i32] })
/* 20888*/ /*Scope*/ 17, /*->20906*/
/* 20889*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20891*/ OPC_EmitMergeInputChains1_0,
/* 20892*/ OPC_EmitInteger, MVT::i32, 2,
/* 20895*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 2:{ *:[i32] })
/* 20906*/ 0, /*End of Scope*/
/* 20907*/ /*Scope*/ 40, /*->20948*/
/* 20908*/ OPC_CheckPredicate, 21, // Predicate_atomic_cmp_swap_64_acquire
/* 20910*/ OPC_Scope, 17, /*->20929*/ // 2 children in Scope
/* 20912*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20914*/ OPC_EmitMergeInputChains1_0,
/* 20915*/ OPC_EmitInteger, MVT::i32, 4,
/* 20918*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 4:{ *:[i32] })
/* 20929*/ /*Scope*/ 17, /*->20947*/
/* 20930*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20932*/ OPC_EmitMergeInputChains1_0,
/* 20933*/ OPC_EmitInteger, MVT::i32, 4,
/* 20936*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 4:{ *:[i32] })
/* 20947*/ 0, /*End of Scope*/
/* 20948*/ /*Scope*/ 40, /*->20989*/
/* 20949*/ OPC_CheckPredicate, 22, // Predicate_atomic_cmp_swap_64_release
/* 20951*/ OPC_Scope, 17, /*->20970*/ // 2 children in Scope
/* 20953*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20955*/ OPC_EmitMergeInputChains1_0,
/* 20956*/ OPC_EmitInteger, MVT::i32, 5,
/* 20959*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_release>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 5:{ *:[i32] })
/* 20970*/ /*Scope*/ 17, /*->20988*/
/* 20971*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 20973*/ OPC_EmitMergeInputChains1_0,
/* 20974*/ OPC_EmitInteger, MVT::i32, 5,
/* 20977*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_release>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 5:{ *:[i32] })
/* 20988*/ 0, /*End of Scope*/
/* 20989*/ /*Scope*/ 40, /*->21030*/
/* 20990*/ OPC_CheckPredicate, 23, // Predicate_atomic_cmp_swap_64_acq_rel
/* 20992*/ OPC_Scope, 17, /*->21011*/ // 2 children in Scope
/* 20994*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 20996*/ OPC_EmitMergeInputChains1_0,
/* 20997*/ OPC_EmitInteger, MVT::i32, 6,
/* 21000*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 6:{ *:[i32] })
/* 21011*/ /*Scope*/ 17, /*->21029*/
/* 21012*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21014*/ OPC_EmitMergeInputChains1_0,
/* 21015*/ OPC_EmitInteger, MVT::i32, 6,
/* 21018*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 6:{ *:[i32] })
/* 21029*/ 0, /*End of Scope*/
/* 21030*/ /*Scope*/ 40, /*->21071*/
/* 21031*/ OPC_CheckPredicate, 24, // Predicate_atomic_cmp_swap_64_seq_cst
/* 21033*/ OPC_Scope, 17, /*->21052*/ // 2 children in Scope
/* 21035*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21037*/ OPC_EmitMergeInputChains1_0,
/* 21038*/ OPC_EmitInteger, MVT::i32, 7,
/* 21041*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 7:{ *:[i32] })
/* 21052*/ /*Scope*/ 17, /*->21070*/
/* 21053*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21055*/ OPC_EmitMergeInputChains1_0,
/* 21056*/ OPC_EmitInteger, MVT::i32, 7,
/* 21059*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, MVT::i32, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i32] }:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$cmp, GPR:{ *:[i32] }:$new, 7:{ *:[i32] })
/* 21070*/ 0, /*End of Scope*/
/* 21071*/ 0, /*End of Scope*/
/* 21072*/ 0, /*End of Scope*/
/* 21073*/ /*SwitchType*/ 88|128,1/*216*/, MVT::i64,// ->21292
/* 21076*/ OPC_CheckChild1Type, MVT::i64,
/* 21078*/ OPC_RecordChild2, // #2 = $cmp
/* 21079*/ OPC_RecordChild3, // #3 = $new
/* 21080*/ OPC_Scope, 104, /*->21186*/ // 2 children in Scope
/* 21082*/ OPC_CheckPredicate, 10, // Predicate_atomic_cmp_swap_32
/* 21084*/ OPC_Scope, 19, /*->21105*/ // 5 children in Scope
/* 21086*/ OPC_CheckPredicate, 20, // Predicate_atomic_cmp_swap_32_monotonic
/* 21088*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21090*/ OPC_EmitMergeInputChains1_0,
/* 21091*/ OPC_EmitInteger, MVT::i64, 2,
/* 21094*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 2:{ *:[i64] })
/* 21105*/ /*Scope*/ 19, /*->21125*/
/* 21106*/ OPC_CheckPredicate, 21, // Predicate_atomic_cmp_swap_32_acquire
/* 21108*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21110*/ OPC_EmitMergeInputChains1_0,
/* 21111*/ OPC_EmitInteger, MVT::i64, 4,
/* 21114*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 4:{ *:[i64] })
/* 21125*/ /*Scope*/ 19, /*->21145*/
/* 21126*/ OPC_CheckPredicate, 22, // Predicate_atomic_cmp_swap_32_release
/* 21128*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21130*/ OPC_EmitMergeInputChains1_0,
/* 21131*/ OPC_EmitInteger, MVT::i64, 5,
/* 21134*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_release>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 5:{ *:[i64] })
/* 21145*/ /*Scope*/ 19, /*->21165*/
/* 21146*/ OPC_CheckPredicate, 23, // Predicate_atomic_cmp_swap_32_acq_rel
/* 21148*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21150*/ OPC_EmitMergeInputChains1_0,
/* 21151*/ OPC_EmitInteger, MVT::i64, 6,
/* 21154*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 6:{ *:[i64] })
/* 21165*/ /*Scope*/ 19, /*->21185*/
/* 21166*/ OPC_CheckPredicate, 24, // Predicate_atomic_cmp_swap_32_seq_cst
/* 21168*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21170*/ OPC_EmitMergeInputChains1_0,
/* 21171*/ OPC_EmitInteger, MVT::i64, 7,
/* 21174*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg32), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_32>><<P:Predicate_atomic_cmp_swap_32_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg32:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 7:{ *:[i64] })
/* 21185*/ 0, /*End of Scope*/
/* 21186*/ /*Scope*/ 104, /*->21291*/
/* 21187*/ OPC_CheckPredicate, 14, // Predicate_atomic_cmp_swap_64
/* 21189*/ OPC_Scope, 19, /*->21210*/ // 5 children in Scope
/* 21191*/ OPC_CheckPredicate, 20, // Predicate_atomic_cmp_swap_64_monotonic
/* 21193*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21195*/ OPC_EmitMergeInputChains1_0,
/* 21196*/ OPC_EmitInteger, MVT::i64, 2,
/* 21199*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_monotonic>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 2:{ *:[i64] })
/* 21210*/ /*Scope*/ 19, /*->21230*/
/* 21211*/ OPC_CheckPredicate, 21, // Predicate_atomic_cmp_swap_64_acquire
/* 21213*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21215*/ OPC_EmitMergeInputChains1_0,
/* 21216*/ OPC_EmitInteger, MVT::i64, 4,
/* 21219*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acquire>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 4:{ *:[i64] })
/* 21230*/ /*Scope*/ 19, /*->21250*/
/* 21231*/ OPC_CheckPredicate, 22, // Predicate_atomic_cmp_swap_64_release
/* 21233*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21235*/ OPC_EmitMergeInputChains1_0,
/* 21236*/ OPC_EmitInteger, MVT::i64, 5,
/* 21239*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_release>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 5:{ *:[i64] })
/* 21250*/ /*Scope*/ 19, /*->21270*/
/* 21251*/ OPC_CheckPredicate, 23, // Predicate_atomic_cmp_swap_64_acq_rel
/* 21253*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21255*/ OPC_EmitMergeInputChains1_0,
/* 21256*/ OPC_EmitInteger, MVT::i64, 6,
/* 21259*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_acq_rel>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 6:{ *:[i64] })
/* 21270*/ /*Scope*/ 19, /*->21290*/
/* 21271*/ OPC_CheckPredicate, 24, // Predicate_atomic_cmp_swap_64_seq_cst
/* 21273*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21275*/ OPC_EmitMergeInputChains1_0,
/* 21276*/ OPC_EmitInteger, MVT::i64, 7,
/* 21279*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::PseudoCmpXchg64), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, MVT::i64, 4/*#Ops*/, 1, 2, 3, 4,
// Src: (atomic_cmp_swap:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new)<<P:Predicate_atomic_cmp_swap_64>><<P:Predicate_atomic_cmp_swap_64_seq_cst>> - Complexity = 4
// Dst: (PseudoCmpXchg64:{ *:[i64] }:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$cmp, GPR:{ *:[i64] }:$new, 7:{ *:[i64] })
/* 21290*/ 0, /*End of Scope*/
/* 21291*/ 0, /*End of Scope*/
/* 21292*/ 0, // EndSwitchType
/* 21293*/ /*SwitchOpcode*/ 37|128,6/*805*/, TARGET_VAL(ISD::ATOMIC_LOAD_SUB),// ->22102
/* 21297*/ OPC_RecordMemRef,
/* 21298*/ OPC_RecordNode, // #0 = 'atomic_load_sub' chained node
/* 21299*/ OPC_RecordChild1, // #1 = $addr
/* 21300*/ OPC_SwitchType /*2 cases */, 15|128,4/*527*/, MVT::i32,// ->21831
/* 21304*/ OPC_CheckChild1Type, MVT::i32,
/* 21306*/ OPC_RecordChild2, // #2 = $incr
/* 21307*/ OPC_Scope, 3|128,2/*259*/, /*->21569*/ // 2 children in Scope
/* 21310*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_sub_32
/* 21312*/ OPC_Scope, 50, /*->21364*/ // 5 children in Scope
/* 21314*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_sub_32_monotonic
/* 21316*/ OPC_Scope, 22, /*->21340*/ // 2 children in Scope
/* 21318*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21320*/ OPC_EmitMergeInputChains1_0,
/* 21321*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21324*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21332*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21340*/ /*Scope*/ 22, /*->21363*/
/* 21341*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 21343*/ OPC_EmitMergeInputChains1_0,
/* 21344*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21347*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21355*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21363*/ 0, /*End of Scope*/
/* 21364*/ /*Scope*/ 50, /*->21415*/
/* 21365*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_sub_32_acquire
/* 21367*/ OPC_Scope, 22, /*->21391*/ // 2 children in Scope
/* 21369*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21371*/ OPC_EmitMergeInputChains1_0,
/* 21372*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21375*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21383*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21391*/ /*Scope*/ 22, /*->21414*/
/* 21392*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 21394*/ OPC_EmitMergeInputChains1_0,
/* 21395*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21398*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21406*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21414*/ 0, /*End of Scope*/
/* 21415*/ /*Scope*/ 50, /*->21466*/
/* 21416*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_sub_32_release
/* 21418*/ OPC_Scope, 22, /*->21442*/ // 2 children in Scope
/* 21420*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21422*/ OPC_EmitMergeInputChains1_0,
/* 21423*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21426*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21434*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21442*/ /*Scope*/ 22, /*->21465*/
/* 21443*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 21445*/ OPC_EmitMergeInputChains1_0,
/* 21446*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21449*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21457*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21465*/ 0, /*End of Scope*/
/* 21466*/ /*Scope*/ 50, /*->21517*/
/* 21467*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_sub_32_acq_rel
/* 21469*/ OPC_Scope, 22, /*->21493*/ // 2 children in Scope
/* 21471*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21473*/ OPC_EmitMergeInputChains1_0,
/* 21474*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21477*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21485*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21493*/ /*Scope*/ 22, /*->21516*/
/* 21494*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 21496*/ OPC_EmitMergeInputChains1_0,
/* 21497*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21500*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21508*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21516*/ 0, /*End of Scope*/
/* 21517*/ /*Scope*/ 50, /*->21568*/
/* 21518*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_sub_32_seq_cst
/* 21520*/ OPC_Scope, 22, /*->21544*/ // 2 children in Scope
/* 21522*/ OPC_CheckPatternPredicate, 17, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21524*/ OPC_EmitMergeInputChains1_0,
/* 21525*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21528*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21536*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21544*/ /*Scope*/ 22, /*->21567*/
/* 21545*/ OPC_CheckPatternPredicate, 18, // (Subtarget->hasStdExtA())
/* 21547*/ OPC_EmitMergeInputChains1_0,
/* 21548*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21551*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21559*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21567*/ 0, /*End of Scope*/
/* 21568*/ 0, /*End of Scope*/
/* 21569*/ /*Scope*/ 3|128,2/*259*/, /*->21830*/
/* 21571*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_sub_64
/* 21573*/ OPC_Scope, 50, /*->21625*/ // 5 children in Scope
/* 21575*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_sub_64_monotonic
/* 21577*/ OPC_Scope, 22, /*->21601*/ // 2 children in Scope
/* 21579*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21581*/ OPC_EmitMergeInputChains1_0,
/* 21582*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21585*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21593*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21601*/ /*Scope*/ 22, /*->21624*/
/* 21602*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21604*/ OPC_EmitMergeInputChains1_0,
/* 21605*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21608*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21616*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21624*/ 0, /*End of Scope*/
/* 21625*/ /*Scope*/ 50, /*->21676*/
/* 21626*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_sub_64_acquire
/* 21628*/ OPC_Scope, 22, /*->21652*/ // 2 children in Scope
/* 21630*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21632*/ OPC_EmitMergeInputChains1_0,
/* 21633*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21636*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21644*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21652*/ /*Scope*/ 22, /*->21675*/
/* 21653*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21655*/ OPC_EmitMergeInputChains1_0,
/* 21656*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21659*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21667*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21675*/ 0, /*End of Scope*/
/* 21676*/ /*Scope*/ 50, /*->21727*/
/* 21677*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_sub_64_release
/* 21679*/ OPC_Scope, 22, /*->21703*/ // 2 children in Scope
/* 21681*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21683*/ OPC_EmitMergeInputChains1_0,
/* 21684*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21687*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21695*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21703*/ /*Scope*/ 22, /*->21726*/
/* 21704*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21706*/ OPC_EmitMergeInputChains1_0,
/* 21707*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21710*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21718*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21726*/ 0, /*End of Scope*/
/* 21727*/ /*Scope*/ 50, /*->21778*/
/* 21728*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_sub_64_acq_rel
/* 21730*/ OPC_Scope, 22, /*->21754*/ // 2 children in Scope
/* 21732*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21734*/ OPC_EmitMergeInputChains1_0,
/* 21735*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21738*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21746*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21754*/ /*Scope*/ 22, /*->21777*/
/* 21755*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21757*/ OPC_EmitMergeInputChains1_0,
/* 21758*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21761*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21769*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21777*/ 0, /*End of Scope*/
/* 21778*/ /*Scope*/ 50, /*->21829*/
/* 21779*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_sub_64_seq_cst
/* 21781*/ OPC_Scope, 22, /*->21805*/ // 2 children in Scope
/* 21783*/ OPC_CheckPatternPredicate, 19, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 21785*/ OPC_EmitMergeInputChains1_0,
/* 21786*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21789*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21797*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21805*/ /*Scope*/ 22, /*->21828*/
/* 21806*/ OPC_CheckPatternPredicate, 20, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit())
/* 21808*/ OPC_EmitMergeInputChains1_0,
/* 21809*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 21812*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 3, 2, // Results = #4
/* 21820*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i32, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i32] } GPR:{ *:[i32] }:$addr, GPR:{ *:[i32] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i32] } GPR:{ *:[i32] }:$addr, (SUB:{ *:[i32] } X0:{ *:[i32] }, GPR:{ *:[i32] }:$incr))
/* 21828*/ 0, /*End of Scope*/
/* 21829*/ 0, /*End of Scope*/
/* 21830*/ 0, /*End of Scope*/
/* 21831*/ /*SwitchType*/ 11|128,2/*267*/, MVT::i64,// ->22101
/* 21834*/ OPC_CheckChild1Type, MVT::i64,
/* 21836*/ OPC_RecordChild2, // #2 = $incr
/* 21837*/ OPC_Scope, 1|128,1/*129*/, /*->21969*/ // 2 children in Scope
/* 21840*/ OPC_CheckPredicate, 10, // Predicate_atomic_load_sub_32
/* 21842*/ OPC_Scope, 24, /*->21868*/ // 5 children in Scope
/* 21844*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_sub_32_monotonic
/* 21846*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21848*/ OPC_EmitMergeInputChains1_0,
/* 21849*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21852*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21860*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_monotonic>> - Complexity = 4
// Dst: (AMOADD_W:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21868*/ /*Scope*/ 24, /*->21893*/
/* 21869*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_sub_32_acquire
/* 21871*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21873*/ OPC_EmitMergeInputChains1_0,
/* 21874*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21877*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21885*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acquire>> - Complexity = 4
// Dst: (AMOADD_W_AQ:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21893*/ /*Scope*/ 24, /*->21918*/
/* 21894*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_sub_32_release
/* 21896*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21898*/ OPC_EmitMergeInputChains1_0,
/* 21899*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21902*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21910*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_release>> - Complexity = 4
// Dst: (AMOADD_W_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21918*/ /*Scope*/ 24, /*->21943*/
/* 21919*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_sub_32_acq_rel
/* 21921*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21923*/ OPC_EmitMergeInputChains1_0,
/* 21924*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21927*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21935*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_acq_rel>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21943*/ /*Scope*/ 24, /*->21968*/
/* 21944*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_sub_32_seq_cst
/* 21946*/ OPC_CheckPatternPredicate, 21, // (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21948*/ OPC_EmitMergeInputChains1_0,
/* 21949*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21952*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21960*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_W_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_32>><<P:Predicate_atomic_load_sub_32_seq_cst>> - Complexity = 4
// Dst: (AMOADD_W_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21968*/ 0, /*End of Scope*/
/* 21969*/ /*Scope*/ 1|128,1/*129*/, /*->22100*/
/* 21971*/ OPC_CheckPredicate, 14, // Predicate_atomic_load_sub_64
/* 21973*/ OPC_Scope, 24, /*->21999*/ // 5 children in Scope
/* 21975*/ OPC_CheckPredicate, 20, // Predicate_atomic_load_sub_64_monotonic
/* 21977*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 21979*/ OPC_EmitMergeInputChains1_0,
/* 21980*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 21983*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 21991*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_monotonic>> - Complexity = 4
// Dst: (AMOADD_D:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 21999*/ /*Scope*/ 24, /*->22024*/
/* 22000*/ OPC_CheckPredicate, 21, // Predicate_atomic_load_sub_64_acquire
/* 22002*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22004*/ OPC_EmitMergeInputChains1_0,
/* 22005*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22008*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 22016*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acquire>> - Complexity = 4
// Dst: (AMOADD_D_AQ:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 22024*/ /*Scope*/ 24, /*->22049*/
/* 22025*/ OPC_CheckPredicate, 22, // Predicate_atomic_load_sub_64_release
/* 22027*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22029*/ OPC_EmitMergeInputChains1_0,
/* 22030*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22033*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 22041*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_release>> - Complexity = 4
// Dst: (AMOADD_D_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 22049*/ /*Scope*/ 24, /*->22074*/
/* 22050*/ OPC_CheckPredicate, 23, // Predicate_atomic_load_sub_64_acq_rel
/* 22052*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22054*/ OPC_EmitMergeInputChains1_0,
/* 22055*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22058*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 22066*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_acq_rel>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 22074*/ /*Scope*/ 24, /*->22099*/
/* 22075*/ OPC_CheckPredicate, 24, // Predicate_atomic_load_sub_64_seq_cst
/* 22077*/ OPC_CheckPatternPredicate, 22, // (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22079*/ OPC_EmitMergeInputChains1_0,
/* 22080*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22083*/ OPC_EmitNode1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 3, 2, // Results = #4
/* 22091*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::AMOADD_D_AQ_RL), 0|OPFL_Chain|OPFL_MemRefs,
MVT::i64, 2/*#Ops*/, 1, 4,
// Src: (atomic_load_sub:{ *:[i64] } GPR:{ *:[i64] }:$addr, GPR:{ *:[i64] }:$incr)<<P:Predicate_atomic_load_sub_64>><<P:Predicate_atomic_load_sub_64_seq_cst>> - Complexity = 4
// Dst: (AMOADD_D_AQ_RL:{ *:[i64] } GPR:{ *:[i64] }:$addr, (SUB:{ *:[i64] } X0:{ *:[i64] }, GPR:{ *:[i64] }:$incr))
/* 22099*/ 0, /*End of Scope*/
/* 22100*/ 0, /*End of Scope*/
/* 22101*/ 0, // EndSwitchType
/* 22102*/ /*SwitchOpcode*/ 14, TARGET_VAL(ISD::BR),// ->22119
/* 22105*/ OPC_RecordNode, // #0 = 'br' chained node
/* 22106*/ OPC_RecordChild1, // #1 = $imm20
/* 22107*/ OPC_MoveChild1,
/* 22108*/ OPC_CheckOpcode, TARGET_VAL(ISD::BasicBlock),
/* 22111*/ OPC_MoveParent,
/* 22112*/ OPC_EmitMergeInputChains1_0,
/* 22113*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoBR), 0|OPFL_Chain,
1/*#Ops*/, 1,
// Src: (br (bb:{ *:[Other] }):$imm20) - Complexity = 3
// Dst: (PseudoBR (bb:{ *:[Other] }):$imm20)
/* 22119*/ /*SwitchOpcode*/ 8, TARGET_VAL(RISCVISD::RET_FLAG),// ->22130
/* 22122*/ OPC_RecordNode, // #0 = 'riscv_ret_flag' chained node
/* 22123*/ OPC_CaptureGlueInput,
/* 22124*/ OPC_EmitMergeInputChains1_0,
/* 22125*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::PseudoRET), 0|OPFL_Chain|OPFL_GlueInput|OPFL_Variadic0,
0/*#Ops*/,
// Src: (riscv_ret_flag) - Complexity = 3
// Dst: (PseudoRET)
/* 22130*/ /*SwitchOpcode*/ 7, TARGET_VAL(ISD::TRAP),// ->22140
/* 22133*/ OPC_RecordNode, // #0 = 'trap' chained node
/* 22134*/ OPC_EmitMergeInputChains1_0,
/* 22135*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::UNIMP), 0|OPFL_Chain,
0/*#Ops*/,
// Src: (trap) - Complexity = 3
// Dst: (UNIMP)
/* 22140*/ /*SwitchOpcode*/ 7, TARGET_VAL(ISD::DEBUGTRAP),// ->22150
/* 22143*/ OPC_RecordNode, // #0 = 'debugtrap' chained node
/* 22144*/ OPC_EmitMergeInputChains1_0,
/* 22145*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::EBREAK), 0|OPFL_Chain,
0/*#Ops*/,
// Src: (debugtrap) - Complexity = 3
// Dst: (EBREAK)
/* 22150*/ /*SwitchOpcode*/ 40, TARGET_VAL(ISD::SUB),// ->22193
/* 22153*/ OPC_RecordChild0, // #0 = $rs1
/* 22154*/ OPC_RecordChild1, // #1 = $rs2
/* 22155*/ OPC_SwitchType /*2 cases */, 22, MVT::i32,// ->22180
/* 22158*/ OPC_Scope, 10, /*->22170*/ // 2 children in Scope
/* 22160*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 22162*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sub:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SUB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22170*/ /*Scope*/ 8, /*->22179*/
/* 22171*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SUB), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sub:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SUB:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22179*/ 0, /*End of Scope*/
/* 22180*/ /*SwitchType*/ 10, MVT::i64,// ->22192
/* 22182*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 22184*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SUB), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sub:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SUB:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22192*/ 0, // EndSwitchType
/* 22193*/ /*SwitchOpcode*/ 53, TARGET_VAL(RISCVISD::URET_FLAG),// ->22249
/* 22196*/ OPC_RecordNode, // #0 = 'riscv_uret_flag' chained node
/* 22197*/ OPC_CaptureGlueInput,
/* 22198*/ OPC_Scope, 16, /*->22216*/ // 3 children in Scope
/* 22200*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 22202*/ OPC_EmitMergeInputChains1_0,
/* 22203*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22206*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22209*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::URET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_uret_flag) - Complexity = 3
// Dst: (URET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22216*/ /*Scope*/ 16, /*->22233*/
/* 22217*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 22219*/ OPC_EmitMergeInputChains1_0,
/* 22220*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22223*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22226*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::URET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_uret_flag) - Complexity = 3
// Dst: (URET X0:{ *:[i64] }, X0:{ *:[i64] })
/* 22233*/ /*Scope*/ 14, /*->22248*/
/* 22234*/ OPC_EmitMergeInputChains1_0,
/* 22235*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22238*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22241*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::URET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_uret_flag) - Complexity = 3
// Dst: (URET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22248*/ 0, /*End of Scope*/
/* 22249*/ /*SwitchOpcode*/ 53, TARGET_VAL(RISCVISD::SRET_FLAG),// ->22305
/* 22252*/ OPC_RecordNode, // #0 = 'riscv_sret_flag' chained node
/* 22253*/ OPC_CaptureGlueInput,
/* 22254*/ OPC_Scope, 16, /*->22272*/ // 3 children in Scope
/* 22256*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 22258*/ OPC_EmitMergeInputChains1_0,
/* 22259*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22262*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22265*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_sret_flag) - Complexity = 3
// Dst: (SRET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22272*/ /*Scope*/ 16, /*->22289*/
/* 22273*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 22275*/ OPC_EmitMergeInputChains1_0,
/* 22276*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22279*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22282*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_sret_flag) - Complexity = 3
// Dst: (SRET X0:{ *:[i64] }, X0:{ *:[i64] })
/* 22289*/ /*Scope*/ 14, /*->22304*/
/* 22290*/ OPC_EmitMergeInputChains1_0,
/* 22291*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22294*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22297*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::SRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_sret_flag) - Complexity = 3
// Dst: (SRET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22304*/ 0, /*End of Scope*/
/* 22305*/ /*SwitchOpcode*/ 53, TARGET_VAL(RISCVISD::MRET_FLAG),// ->22361
/* 22308*/ OPC_RecordNode, // #0 = 'riscv_mret_flag' chained node
/* 22309*/ OPC_CaptureGlueInput,
/* 22310*/ OPC_Scope, 16, /*->22328*/ // 3 children in Scope
/* 22312*/ OPC_CheckPatternPredicate, 6, // (MF->getSubtarget().checkFeatures("-64bit"))
/* 22314*/ OPC_EmitMergeInputChains1_0,
/* 22315*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22318*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22321*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::MRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_mret_flag) - Complexity = 3
// Dst: (MRET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22328*/ /*Scope*/ 16, /*->22345*/
/* 22329*/ OPC_CheckPatternPredicate, 7, // (MF->getSubtarget().checkFeatures("+64bit"))
/* 22331*/ OPC_EmitMergeInputChains1_0,
/* 22332*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22335*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22338*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::MRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_mret_flag) - Complexity = 3
// Dst: (MRET X0:{ *:[i64] }, X0:{ *:[i64] })
/* 22345*/ /*Scope*/ 14, /*->22360*/
/* 22346*/ OPC_EmitMergeInputChains1_0,
/* 22347*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22350*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22353*/ OPC_MorphNodeTo0, TARGET_VAL(RISCV::MRET), 0|OPFL_Chain|OPFL_GlueInput,
2/*#Ops*/, 1, 2,
// Src: (riscv_mret_flag) - Complexity = 3
// Dst: (MRET X0:{ *:[i32] }, X0:{ *:[i32] })
/* 22360*/ 0, /*End of Scope*/
/* 22361*/ /*SwitchOpcode*/ 46, TARGET_VAL(RISCVISD::SLLW),// ->22410
/* 22364*/ OPC_RecordChild0, // #0 = $rs1
/* 22365*/ OPC_RecordChild1, // #1 = $rs2
/* 22366*/ OPC_SwitchType /*2 cases */, 26, MVT::i32,// ->22395
/* 22369*/ OPC_CheckChild1Type, MVT::i32,
/* 22371*/ OPC_Scope, 10, /*->22383*/ // 2 children in Scope
/* 22373*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22375*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_sllw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SLLW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22383*/ /*Scope*/ 10, /*->22394*/
/* 22384*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 22386*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_sllw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SLLW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22394*/ 0, /*End of Scope*/
/* 22395*/ /*SwitchType*/ 12, MVT::i64,// ->22409
/* 22397*/ OPC_CheckChild1Type, MVT::i64,
/* 22399*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22401*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SLLW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_sllw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SLLW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22409*/ 0, // EndSwitchType
/* 22410*/ /*SwitchOpcode*/ 46, TARGET_VAL(RISCVISD::SRLW),// ->22459
/* 22413*/ OPC_RecordChild0, // #0 = $rs1
/* 22414*/ OPC_RecordChild1, // #1 = $rs2
/* 22415*/ OPC_SwitchType /*2 cases */, 26, MVT::i32,// ->22444
/* 22418*/ OPC_CheckChild1Type, MVT::i32,
/* 22420*/ OPC_Scope, 10, /*->22432*/ // 2 children in Scope
/* 22422*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22424*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_srlw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRLW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22432*/ /*Scope*/ 10, /*->22443*/
/* 22433*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 22435*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_srlw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRLW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22443*/ 0, /*End of Scope*/
/* 22444*/ /*SwitchType*/ 12, MVT::i64,// ->22458
/* 22446*/ OPC_CheckChild1Type, MVT::i64,
/* 22448*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22450*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRLW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_srlw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SRLW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22458*/ 0, // EndSwitchType
/* 22459*/ /*SwitchOpcode*/ 46, TARGET_VAL(RISCVISD::SRAW),// ->22508
/* 22462*/ OPC_RecordChild0, // #0 = $rs1
/* 22463*/ OPC_RecordChild1, // #1 = $rs2
/* 22464*/ OPC_SwitchType /*2 cases */, 26, MVT::i32,// ->22493
/* 22467*/ OPC_CheckChild1Type, MVT::i32,
/* 22469*/ OPC_Scope, 10, /*->22481*/ // 2 children in Scope
/* 22471*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22473*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_sraw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRAW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22481*/ /*Scope*/ 10, /*->22492*/
/* 22482*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 22484*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_sraw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (SRAW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22492*/ 0, /*End of Scope*/
/* 22493*/ /*SwitchType*/ 12, MVT::i64,// ->22507
/* 22495*/ OPC_CheckChild1Type, MVT::i64,
/* 22497*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22499*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::SRAW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_sraw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (SRAW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22507*/ 0, // EndSwitchType
/* 22508*/ /*SwitchOpcode*/ 65, TARGET_VAL(ISD::READCYCLECOUNTER),// ->22576
/* 22511*/ OPC_RecordNode, // #0 = 'readcyclecounter' chained node
/* 22512*/ OPC_SwitchType /*2 cases */, 40, MVT::i32,// ->22555
/* 22515*/ OPC_Scope, 18, /*->22535*/ // 2 children in Scope
/* 22517*/ OPC_CheckPatternPredicate, 3, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22519*/ OPC_EmitMergeInputChains1_0,
/* 22520*/ OPC_EmitInteger, MVT::i32, 0|128,24/*3072*/,
/* 22524*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22527*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::CSRRS), 0|OPFL_Chain,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (readcyclecounter:{ *:[i32] }) - Complexity = 3
// Dst: (CSRRS:{ *:[i32] } 3072:{ *:[i32] }, X0:{ *:[i32] })
/* 22535*/ /*Scope*/ 18, /*->22554*/
/* 22536*/ OPC_CheckPatternPredicate, 4, // (Subtarget->is64Bit())
/* 22538*/ OPC_EmitMergeInputChains1_0,
/* 22539*/ OPC_EmitInteger, MVT::i32, 0|128,24/*3072*/,
/* 22543*/ OPC_EmitRegister, MVT::i32, RISCV::X0,
/* 22546*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::CSRRS), 0|OPFL_Chain,
MVT::i32, 2/*#Ops*/, 1, 2,
// Src: (readcyclecounter:{ *:[i32] }) - Complexity = 3
// Dst: (CSRRS:{ *:[i32] } 3072:{ *:[i32] }, X0:{ *:[i32] })
/* 22554*/ 0, /*End of Scope*/
/* 22555*/ /*SwitchType*/ 18, MVT::i64,// ->22575
/* 22557*/ OPC_CheckPatternPredicate, 5, // (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22559*/ OPC_EmitMergeInputChains1_0,
/* 22560*/ OPC_EmitInteger, MVT::i64, 0|128,24/*3072*/,
/* 22564*/ OPC_EmitRegister, MVT::i64, RISCV::X0,
/* 22567*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::CSRRS), 0|OPFL_Chain,
MVT::i64, 2/*#Ops*/, 1, 2,
// Src: (readcyclecounter:{ *:[i64] }) - Complexity = 3
// Dst: (CSRRS:{ *:[i64] } 3072:{ *:[i64] }, X0:{ *:[i64] })
/* 22575*/ 0, // EndSwitchType
/* 22576*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::MUL),// ->22621
/* 22579*/ OPC_RecordChild0, // #0 = $rs1
/* 22580*/ OPC_RecordChild1, // #1 = $rs2
/* 22581*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22608
/* 22584*/ OPC_Scope, 10, /*->22596*/ // 2 children in Scope
/* 22586*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22588*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MUL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mul:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MUL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22596*/ /*Scope*/ 10, /*->22607*/
/* 22597*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22599*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MUL), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mul:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MUL:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22607*/ 0, /*End of Scope*/
/* 22608*/ /*SwitchType*/ 10, MVT::i64,// ->22620
/* 22610*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22612*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MUL), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (mul:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (MUL:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22620*/ 0, // EndSwitchType
/* 22621*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::MULHS),// ->22666
/* 22624*/ OPC_RecordChild0, // #0 = $rs1
/* 22625*/ OPC_RecordChild1, // #1 = $rs2
/* 22626*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22653
/* 22629*/ OPC_Scope, 10, /*->22641*/ // 2 children in Scope
/* 22631*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22633*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULH), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mulhs:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MULH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22641*/ /*Scope*/ 10, /*->22652*/
/* 22642*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22644*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULH), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mulhs:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MULH:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22652*/ 0, /*End of Scope*/
/* 22653*/ /*SwitchType*/ 10, MVT::i64,// ->22665
/* 22655*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22657*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULH), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (mulhs:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (MULH:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22665*/ 0, // EndSwitchType
/* 22666*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::MULHU),// ->22711
/* 22669*/ OPC_RecordChild0, // #0 = $rs1
/* 22670*/ OPC_RecordChild1, // #1 = $rs2
/* 22671*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22698
/* 22674*/ OPC_Scope, 10, /*->22686*/ // 2 children in Scope
/* 22676*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22678*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULHU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mulhu:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MULHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22686*/ /*Scope*/ 10, /*->22697*/
/* 22687*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22689*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULHU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (mulhu:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (MULHU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22697*/ 0, /*End of Scope*/
/* 22698*/ /*SwitchType*/ 10, MVT::i64,// ->22710
/* 22700*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22702*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::MULHU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (mulhu:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (MULHU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22710*/ 0, // EndSwitchType
/* 22711*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::SDIV),// ->22756
/* 22714*/ OPC_RecordChild0, // #0 = $rs1
/* 22715*/ OPC_RecordChild1, // #1 = $rs2
/* 22716*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22743
/* 22719*/ OPC_Scope, 10, /*->22731*/ // 2 children in Scope
/* 22721*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22723*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIV), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sdiv:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIV:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22731*/ /*Scope*/ 10, /*->22742*/
/* 22732*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22734*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIV), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (sdiv:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIV:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22742*/ 0, /*End of Scope*/
/* 22743*/ /*SwitchType*/ 10, MVT::i64,// ->22755
/* 22745*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22747*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIV), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (sdiv:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (DIV:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22755*/ 0, // EndSwitchType
/* 22756*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::UDIV),// ->22801
/* 22759*/ OPC_RecordChild0, // #0 = $rs1
/* 22760*/ OPC_RecordChild1, // #1 = $rs2
/* 22761*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22788
/* 22764*/ OPC_Scope, 10, /*->22776*/ // 2 children in Scope
/* 22766*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22768*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (udiv:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22776*/ /*Scope*/ 10, /*->22787*/
/* 22777*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22779*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (udiv:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22787*/ 0, /*End of Scope*/
/* 22788*/ /*SwitchType*/ 10, MVT::i64,// ->22800
/* 22790*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22792*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (udiv:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (DIVU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22800*/ 0, // EndSwitchType
/* 22801*/ /*SwitchOpcode*/ 42, TARGET_VAL(ISD::UREM),// ->22846
/* 22804*/ OPC_RecordChild0, // #0 = $rs1
/* 22805*/ OPC_RecordChild1, // #1 = $rs2
/* 22806*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22833
/* 22809*/ OPC_Scope, 10, /*->22821*/ // 2 children in Scope
/* 22811*/ OPC_CheckPatternPredicate, 25, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22813*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (urem:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22821*/ /*Scope*/ 10, /*->22832*/
/* 22822*/ OPC_CheckPatternPredicate, 26, // (Subtarget->hasStdExtM())
/* 22824*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (urem:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REMU:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22832*/ 0, /*End of Scope*/
/* 22833*/ /*SwitchType*/ 10, MVT::i64,// ->22845
/* 22835*/ OPC_CheckPatternPredicate, 27, // (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22837*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMU), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (urem:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (REMU:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22845*/ 0, // EndSwitchType
/* 22846*/ /*SwitchOpcode*/ 42, TARGET_VAL(RISCVISD::DIVW),// ->22891
/* 22849*/ OPC_RecordChild0, // #0 = $rs1
/* 22850*/ OPC_RecordChild1, // #1 = $rs2
/* 22851*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22878
/* 22854*/ OPC_Scope, 10, /*->22866*/ // 2 children in Scope
/* 22856*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22858*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_divw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22866*/ /*Scope*/ 10, /*->22877*/
/* 22867*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 22869*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_divw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22877*/ 0, /*End of Scope*/
/* 22878*/ /*SwitchType*/ 10, MVT::i64,// ->22890
/* 22880*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22882*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_divw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (DIVW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22890*/ 0, // EndSwitchType
/* 22891*/ /*SwitchOpcode*/ 42, TARGET_VAL(RISCVISD::DIVUW),// ->22936
/* 22894*/ OPC_RecordChild0, // #0 = $rs1
/* 22895*/ OPC_RecordChild1, // #1 = $rs2
/* 22896*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22923
/* 22899*/ OPC_Scope, 10, /*->22911*/ // 2 children in Scope
/* 22901*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22903*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVUW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_divuw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVUW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22911*/ /*Scope*/ 10, /*->22922*/
/* 22912*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 22914*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVUW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_divuw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (DIVUW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22922*/ 0, /*End of Scope*/
/* 22923*/ /*SwitchType*/ 10, MVT::i64,// ->22935
/* 22925*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22927*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::DIVUW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_divuw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (DIVUW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22935*/ 0, // EndSwitchType
/* 22936*/ /*SwitchOpcode*/ 42, TARGET_VAL(RISCVISD::REMUW),// ->22981
/* 22939*/ OPC_RecordChild0, // #0 = $rs1
/* 22940*/ OPC_RecordChild1, // #1 = $rs2
/* 22941*/ OPC_SwitchType /*2 cases */, 24, MVT::i32,// ->22968
/* 22944*/ OPC_Scope, 10, /*->22956*/ // 2 children in Scope
/* 22946*/ OPC_CheckPatternPredicate, 0, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22948*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMUW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_remuw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REMUW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22956*/ /*Scope*/ 10, /*->22967*/
/* 22957*/ OPC_CheckPatternPredicate, 1, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit())
/* 22959*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMUW), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (riscv_remuw:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2) - Complexity = 3
// Dst: (REMUW:{ *:[i32] } GPR:{ *:[i32] }:$rs1, GPR:{ *:[i32] }:$rs2)
/* 22967*/ 0, /*End of Scope*/
/* 22968*/ /*SwitchType*/ 10, MVT::i64,// ->22980
/* 22970*/ OPC_CheckPatternPredicate, 2, // (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 22972*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::REMUW), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (riscv_remuw:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2) - Complexity = 3
// Dst: (REMUW:{ *:[i64] } GPR:{ *:[i64] }:$rs1, GPR:{ *:[i64] }:$rs2)
/* 22980*/ 0, // EndSwitchType
/* 22981*/ /*SwitchOpcode*/ 35|128,1/*163*/, TARGET_VAL(ISD::BITCAST),// ->23148
/* 22985*/ OPC_RecordChild0, // #0 = $rs1
/* 22986*/ OPC_Scope, 39, /*->23027*/ // 4 children in Scope
/* 22988*/ OPC_CheckChild0Type, MVT::f32,
/* 22990*/ OPC_SwitchType /*2 cases */, 22, MVT::i32,// ->23015
/* 22993*/ OPC_Scope, 9, /*->23004*/ // 2 children in Scope
/* 22995*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 22997*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FMV_X_W:{ *:[i32] } FPR32:{ *:[f32] }:$rs1)
/* 23004*/ /*Scope*/ 9, /*->23014*/
/* 23005*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 23007*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FMV_X_W:{ *:[i32] } FPR32:{ *:[f32] }:$rs1)
/* 23014*/ 0, /*End of Scope*/
/* 23015*/ /*SwitchType*/ 9, MVT::i64,// ->23026
/* 23017*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23019*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i64, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FMV_X_W:{ *:[i64] } FPR32:{ *:[f32] }:$rs1)
/* 23026*/ 0, // EndSwitchType
/* 23027*/ /*Scope*/ 39, /*->23067*/
/* 23028*/ OPC_CheckChild0Type, MVT::f64,
/* 23030*/ OPC_SwitchType /*2 cases */, 22, MVT::i32,// ->23055
/* 23033*/ OPC_Scope, 9, /*->23044*/ // 2 children in Scope
/* 23035*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23037*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_D), 0,
MVT::i32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FMV_X_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1)
/* 23044*/ /*Scope*/ 9, /*->23054*/
/* 23045*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23047*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_D), 0,
MVT::i32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FMV_X_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1)
/* 23054*/ 0, /*End of Scope*/
/* 23055*/ /*SwitchType*/ 9, MVT::i64,// ->23066
/* 23057*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23059*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_D), 0,
MVT::i64, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[i64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FMV_X_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1)
/* 23066*/ 0, // EndSwitchType
/* 23067*/ /*Scope*/ 52, /*->23120*/
/* 23068*/ OPC_CheckChild0Type, MVT::i32,
/* 23070*/ OPC_SwitchType /*2 cases */, 22, MVT::f32,// ->23095
/* 23073*/ OPC_Scope, 9, /*->23084*/ // 2 children in Scope
/* 23075*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23077*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_W_X), 0,
MVT::f32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FMV_W_X:{ *:[f32] } GPR:{ *:[i32] }:$rs1)
/* 23084*/ /*Scope*/ 9, /*->23094*/
/* 23085*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 23087*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_W_X), 0,
MVT::f32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FMV_W_X:{ *:[f32] } GPR:{ *:[i32] }:$rs1)
/* 23094*/ 0, /*End of Scope*/
/* 23095*/ /*SwitchType*/ 22, MVT::f64,// ->23119
/* 23097*/ OPC_Scope, 9, /*->23108*/ // 2 children in Scope
/* 23099*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23101*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_D_X), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FMV_D_X:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 23108*/ /*Scope*/ 9, /*->23118*/
/* 23109*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23111*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_D_X), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FMV_D_X:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 23118*/ 0, /*End of Scope*/
/* 23119*/ 0, // EndSwitchType
/* 23120*/ /*Scope*/ 26, /*->23147*/
/* 23121*/ OPC_CheckChild0Type, MVT::i64,
/* 23123*/ OPC_SwitchType /*2 cases */, 9, MVT::f32,// ->23135
/* 23126*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23128*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_W_X), 0,
MVT::f32, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f32] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FMV_W_X:{ *:[f32] } GPR:{ *:[i64] }:$rs1)
/* 23135*/ /*SwitchType*/ 9, MVT::f64,// ->23146
/* 23137*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23139*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_D_X), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (bitconvert:{ *:[f64] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FMV_D_X:{ *:[f64] } GPR:{ *:[i64] }:$rs1)
/* 23146*/ 0, // EndSwitchType
/* 23147*/ 0, /*End of Scope*/
/* 23148*/ /*SwitchOpcode*/ 97|128,1/*225*/, TARGET_VAL(ISD::FP_TO_SINT),// ->23377
/* 23152*/ OPC_RecordChild0, // #0 = $rs1
/* 23153*/ OPC_Scope, 124, /*->23279*/ // 2 children in Scope
/* 23155*/ OPC_CheckChild0Type, MVT::f32,
/* 23157*/ OPC_SwitchType /*2 cases */, 86, MVT::i32,// ->23246
/* 23160*/ OPC_Scope, 13, /*->23175*/ // 6 children in Scope
/* 23162*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23164*/ OPC_EmitInteger, MVT::i32, 1,
/* 23167*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23175*/ /*Scope*/ 13, /*->23189*/
/* 23176*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23178*/ OPC_EmitInteger, MVT::i32, 1,
/* 23181*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23189*/ /*Scope*/ 13, /*->23203*/
/* 23190*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23192*/ OPC_EmitInteger, MVT::i32, 1,
/* 23195*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23203*/ /*Scope*/ 13, /*->23217*/
/* 23204*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23206*/ OPC_EmitInteger, MVT::i32, 1,
/* 23209*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23217*/ /*Scope*/ 13, /*->23231*/
/* 23218*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23220*/ OPC_EmitInteger, MVT::i32, 1,
/* 23223*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23231*/ /*Scope*/ 13, /*->23245*/
/* 23232*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 23234*/ OPC_EmitInteger, MVT::i32, 1,
/* 23237*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23245*/ 0, /*End of Scope*/
/* 23246*/ /*SwitchType*/ 30, MVT::i64,// ->23278
/* 23248*/ OPC_Scope, 13, /*->23263*/ // 2 children in Scope
/* 23250*/ OPC_CheckPatternPredicate, 34, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23252*/ OPC_EmitInteger, MVT::i64, 1,
/* 23255*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, 1:{ *:[i64] })
/* 23263*/ /*Scope*/ 13, /*->23277*/
/* 23264*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23266*/ OPC_EmitInteger, MVT::i64, 1,
/* 23269*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, 1:{ *:[i64] })
/* 23277*/ 0, /*End of Scope*/
/* 23278*/ 0, // EndSwitchType
/* 23279*/ /*Scope*/ 96, /*->23376*/
/* 23280*/ OPC_CheckChild0Type, MVT::f64,
/* 23282*/ OPC_SwitchType /*2 cases */, 58, MVT::i32,// ->23343
/* 23285*/ OPC_Scope, 13, /*->23300*/ // 4 children in Scope
/* 23287*/ OPC_CheckPatternPredicate, 35, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23289*/ OPC_EmitInteger, MVT::i32, 1,
/* 23292*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23300*/ /*Scope*/ 13, /*->23314*/
/* 23301*/ OPC_CheckPatternPredicate, 36, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit())
/* 23303*/ OPC_EmitInteger, MVT::i32, 1,
/* 23306*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23314*/ /*Scope*/ 13, /*->23328*/
/* 23315*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23317*/ OPC_EmitInteger, MVT::i32, 1,
/* 23320*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23328*/ /*Scope*/ 13, /*->23342*/
/* 23329*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23331*/ OPC_EmitInteger, MVT::i32, 1,
/* 23334*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23342*/ 0, /*End of Scope*/
/* 23343*/ /*SwitchType*/ 30, MVT::i64,// ->23375
/* 23345*/ OPC_Scope, 13, /*->23360*/ // 2 children in Scope
/* 23347*/ OPC_CheckPatternPredicate, 37, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23349*/ OPC_EmitInteger, MVT::i64, 1,
/* 23352*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_W_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_W_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 23360*/ /*Scope*/ 13, /*->23374*/
/* 23361*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23363*/ OPC_EmitInteger, MVT::i64, 1,
/* 23366*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_L_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_sint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_L_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 23374*/ 0, /*End of Scope*/
/* 23375*/ 0, // EndSwitchType
/* 23376*/ 0, /*End of Scope*/
/* 23377*/ /*SwitchOpcode*/ 97|128,1/*225*/, TARGET_VAL(ISD::FP_TO_UINT),// ->23606
/* 23381*/ OPC_RecordChild0, // #0 = $rs1
/* 23382*/ OPC_Scope, 124, /*->23508*/ // 2 children in Scope
/* 23384*/ OPC_CheckChild0Type, MVT::f32,
/* 23386*/ OPC_SwitchType /*2 cases */, 86, MVT::i32,// ->23475
/* 23389*/ OPC_Scope, 13, /*->23404*/ // 6 children in Scope
/* 23391*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23393*/ OPC_EmitInteger, MVT::i32, 1,
/* 23396*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23404*/ /*Scope*/ 13, /*->23418*/
/* 23405*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23407*/ OPC_EmitInteger, MVT::i32, 1,
/* 23410*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23418*/ /*Scope*/ 13, /*->23432*/
/* 23419*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23421*/ OPC_EmitInteger, MVT::i32, 1,
/* 23424*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23432*/ /*Scope*/ 13, /*->23446*/
/* 23433*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23435*/ OPC_EmitInteger, MVT::i32, 1,
/* 23438*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23446*/ /*Scope*/ 13, /*->23460*/
/* 23447*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23449*/ OPC_EmitInteger, MVT::i32, 1,
/* 23452*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23460*/ /*Scope*/ 13, /*->23474*/
/* 23461*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 23463*/ OPC_EmitInteger, MVT::i32, 1,
/* 23466*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_S), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_S:{ *:[i32] } ?:{ *:[f32] }:$rs1, 1:{ *:[i32] })
/* 23474*/ 0, /*End of Scope*/
/* 23475*/ /*SwitchType*/ 30, MVT::i64,// ->23507
/* 23477*/ OPC_Scope, 13, /*->23492*/ // 2 children in Scope
/* 23479*/ OPC_CheckPatternPredicate, 34, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23481*/ OPC_EmitInteger, MVT::i64, 1,
/* 23484*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, 1:{ *:[i64] })
/* 23492*/ /*Scope*/ 13, /*->23506*/
/* 23493*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23495*/ OPC_EmitInteger, MVT::i64, 1,
/* 23498*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_S), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_S:{ *:[i64] } ?:{ *:[f32] }:$rs1, 1:{ *:[i64] })
/* 23506*/ 0, /*End of Scope*/
/* 23507*/ 0, // EndSwitchType
/* 23508*/ /*Scope*/ 96, /*->23605*/
/* 23509*/ OPC_CheckChild0Type, MVT::f64,
/* 23511*/ OPC_SwitchType /*2 cases */, 58, MVT::i32,// ->23572
/* 23514*/ OPC_Scope, 13, /*->23529*/ // 4 children in Scope
/* 23516*/ OPC_CheckPatternPredicate, 35, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23518*/ OPC_EmitInteger, MVT::i32, 1,
/* 23521*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23529*/ /*Scope*/ 13, /*->23543*/
/* 23530*/ OPC_CheckPatternPredicate, 36, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit())
/* 23532*/ OPC_EmitInteger, MVT::i32, 1,
/* 23535*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23543*/ /*Scope*/ 13, /*->23557*/
/* 23544*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23546*/ OPC_EmitInteger, MVT::i32, 1,
/* 23549*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23557*/ /*Scope*/ 13, /*->23571*/
/* 23558*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23560*/ OPC_EmitInteger, MVT::i32, 1,
/* 23563*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_D), 0,
MVT::i32, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_D:{ *:[i32] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i32] })
/* 23571*/ 0, /*End of Scope*/
/* 23572*/ /*SwitchType*/ 30, MVT::i64,// ->23604
/* 23574*/ OPC_Scope, 13, /*->23589*/ // 2 children in Scope
/* 23576*/ OPC_CheckPatternPredicate, 37, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23578*/ OPC_EmitInteger, MVT::i64, 1,
/* 23581*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_WU_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_WU_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 23589*/ /*Scope*/ 13, /*->23603*/
/* 23590*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23592*/ OPC_EmitInteger, MVT::i64, 1,
/* 23595*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_LU_D), 0,
MVT::i64, 2/*#Ops*/, 0, 1,
// Src: (fp_to_uint:{ *:[i64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_LU_D:{ *:[i64] } FPR64:{ *:[f64] }:$rs1, 1:{ *:[i64] })
/* 23603*/ 0, /*End of Scope*/
/* 23604*/ 0, // EndSwitchType
/* 23605*/ 0, /*End of Scope*/
/* 23606*/ /*SwitchOpcode*/ 10, TARGET_VAL(RISCVISD::FMV_X_ANYEXTW_RV64),// ->23619
/* 23609*/ OPC_RecordChild0, // #0 = $src
/* 23610*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23612*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_X_W), 0,
MVT::i64, 1/*#Ops*/, 0,
// Src: (riscv_fmv_x_anyextw_rv64:{ *:[i64] } FPR32:{ *:[f32] }:$src) - Complexity = 3
// Dst: (FMV_X_W:{ *:[i64] } FPR32:{ *:[f32] }:$src)
/* 23619*/ /*SwitchOpcode*/ 25, TARGET_VAL(RISCVISD::SplitF64),// ->23647
/* 23622*/ OPC_RecordChild0, // #0 = $src
/* 23623*/ OPC_Scope, 10, /*->23635*/ // 2 children in Scope
/* 23625*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23627*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::SplitF64Pseudo), 0,
MVT::i32, MVT::i32, 1/*#Ops*/, 0,
// Src: (RISCVSplitF64:{ *:[i32] }:{ *:[i32] } FPR64:{ *:[f64] }:$src) - Complexity = 3
// Dst: (SplitF64Pseudo:{ *:[i32] }:{ *:[i32] } FPR64:{ *:[f64] }:$src)
/* 23635*/ /*Scope*/ 10, /*->23646*/
/* 23636*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 23638*/ OPC_MorphNodeTo2, TARGET_VAL(RISCV::SplitF64Pseudo), 0,
MVT::i32, MVT::i32, 1/*#Ops*/, 0,
// Src: (RISCVSplitF64:{ *:[i32] }:{ *:[i32] } FPR64:{ *:[f64] }:$src) - Complexity = 3
// Dst: (SplitF64Pseudo:{ *:[i32] }:{ *:[i32] } FPR64:{ *:[f64] }:$src)
/* 23646*/ 0, /*End of Scope*/
/* 23647*/ /*SwitchOpcode*/ 42|128,3/*426*/, TARGET_VAL(ISD::UINT_TO_FP),// ->24077
/* 23651*/ OPC_Scope, 78|128,1/*206*/, /*->23860*/ // 2 children in Scope
/* 23654*/ OPC_MoveChild0,
/* 23655*/ OPC_Scope, 101, /*->23758*/ // 2 children in Scope
/* 23657*/ OPC_CheckAndImm, 127|128,127|128,127|128,127|128,15/*4294967295*/,
/* 23663*/ OPC_RecordChild0, // #0 = $rs1
/* 23664*/ OPC_SwitchType /*2 cases */, 59, MVT::i32,// ->23726
/* 23667*/ OPC_MoveParent,
/* 23668*/ OPC_SwitchType /*2 cases */, 30, MVT::f32,// ->23701
/* 23671*/ OPC_Scope, 13, /*->23686*/ // 2 children in Scope
/* 23673*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23675*/ OPC_EmitInteger, MVT::i32, 7,
/* 23678*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] })) - Complexity = 11
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23686*/ /*Scope*/ 13, /*->23700*/
/* 23687*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 23689*/ OPC_EmitInteger, MVT::i32, 7,
/* 23692*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] })) - Complexity = 11
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23700*/ 0, /*End of Scope*/
/* 23701*/ /*SwitchType*/ 22, MVT::f64,// ->23725
/* 23703*/ OPC_Scope, 9, /*->23714*/ // 2 children in Scope
/* 23705*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23707*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] })) - Complexity = 11
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i32] }:$rs1)
/* 23714*/ /*Scope*/ 9, /*->23724*/
/* 23715*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23717*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (and:{ *:[i32] } GPR:{ *:[i32] }:$rs1, 4294967295:{ *:[i32] })) - Complexity = 11
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i32] }:$rs1)
/* 23724*/ 0, /*End of Scope*/
/* 23725*/ 0, // EndSwitchType
/* 23726*/ /*SwitchType*/ 29, MVT::i64,// ->23757
/* 23728*/ OPC_MoveParent,
/* 23729*/ OPC_SwitchType /*2 cases */, 13, MVT::f32,// ->23745
/* 23732*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23734*/ OPC_EmitInteger, MVT::i64, 7,
/* 23737*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] })) - Complexity = 11
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 23745*/ /*SwitchType*/ 9, MVT::f64,// ->23756
/* 23747*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23749*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (and:{ *:[i64] } GPR:{ *:[i64] }:$rs1, 4294967295:{ *:[i64] })) - Complexity = 11
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i64] }:$rs1)
/* 23756*/ 0, // EndSwitchType
/* 23757*/ 0, // EndSwitchType
/* 23758*/ /*Scope*/ 100, /*->23859*/
/* 23759*/ OPC_CheckOpcode, TARGET_VAL(ISD::AssertZext),
/* 23762*/ OPC_RecordChild0, // #0 = $rs1
/* 23763*/ OPC_CheckPredicate, 0, // Predicate_assertzexti32
/* 23765*/ OPC_SwitchType /*2 cases */, 59, MVT::i32,// ->23827
/* 23768*/ OPC_MoveParent,
/* 23769*/ OPC_SwitchType /*2 cases */, 30, MVT::f32,// ->23802
/* 23772*/ OPC_Scope, 13, /*->23787*/ // 2 children in Scope
/* 23774*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23776*/ OPC_EmitInteger, MVT::i32, 7,
/* 23779*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23787*/ /*Scope*/ 13, /*->23801*/
/* 23788*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 23790*/ OPC_EmitInteger, MVT::i32, 7,
/* 23793*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23801*/ 0, /*End of Scope*/
/* 23802*/ /*SwitchType*/ 22, MVT::f64,// ->23826
/* 23804*/ OPC_Scope, 9, /*->23815*/ // 2 children in Scope
/* 23806*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23808*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i32] }:$rs1)
/* 23815*/ /*Scope*/ 9, /*->23825*/
/* 23816*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23818*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (assertzext:{ *:[i32] } GPR:{ *:[i32] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i32] }:$rs1)
/* 23825*/ 0, /*End of Scope*/
/* 23826*/ 0, // EndSwitchType
/* 23827*/ /*SwitchType*/ 29, MVT::i64,// ->23858
/* 23829*/ OPC_MoveParent,
/* 23830*/ OPC_SwitchType /*2 cases */, 13, MVT::f32,// ->23846
/* 23833*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23835*/ OPC_EmitInteger, MVT::i64, 7,
/* 23838*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 23846*/ /*SwitchType*/ 9, MVT::f64,// ->23857
/* 23848*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 23850*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } (assertzext:{ *:[i64] } GPR:{ *:[i64] }:$rs1)<<P:Predicate_assertzexti32>>) - Complexity = 7
// Dst: (FCVT_D_WU:{ *:[f64] } ?:{ *:[i64] }:$rs1)
/* 23857*/ 0, // EndSwitchType
/* 23858*/ 0, // EndSwitchType
/* 23859*/ 0, /*End of Scope*/
/* 23860*/ /*Scope*/ 86|128,1/*214*/, /*->24076*/
/* 23862*/ OPC_RecordChild0, // #0 = $rs1
/* 23863*/ OPC_Scope, 16|128,1/*144*/, /*->24010*/ // 2 children in Scope
/* 23866*/ OPC_CheckChild0Type, MVT::i32,
/* 23868*/ OPC_SwitchType /*2 cases */, 86, MVT::f32,// ->23957
/* 23871*/ OPC_Scope, 13, /*->23886*/ // 6 children in Scope
/* 23873*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23875*/ OPC_EmitInteger, MVT::i32, 7,
/* 23878*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23886*/ /*Scope*/ 13, /*->23900*/
/* 23887*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23889*/ OPC_EmitInteger, MVT::i32, 7,
/* 23892*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23900*/ /*Scope*/ 13, /*->23914*/
/* 23901*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23903*/ OPC_EmitInteger, MVT::i32, 7,
/* 23906*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23914*/ /*Scope*/ 13, /*->23928*/
/* 23915*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 23917*/ OPC_EmitInteger, MVT::i32, 7,
/* 23920*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23928*/ /*Scope*/ 13, /*->23942*/
/* 23929*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23931*/ OPC_EmitInteger, MVT::i32, 7,
/* 23934*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_LU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_LU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23942*/ /*Scope*/ 13, /*->23956*/
/* 23943*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 23945*/ OPC_EmitInteger, MVT::i32, 7,
/* 23948*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_LU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_LU:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23956*/ 0, /*End of Scope*/
/* 23957*/ /*SwitchType*/ 50, MVT::f64,// ->24009
/* 23959*/ OPC_Scope, 9, /*->23970*/ // 4 children in Scope
/* 23961*/ OPC_CheckPatternPredicate, 35, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23963*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_WU:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 23970*/ /*Scope*/ 9, /*->23980*/
/* 23971*/ OPC_CheckPatternPredicate, 36, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit())
/* 23973*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_WU:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 23980*/ /*Scope*/ 13, /*->23994*/
/* 23981*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 23983*/ OPC_EmitInteger, MVT::i32, 7,
/* 23986*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_LU), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_LU:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 23994*/ /*Scope*/ 13, /*->24008*/
/* 23995*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 23997*/ OPC_EmitInteger, MVT::i32, 7,
/* 24000*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_LU), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_LU:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24008*/ 0, /*End of Scope*/
/* 24009*/ 0, // EndSwitchType
/* 24010*/ /*Scope*/ 64, /*->24075*/
/* 24011*/ OPC_CheckChild0Type, MVT::i64,
/* 24013*/ OPC_SwitchType /*2 cases */, 30, MVT::f32,// ->24046
/* 24016*/ OPC_Scope, 13, /*->24031*/ // 2 children in Scope
/* 24018*/ OPC_CheckPatternPredicate, 34, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24020*/ OPC_EmitInteger, MVT::i64, 7,
/* 24023*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_WU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_WU:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24031*/ /*Scope*/ 13, /*->24045*/
/* 24032*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24034*/ OPC_EmitInteger, MVT::i64, 7,
/* 24037*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_LU), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f32] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_LU:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24045*/ 0, /*End of Scope*/
/* 24046*/ /*SwitchType*/ 26, MVT::f64,// ->24074
/* 24048*/ OPC_Scope, 9, /*->24059*/ // 2 children in Scope
/* 24050*/ OPC_CheckPatternPredicate, 37, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24052*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_WU), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_WU:{ *:[f64] } GPR:{ *:[i64] }:$rs1)
/* 24059*/ /*Scope*/ 13, /*->24073*/
/* 24060*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24062*/ OPC_EmitInteger, MVT::i64, 7,
/* 24065*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_LU), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (uint_to_fp:{ *:[f64] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_LU:{ *:[f64] } GPR:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24073*/ 0, /*End of Scope*/
/* 24074*/ 0, // EndSwitchType
/* 24075*/ 0, /*End of Scope*/
/* 24076*/ 0, /*End of Scope*/
/* 24077*/ /*SwitchOpcode*/ 92|128,3/*476*/, TARGET_VAL(ISD::FMA),// ->24557
/* 24081*/ OPC_Scope, 119, /*->24202*/ // 6 children in Scope
/* 24083*/ OPC_MoveChild0,
/* 24084*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24087*/ OPC_RecordChild0, // #0 = $rs1
/* 24088*/ OPC_MoveParent,
/* 24089*/ OPC_RecordChild1, // #1 = $rs2
/* 24090*/ OPC_MoveChild2,
/* 24091*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24094*/ OPC_RecordChild0, // #2 = $rs3
/* 24095*/ OPC_MoveParent,
/* 24096*/ OPC_SwitchType /*2 cases */, 50, MVT::f32,// ->24149
/* 24099*/ OPC_Scope, 15, /*->24116*/ // 3 children in Scope
/* 24101*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24103*/ OPC_EmitInteger, MVT::i32, 7,
/* 24106*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24116*/ /*Scope*/ 15, /*->24132*/
/* 24117*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24119*/ OPC_EmitInteger, MVT::i64, 7,
/* 24122*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i64] })
/* 24132*/ /*Scope*/ 15, /*->24148*/
/* 24133*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24135*/ OPC_EmitInteger, MVT::i32, 7,
/* 24138*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24148*/ 0, /*End of Scope*/
/* 24149*/ /*SwitchType*/ 50, MVT::f64,// ->24201
/* 24151*/ OPC_Scope, 15, /*->24168*/ // 3 children in Scope
/* 24153*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24155*/ OPC_EmitInteger, MVT::i32, 7,
/* 24158*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24168*/ /*Scope*/ 15, /*->24184*/
/* 24169*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24171*/ OPC_EmitInteger, MVT::i64, 7,
/* 24174*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i64] })
/* 24184*/ /*Scope*/ 15, /*->24200*/
/* 24185*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24187*/ OPC_EmitInteger, MVT::i32, 7,
/* 24190*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 9
// Dst: (FNMADD_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24200*/ 0, /*End of Scope*/
/* 24201*/ 0, // EndSwitchType
/* 24202*/ /*Scope*/ 60, /*->24263*/
/* 24203*/ OPC_RecordChild0, // #0 = $rs1
/* 24204*/ OPC_RecordChild1, // #1 = $rs2
/* 24205*/ OPC_MoveChild2,
/* 24206*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24209*/ OPC_RecordChild0, // #2 = $rs3
/* 24210*/ OPC_MoveParent,
/* 24211*/ OPC_CheckType, MVT::f32,
/* 24213*/ OPC_Scope, 15, /*->24230*/ // 3 children in Scope
/* 24215*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24217*/ OPC_EmitInteger, MVT::i32, 7,
/* 24220*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24230*/ /*Scope*/ 15, /*->24246*/
/* 24231*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24233*/ OPC_EmitInteger, MVT::i64, 7,
/* 24236*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i64] })
/* 24246*/ /*Scope*/ 15, /*->24262*/
/* 24247*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24249*/ OPC_EmitInteger, MVT::i32, 7,
/* 24252*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24262*/ 0, /*End of Scope*/
/* 24263*/ /*Scope*/ 60, /*->24324*/
/* 24264*/ OPC_MoveChild0,
/* 24265*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24268*/ OPC_RecordChild0, // #0 = $rs1
/* 24269*/ OPC_MoveParent,
/* 24270*/ OPC_RecordChild1, // #1 = $rs2
/* 24271*/ OPC_RecordChild2, // #2 = $rs3
/* 24272*/ OPC_CheckType, MVT::f32,
/* 24274*/ OPC_Scope, 15, /*->24291*/ // 3 children in Scope
/* 24276*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24278*/ OPC_EmitInteger, MVT::i32, 7,
/* 24281*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24291*/ /*Scope*/ 15, /*->24307*/
/* 24292*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24294*/ OPC_EmitInteger, MVT::i64, 7,
/* 24297*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i64] })
/* 24307*/ /*Scope*/ 15, /*->24323*/
/* 24308*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24310*/ OPC_EmitInteger, MVT::i32, 7,
/* 24313*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1), FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24323*/ 0, /*End of Scope*/
/* 24324*/ /*Scope*/ 60, /*->24385*/
/* 24325*/ OPC_RecordChild0, // #0 = $rs1
/* 24326*/ OPC_RecordChild1, // #1 = $rs2
/* 24327*/ OPC_MoveChild2,
/* 24328*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24331*/ OPC_RecordChild0, // #2 = $rs3
/* 24332*/ OPC_MoveParent,
/* 24333*/ OPC_CheckType, MVT::f64,
/* 24335*/ OPC_Scope, 15, /*->24352*/ // 3 children in Scope
/* 24337*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24339*/ OPC_EmitInteger, MVT::i32, 7,
/* 24342*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24352*/ /*Scope*/ 15, /*->24368*/
/* 24353*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24355*/ OPC_EmitInteger, MVT::i64, 7,
/* 24358*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i64] })
/* 24368*/ /*Scope*/ 15, /*->24384*/
/* 24369*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24371*/ OPC_EmitInteger, MVT::i32, 7,
/* 24374*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs3)) - Complexity = 6
// Dst: (FMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24384*/ 0, /*End of Scope*/
/* 24385*/ /*Scope*/ 60, /*->24446*/
/* 24386*/ OPC_MoveChild0,
/* 24387*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24390*/ OPC_RecordChild0, // #0 = $rs1
/* 24391*/ OPC_MoveParent,
/* 24392*/ OPC_RecordChild1, // #1 = $rs2
/* 24393*/ OPC_RecordChild2, // #2 = $rs3
/* 24394*/ OPC_CheckType, MVT::f64,
/* 24396*/ OPC_Scope, 15, /*->24413*/ // 3 children in Scope
/* 24398*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24400*/ OPC_EmitInteger, MVT::i32, 7,
/* 24403*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24413*/ /*Scope*/ 15, /*->24429*/
/* 24414*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24416*/ OPC_EmitInteger, MVT::i64, 7,
/* 24419*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i64] })
/* 24429*/ /*Scope*/ 15, /*->24445*/
/* 24430*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24432*/ OPC_EmitInteger, MVT::i32, 7,
/* 24435*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FNMSUB_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1), FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 6
// Dst: (FNMSUB_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24445*/ 0, /*End of Scope*/
/* 24446*/ /*Scope*/ 109, /*->24556*/
/* 24447*/ OPC_RecordChild0, // #0 = $rs1
/* 24448*/ OPC_RecordChild1, // #1 = $rs2
/* 24449*/ OPC_RecordChild2, // #2 = $rs3
/* 24450*/ OPC_SwitchType /*2 cases */, 50, MVT::f32,// ->24503
/* 24453*/ OPC_Scope, 15, /*->24470*/ // 3 children in Scope
/* 24455*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24457*/ OPC_EmitInteger, MVT::i32, 7,
/* 24460*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 3
// Dst: (FMADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, ?:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24470*/ /*Scope*/ 15, /*->24486*/
/* 24471*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24473*/ OPC_EmitInteger, MVT::i64, 7,
/* 24476*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 3
// Dst: (FMADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, ?:{ *:[f32] }:$rs3, 7:{ *:[i64] })
/* 24486*/ /*Scope*/ 15, /*->24502*/
/* 24487*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24489*/ OPC_EmitInteger, MVT::i32, 7,
/* 24492*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_S), 0,
MVT::f32, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2, FPR32:{ *:[f32] }:$rs3) - Complexity = 3
// Dst: (FMADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, ?:{ *:[f32] }:$rs3, 7:{ *:[i32] })
/* 24502*/ 0, /*End of Scope*/
/* 24503*/ /*SwitchType*/ 50, MVT::f64,// ->24555
/* 24505*/ OPC_Scope, 15, /*->24522*/ // 3 children in Scope
/* 24507*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24509*/ OPC_EmitInteger, MVT::i32, 7,
/* 24512*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 3
// Dst: (FMADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, ?:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24522*/ /*Scope*/ 15, /*->24538*/
/* 24523*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24525*/ OPC_EmitInteger, MVT::i64, 7,
/* 24528*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 3
// Dst: (FMADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, ?:{ *:[f64] }:$rs3, 7:{ *:[i64] })
/* 24538*/ /*Scope*/ 15, /*->24554*/
/* 24539*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24541*/ OPC_EmitInteger, MVT::i32, 7,
/* 24544*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMADD_D), 0,
MVT::f64, 4/*#Ops*/, 0, 1, 2, 3,
// Src: (fma:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2, FPR64:{ *:[f64] }:$rs3) - Complexity = 3
// Dst: (FMADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, ?:{ *:[f64] }:$rs3, 7:{ *:[i32] })
/* 24554*/ 0, /*End of Scope*/
/* 24555*/ 0, // EndSwitchType
/* 24556*/ 0, /*End of Scope*/
/* 24557*/ /*SwitchOpcode*/ 40|128,1/*168*/, TARGET_VAL(ISD::FCOPYSIGN),// ->24729
/* 24561*/ OPC_RecordChild0, // #0 = $rs1
/* 24562*/ OPC_Scope, 37, /*->24601*/ // 2 children in Scope
/* 24564*/ OPC_MoveChild1,
/* 24565*/ OPC_CheckOpcode, TARGET_VAL(ISD::FNEG),
/* 24568*/ OPC_RecordChild0, // #1 = $rs2
/* 24569*/ OPC_SwitchType /*2 cases */, 13, MVT::f32,// ->24585
/* 24572*/ OPC_MoveParent,
/* 24573*/ OPC_CheckType, MVT::f32,
/* 24575*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24577*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJN_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fcopysign:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs2)) - Complexity = 6
// Dst: (FSGNJN_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 24585*/ /*SwitchType*/ 13, MVT::f64,// ->24600
/* 24587*/ OPC_MoveParent,
/* 24588*/ OPC_CheckType, MVT::f64,
/* 24590*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24592*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJN_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fcopysign:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs2)) - Complexity = 6
// Dst: (FSGNJN_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 24600*/ 0, // EndSwitchType
/* 24601*/ /*Scope*/ 126, /*->24728*/
/* 24602*/ OPC_RecordChild1, // #1 = $rs2
/* 24603*/ OPC_Scope, 35, /*->24640*/ // 2 children in Scope
/* 24605*/ OPC_CheckChild1Type, MVT::f32,
/* 24607*/ OPC_SwitchType /*2 cases */, 10, MVT::f32,// ->24620
/* 24610*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24612*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fcopysign:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 24620*/ /*SwitchType*/ 17, MVT::f64,// ->24639
/* 24622*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24624*/ OPC_EmitNode1, TARGET_VAL(RISCV::FCVT_D_S), 0,
MVT::f64, 1/*#Ops*/, 1, // Results = #2
/* 24631*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_D), 0,
MVT::f64, 2/*#Ops*/, 0, 2,
// Src: (fcopysign:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, (FCVT_D_S:{ *:[f64] } ?:{ *:[f32] }:$rs2))
/* 24639*/ 0, // EndSwitchType
/* 24640*/ /*Scope*/ 86, /*->24727*/
/* 24641*/ OPC_CheckChild1Type, MVT::f64,
/* 24643*/ OPC_SwitchType /*2 cases */, 10, MVT::f64,// ->24656
/* 24646*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24648*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fcopysign:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 24656*/ /*SwitchType*/ 68, MVT::f32,// ->24726
/* 24658*/ OPC_Scope, 21, /*->24681*/ // 3 children in Scope
/* 24660*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24662*/ OPC_EmitInteger, MVT::i32, 7,
/* 24665*/ OPC_EmitNode1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 1, 2, // Results = #3
/* 24673*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_S), 0,
MVT::f32, 2/*#Ops*/, 0, 3,
// Src: (fcopysign:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, (FCVT_S_D:{ *:[f32] } ?:{ *:[f64] }:$rs2, 7:{ *:[i32] }))
/* 24681*/ /*Scope*/ 21, /*->24703*/
/* 24682*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24684*/ OPC_EmitInteger, MVT::i64, 7,
/* 24687*/ OPC_EmitNode1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 1, 2, // Results = #3
/* 24695*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_S), 0,
MVT::f32, 2/*#Ops*/, 0, 3,
// Src: (fcopysign:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, (FCVT_S_D:{ *:[f32] } ?:{ *:[f64] }:$rs2, 7:{ *:[i64] }))
/* 24703*/ /*Scope*/ 21, /*->24725*/
/* 24704*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 24706*/ OPC_EmitInteger, MVT::i32, 7,
/* 24709*/ OPC_EmitNode1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 1, 2, // Results = #3
/* 24717*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJ_S), 0,
MVT::f32, 2/*#Ops*/, 0, 3,
// Src: (fcopysign:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSGNJ_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, (FCVT_S_D:{ *:[f32] } ?:{ *:[f64] }:$rs2, 7:{ *:[i32] }))
/* 24725*/ 0, /*End of Scope*/
/* 24726*/ 0, // EndSwitchType
/* 24727*/ 0, /*End of Scope*/
/* 24728*/ 0, /*End of Scope*/
/* 24729*/ /*SwitchOpcode*/ 1|128,2/*257*/, TARGET_VAL(ISD::SINT_TO_FP),// ->24990
/* 24733*/ OPC_Scope, 38, /*->24773*/ // 2 children in Scope
/* 24735*/ OPC_MoveChild0,
/* 24736*/ OPC_CheckOpcode, TARGET_VAL(ISD::SIGN_EXTEND_INREG),
/* 24739*/ OPC_RecordChild0, // #0 = $rs1
/* 24740*/ OPC_MoveChild1,
/* 24741*/ OPC_CheckValueType, MVT::i32,
/* 24743*/ OPC_MoveParent,
/* 24744*/ OPC_MoveParent,
/* 24745*/ OPC_SwitchType /*2 cases */, 13, MVT::f32,// ->24761
/* 24748*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24750*/ OPC_EmitInteger, MVT::i64, 7,
/* 24753*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] })) - Complexity = 6
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24761*/ /*SwitchType*/ 9, MVT::f64,// ->24772
/* 24763*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24765*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_W), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (sint_to_fp:{ *:[f64] } (sext_inreg:{ *:[i64] } GPR:{ *:[i64] }:$rs1, i32:{ *:[Other] })) - Complexity = 6
// Dst: (FCVT_D_W:{ *:[f64] } ?:{ *:[i64] }:$rs1)
/* 24772*/ 0, // EndSwitchType
/* 24773*/ /*Scope*/ 86|128,1/*214*/, /*->24989*/
/* 24775*/ OPC_RecordChild0, // #0 = $rs1
/* 24776*/ OPC_Scope, 16|128,1/*144*/, /*->24923*/ // 2 children in Scope
/* 24779*/ OPC_CheckChild0Type, MVT::i32,
/* 24781*/ OPC_SwitchType /*2 cases */, 86, MVT::f32,// ->24870
/* 24784*/ OPC_Scope, 13, /*->24799*/ // 6 children in Scope
/* 24786*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24788*/ OPC_EmitInteger, MVT::i32, 7,
/* 24791*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24799*/ /*Scope*/ 13, /*->24813*/
/* 24800*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 24802*/ OPC_EmitInteger, MVT::i32, 7,
/* 24805*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24813*/ /*Scope*/ 13, /*->24827*/
/* 24814*/ OPC_CheckPatternPredicate, 30, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24816*/ OPC_EmitInteger, MVT::i32, 7,
/* 24819*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24827*/ /*Scope*/ 13, /*->24841*/
/* 24828*/ OPC_CheckPatternPredicate, 31, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit())
/* 24830*/ OPC_EmitInteger, MVT::i32, 7,
/* 24833*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24841*/ /*Scope*/ 13, /*->24855*/
/* 24842*/ OPC_CheckPatternPredicate, 32, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24844*/ OPC_EmitInteger, MVT::i32, 7,
/* 24847*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_L), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_L:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24855*/ /*Scope*/ 13, /*->24869*/
/* 24856*/ OPC_CheckPatternPredicate, 33, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit())
/* 24858*/ OPC_EmitInteger, MVT::i32, 7,
/* 24861*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_L), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_L:{ *:[f32] } ?:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24869*/ 0, /*End of Scope*/
/* 24870*/ /*SwitchType*/ 50, MVT::f64,// ->24922
/* 24872*/ OPC_Scope, 9, /*->24883*/ // 4 children in Scope
/* 24874*/ OPC_CheckPatternPredicate, 35, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24876*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_W), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_W:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 24883*/ /*Scope*/ 9, /*->24893*/
/* 24884*/ OPC_CheckPatternPredicate, 36, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit())
/* 24886*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_W), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_W:{ *:[f64] } GPR:{ *:[i32] }:$rs1)
/* 24893*/ /*Scope*/ 13, /*->24907*/
/* 24894*/ OPC_CheckPatternPredicate, 28, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 24896*/ OPC_EmitInteger, MVT::i32, 7,
/* 24899*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_L), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_L:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24907*/ /*Scope*/ 13, /*->24921*/
/* 24908*/ OPC_CheckPatternPredicate, 29, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit())
/* 24910*/ OPC_EmitInteger, MVT::i32, 7,
/* 24913*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_L), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_L:{ *:[f64] } GPR:{ *:[i32] }:$rs1, 7:{ *:[i32] })
/* 24921*/ 0, /*End of Scope*/
/* 24922*/ 0, // EndSwitchType
/* 24923*/ /*Scope*/ 64, /*->24988*/
/* 24924*/ OPC_CheckChild0Type, MVT::i64,
/* 24926*/ OPC_SwitchType /*2 cases */, 30, MVT::f32,// ->24959
/* 24929*/ OPC_Scope, 13, /*->24944*/ // 2 children in Scope
/* 24931*/ OPC_CheckPatternPredicate, 34, // (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24933*/ OPC_EmitInteger, MVT::i64, 7,
/* 24936*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_W), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_W:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24944*/ /*Scope*/ 13, /*->24958*/
/* 24945*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24947*/ OPC_EmitInteger, MVT::i64, 7,
/* 24950*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_L), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f32] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_L:{ *:[f32] } ?:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24958*/ 0, /*End of Scope*/
/* 24959*/ /*SwitchType*/ 26, MVT::f64,// ->24987
/* 24961*/ OPC_Scope, 9, /*->24972*/ // 2 children in Scope
/* 24963*/ OPC_CheckPatternPredicate, 37, // (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24965*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_W), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_W:{ *:[f64] } GPR:{ *:[i64] }:$rs1)
/* 24972*/ /*Scope*/ 13, /*->24986*/
/* 24973*/ OPC_CheckPatternPredicate, 23, // (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 24975*/ OPC_EmitInteger, MVT::i64, 7,
/* 24978*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_L), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (sint_to_fp:{ *:[f64] } GPR:{ *:[i64] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_L:{ *:[f64] } GPR:{ *:[i64] }:$rs1, 7:{ *:[i64] })
/* 24986*/ 0, /*End of Scope*/
/* 24987*/ 0, // EndSwitchType
/* 24988*/ 0, /*End of Scope*/
/* 24989*/ 0, /*End of Scope*/
/* 24990*/ /*SwitchOpcode*/ 27, TARGET_VAL(ISD::FNEG),// ->25020
/* 24993*/ OPC_RecordChild0, // #0 = $rs1
/* 24994*/ OPC_SwitchType /*2 cases */, 10, MVT::f32,// ->25007
/* 24997*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 24999*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJN_S), 0,
MVT::f32, 2/*#Ops*/, 0, 0,
// Src: (fneg:{ *:[f32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FSGNJN_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs1)
/* 25007*/ /*SwitchType*/ 10, MVT::f64,// ->25019
/* 25009*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25011*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJN_D), 0,
MVT::f64, 2/*#Ops*/, 0, 0,
// Src: (fneg:{ *:[f64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FSGNJN_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs1)
/* 25019*/ 0, // EndSwitchType
/* 25020*/ /*SwitchOpcode*/ 27, TARGET_VAL(ISD::FABS),// ->25050
/* 25023*/ OPC_RecordChild0, // #0 = $rs1
/* 25024*/ OPC_SwitchType /*2 cases */, 10, MVT::f32,// ->25037
/* 25027*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25029*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJX_S), 0,
MVT::f32, 2/*#Ops*/, 0, 0,
// Src: (fabs:{ *:[f32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FSGNJX_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs1)
/* 25037*/ /*SwitchType*/ 10, MVT::f64,// ->25049
/* 25039*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25041*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSGNJX_D), 0,
MVT::f64, 2/*#Ops*/, 0, 0,
// Src: (fabs:{ *:[f64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FSGNJX_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs1)
/* 25049*/ 0, // EndSwitchType
/* 25050*/ /*SwitchOpcode*/ 28, TARGET_VAL(ISD::FMINNUM),// ->25081
/* 25053*/ OPC_RecordChild0, // #0 = $rs1
/* 25054*/ OPC_RecordChild1, // #1 = $rs2
/* 25055*/ OPC_SwitchType /*2 cases */, 10, MVT::f32,// ->25068
/* 25058*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25060*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMIN_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fminnum:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FMIN_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 25068*/ /*SwitchType*/ 10, MVT::f64,// ->25080
/* 25070*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25072*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMIN_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fminnum:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FMIN_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 25080*/ 0, // EndSwitchType
/* 25081*/ /*SwitchOpcode*/ 28, TARGET_VAL(ISD::FMAXNUM),// ->25112
/* 25084*/ OPC_RecordChild0, // #0 = $rs1
/* 25085*/ OPC_RecordChild1, // #1 = $rs2
/* 25086*/ OPC_SwitchType /*2 cases */, 10, MVT::f32,// ->25099
/* 25089*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25091*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMAX_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fmaxnum:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FMAX_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2)
/* 25099*/ /*SwitchType*/ 10, MVT::f64,// ->25111
/* 25101*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25103*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMAX_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fmaxnum:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FMAX_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2)
/* 25111*/ 0, // EndSwitchType
/* 25112*/ /*SwitchOpcode*/ 10, TARGET_VAL(ISD::FP_EXTEND),// ->25125
/* 25115*/ OPC_RecordChild0, // #0 = $rs1
/* 25116*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25118*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_D_S), 0,
MVT::f64, 1/*#Ops*/, 0,
// Src: (fpextend:{ *:[f64] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FCVT_D_S:{ *:[f64] } FPR32:{ *:[f32] }:$rs1)
/* 25125*/ /*SwitchOpcode*/ 102, TARGET_VAL(ISD::FADD),// ->25230
/* 25128*/ OPC_RecordChild0, // #0 = $rs1
/* 25129*/ OPC_RecordChild1, // #1 = $rs2
/* 25130*/ OPC_SwitchType /*2 cases */, 47, MVT::f32,// ->25180
/* 25133*/ OPC_Scope, 14, /*->25149*/ // 3 children in Scope
/* 25135*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25137*/ OPC_EmitInteger, MVT::i32, 7,
/* 25140*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25149*/ /*Scope*/ 14, /*->25164*/
/* 25150*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25152*/ OPC_EmitInteger, MVT::i64, 7,
/* 25155*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i64] })
/* 25164*/ /*Scope*/ 14, /*->25179*/
/* 25165*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25167*/ OPC_EmitInteger, MVT::i32, 7,
/* 25170*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FADD_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25179*/ 0, /*End of Scope*/
/* 25180*/ /*SwitchType*/ 47, MVT::f64,// ->25229
/* 25182*/ OPC_Scope, 14, /*->25198*/ // 3 children in Scope
/* 25184*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25186*/ OPC_EmitInteger, MVT::i32, 7,
/* 25189*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25198*/ /*Scope*/ 14, /*->25213*/
/* 25199*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25201*/ OPC_EmitInteger, MVT::i64, 7,
/* 25204*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i64] })
/* 25213*/ /*Scope*/ 14, /*->25228*/
/* 25214*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25216*/ OPC_EmitInteger, MVT::i32, 7,
/* 25219*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FADD_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fadd:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FADD_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25228*/ 0, /*End of Scope*/
/* 25229*/ 0, // EndSwitchType
/* 25230*/ /*SwitchOpcode*/ 102, TARGET_VAL(ISD::FSUB),// ->25335
/* 25233*/ OPC_RecordChild0, // #0 = $rs1
/* 25234*/ OPC_RecordChild1, // #1 = $rs2
/* 25235*/ OPC_SwitchType /*2 cases */, 47, MVT::f32,// ->25285
/* 25238*/ OPC_Scope, 14, /*->25254*/ // 3 children in Scope
/* 25240*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25242*/ OPC_EmitInteger, MVT::i32, 7,
/* 25245*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FSUB_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25254*/ /*Scope*/ 14, /*->25269*/
/* 25255*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25257*/ OPC_EmitInteger, MVT::i64, 7,
/* 25260*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FSUB_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i64] })
/* 25269*/ /*Scope*/ 14, /*->25284*/
/* 25270*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25272*/ OPC_EmitInteger, MVT::i32, 7,
/* 25275*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FSUB_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25284*/ 0, /*End of Scope*/
/* 25285*/ /*SwitchType*/ 47, MVT::f64,// ->25334
/* 25287*/ OPC_Scope, 14, /*->25303*/ // 3 children in Scope
/* 25289*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25291*/ OPC_EmitInteger, MVT::i32, 7,
/* 25294*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSUB_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25303*/ /*Scope*/ 14, /*->25318*/
/* 25304*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25306*/ OPC_EmitInteger, MVT::i64, 7,
/* 25309*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSUB_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i64] })
/* 25318*/ /*Scope*/ 14, /*->25333*/
/* 25319*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25321*/ OPC_EmitInteger, MVT::i32, 7,
/* 25324*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSUB_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fsub:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FSUB_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25333*/ 0, /*End of Scope*/
/* 25334*/ 0, // EndSwitchType
/* 25335*/ /*SwitchOpcode*/ 102, TARGET_VAL(ISD::FMUL),// ->25440
/* 25338*/ OPC_RecordChild0, // #0 = $rs1
/* 25339*/ OPC_RecordChild1, // #1 = $rs2
/* 25340*/ OPC_SwitchType /*2 cases */, 47, MVT::f32,// ->25390
/* 25343*/ OPC_Scope, 14, /*->25359*/ // 3 children in Scope
/* 25345*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25347*/ OPC_EmitInteger, MVT::i32, 7,
/* 25350*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FMUL_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25359*/ /*Scope*/ 14, /*->25374*/
/* 25360*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25362*/ OPC_EmitInteger, MVT::i64, 7,
/* 25365*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FMUL_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i64] })
/* 25374*/ /*Scope*/ 14, /*->25389*/
/* 25375*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25377*/ OPC_EmitInteger, MVT::i32, 7,
/* 25380*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FMUL_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25389*/ 0, /*End of Scope*/
/* 25390*/ /*SwitchType*/ 47, MVT::f64,// ->25439
/* 25392*/ OPC_Scope, 14, /*->25408*/ // 3 children in Scope
/* 25394*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25396*/ OPC_EmitInteger, MVT::i32, 7,
/* 25399*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FMUL_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25408*/ /*Scope*/ 14, /*->25423*/
/* 25409*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25411*/ OPC_EmitInteger, MVT::i64, 7,
/* 25414*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FMUL_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i64] })
/* 25423*/ /*Scope*/ 14, /*->25438*/
/* 25424*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25426*/ OPC_EmitInteger, MVT::i32, 7,
/* 25429*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMUL_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fmul:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FMUL_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25438*/ 0, /*End of Scope*/
/* 25439*/ 0, // EndSwitchType
/* 25440*/ /*SwitchOpcode*/ 102, TARGET_VAL(ISD::FDIV),// ->25545
/* 25443*/ OPC_RecordChild0, // #0 = $rs1
/* 25444*/ OPC_RecordChild1, // #1 = $rs2
/* 25445*/ OPC_SwitchType /*2 cases */, 47, MVT::f32,// ->25495
/* 25448*/ OPC_Scope, 14, /*->25464*/ // 3 children in Scope
/* 25450*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25452*/ OPC_EmitInteger, MVT::i32, 7,
/* 25455*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FDIV_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25464*/ /*Scope*/ 14, /*->25479*/
/* 25465*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25467*/ OPC_EmitInteger, MVT::i64, 7,
/* 25470*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FDIV_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i64] })
/* 25479*/ /*Scope*/ 14, /*->25494*/
/* 25480*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25482*/ OPC_EmitInteger, MVT::i32, 7,
/* 25485*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_S), 0,
MVT::f32, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, FPR32:{ *:[f32] }:$rs2) - Complexity = 3
// Dst: (FDIV_S:{ *:[f32] } ?:{ *:[f32] }:$rs1, ?:{ *:[f32] }:$rs2, 7:{ *:[i32] })
/* 25494*/ 0, /*End of Scope*/
/* 25495*/ /*SwitchType*/ 47, MVT::f64,// ->25544
/* 25497*/ OPC_Scope, 14, /*->25513*/ // 3 children in Scope
/* 25499*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25501*/ OPC_EmitInteger, MVT::i32, 7,
/* 25504*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FDIV_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25513*/ /*Scope*/ 14, /*->25528*/
/* 25514*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25516*/ OPC_EmitInteger, MVT::i64, 7,
/* 25519*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FDIV_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i64] })
/* 25528*/ /*Scope*/ 14, /*->25543*/
/* 25529*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25531*/ OPC_EmitInteger, MVT::i32, 7,
/* 25534*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FDIV_D), 0,
MVT::f64, 3/*#Ops*/, 0, 1, 2,
// Src: (fdiv:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, FPR64:{ *:[f64] }:$rs2) - Complexity = 3
// Dst: (FDIV_D:{ *:[f64] } ?:{ *:[f64] }:$rs1, ?:{ *:[f64] }:$rs2, 7:{ *:[i32] })
/* 25543*/ 0, /*End of Scope*/
/* 25544*/ 0, // EndSwitchType
/* 25545*/ /*SwitchOpcode*/ 95, TARGET_VAL(ISD::FSQRT),// ->25643
/* 25548*/ OPC_RecordChild0, // #0 = $rs1
/* 25549*/ OPC_SwitchType /*2 cases */, 44, MVT::f32,// ->25596
/* 25552*/ OPC_Scope, 13, /*->25567*/ // 3 children in Scope
/* 25554*/ OPC_CheckPatternPredicate, 11, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25556*/ OPC_EmitInteger, MVT::i32, 7,
/* 25559*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FSQRT_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, 7:{ *:[i32] })
/* 25567*/ /*Scope*/ 13, /*->25581*/
/* 25568*/ OPC_CheckPatternPredicate, 15, // (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25570*/ OPC_EmitInteger, MVT::i64, 7,
/* 25573*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FSQRT_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, 7:{ *:[i64] })
/* 25581*/ /*Scope*/ 13, /*->25595*/
/* 25582*/ OPC_CheckPatternPredicate, 12, // (Subtarget->hasStdExtF())
/* 25584*/ OPC_EmitInteger, MVT::i32, 7,
/* 25587*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_S), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f32] } FPR32:{ *:[f32] }:$rs1) - Complexity = 3
// Dst: (FSQRT_S:{ *:[f32] } FPR32:{ *:[f32] }:$rs1, 7:{ *:[i32] })
/* 25595*/ 0, /*End of Scope*/
/* 25596*/ /*SwitchType*/ 44, MVT::f64,// ->25642
/* 25598*/ OPC_Scope, 13, /*->25613*/ // 3 children in Scope
/* 25600*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25602*/ OPC_EmitInteger, MVT::i32, 7,
/* 25605*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FSQRT_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i32] })
/* 25613*/ /*Scope*/ 13, /*->25627*/
/* 25614*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25616*/ OPC_EmitInteger, MVT::i64, 7,
/* 25619*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FSQRT_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i64] })
/* 25627*/ /*Scope*/ 13, /*->25641*/
/* 25628*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25630*/ OPC_EmitInteger, MVT::i32, 7,
/* 25633*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FSQRT_D), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (fsqrt:{ *:[f64] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FSQRT_D:{ *:[f64] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i32] })
/* 25641*/ 0, /*End of Scope*/
/* 25642*/ 0, // EndSwitchType
/* 25643*/ /*SwitchOpcode*/ 10, TARGET_VAL(RISCVISD::FMV_W_X_RV64),// ->25656
/* 25646*/ OPC_RecordChild0, // #0 = $src
/* 25647*/ OPC_CheckPatternPredicate, 24, // (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25649*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FMV_W_X), 0,
MVT::f32, 1/*#Ops*/, 0,
// Src: (riscv_fmv_w_x_rv64:{ *:[f32] } GPR:{ *:[i64] }:$src) - Complexity = 3
// Dst: (FMV_W_X:{ *:[f32] } GPR:{ *:[i64] }:$src)
/* 25656*/ /*SwitchOpcode*/ 45, TARGET_VAL(ISD::FP_ROUND),// ->25704
/* 25659*/ OPC_RecordChild0, // #0 = $rs1
/* 25660*/ OPC_Scope, 13, /*->25675*/ // 3 children in Scope
/* 25662*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25664*/ OPC_EmitInteger, MVT::i32, 7,
/* 25667*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fpround:{ *:[f32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_D:{ *:[f32] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i32] })
/* 25675*/ /*Scope*/ 13, /*->25689*/
/* 25676*/ OPC_CheckPatternPredicate, 16, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"))
/* 25678*/ OPC_EmitInteger, MVT::i64, 7,
/* 25681*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fpround:{ *:[f32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_D:{ *:[f32] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i64] })
/* 25689*/ /*Scope*/ 13, /*->25703*/
/* 25690*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25692*/ OPC_EmitInteger, MVT::i32, 7,
/* 25695*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::FCVT_S_D), 0,
MVT::f32, 2/*#Ops*/, 0, 1,
// Src: (fpround:{ *:[f32] } FPR64:{ *:[f64] }:$rs1) - Complexity = 3
// Dst: (FCVT_S_D:{ *:[f32] } FPR64:{ *:[f64] }:$rs1, 7:{ *:[i32] })
/* 25703*/ 0, /*End of Scope*/
/* 25704*/ /*SwitchOpcode*/ 26, TARGET_VAL(RISCVISD::BuildPairF64),// ->25733
/* 25707*/ OPC_RecordChild0, // #0 = $src1
/* 25708*/ OPC_RecordChild1, // #1 = $src2
/* 25709*/ OPC_Scope, 10, /*->25721*/ // 2 children in Scope
/* 25711*/ OPC_CheckPatternPredicate, 13, // (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"))
/* 25713*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::BuildPairF64Pseudo), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (RISCVBuildPairF64:{ *:[f64] } GPR:{ *:[i32] }:$src1, GPR:{ *:[i32] }:$src2) - Complexity = 3
// Dst: (BuildPairF64Pseudo:{ *:[f64] } GPR:{ *:[i32] }:$src1, GPR:{ *:[i32] }:$src2)
/* 25721*/ /*Scope*/ 10, /*->25732*/
/* 25722*/ OPC_CheckPatternPredicate, 14, // (Subtarget->hasStdExtD())
/* 25724*/ OPC_MorphNodeTo1, TARGET_VAL(RISCV::BuildPairF64Pseudo), 0,
MVT::f64, 2/*#Ops*/, 0, 1,
// Src: (RISCVBuildPairF64:{ *:[f64] } GPR:{ *:[i32] }:$src1, GPR:{ *:[i32] }:$src2) - Complexity = 3
// Dst: (BuildPairF64Pseudo:{ *:[f64] } GPR:{ *:[i32] }:$src1, GPR:{ *:[i32] }:$src2)
/* 25732*/ 0, /*End of Scope*/
/* 25733*/ 0, // EndSwitchOpcode
0
}; // Total Array size is 25735 bytes
// Opcode Histogram:
// #OPC_Scope = 627
// #OPC_RecordNode = 33
// #OPC_RecordChild = 364
// #OPC_RecordMemRef = 16
// #OPC_CaptureGlueInput = 8
// #OPC_MoveChild = 160
// #OPC_MoveParent = 260
// #OPC_CheckSame = 0
// #OPC_CheckChildSame = 0
// #OPC_CheckPatternPredicate = 1223
// #OPC_CheckPredicate = 721
// #OPC_CheckOpcode = 128
// #OPC_SwitchOpcode = 18
// #OPC_CheckType = 77
// #OPC_SwitchType = 146
// #OPC_CheckChildType = 123
// #OPC_CheckInteger = 0
// #OPC_CheckChildInteger = 24
// #OPC_CheckCondCode = 0
// #OPC_CheckChild2CondCode = 68
// #OPC_CheckValueType = 22
// #OPC_CheckComplexPat = 256
// #OPC_CheckAndImm = 15
// #OPC_CheckOrImm = 0
// #OPC_CheckImmAllOnesV = 0
// #OPC_CheckImmAllZerosV = 0
// #OPC_CheckFoldableChainNode = 0
// #OPC_EmitInteger = 406
// #OPC_EmitStringInteger = 0
// #OPC_EmitRegister = 66
// #OPC_EmitConvertToTarget = 343
// #OPC_EmitMergeInputChains = 894
// #OPC_EmitCopyToReg = 0
// #OPC_EmitNode = 94
// #OPC_EmitNodeXForm = 9
// #OPC_CompleteMatch = 0
// #OPC_MorphNodeTo = 1338
#undef TARGET_VAL
SelectCodeCommon(N, MatcherTable,sizeof(MatcherTable));
}
#endif // GET_DAGISEL_BODY
#ifdef GET_DAGISEL_DECL
bool CheckPatternPredicate(unsigned PredNo) const override;
#endif
#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE
bool DAGISEL_CLASS_COLONCOLON CheckPatternPredicate(unsigned PredNo) const
#if DAGISEL_INLINE
override
#endif
{
switch (PredNo) {
default: llvm_unreachable("Invalid predicate in table?");
case 0: return (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 1: return (Subtarget->hasStdExtM()) && (Subtarget->is64Bit());
case 2: return (Subtarget->hasStdExtM()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 3: return (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 4: return (Subtarget->is64Bit());
case 5: return (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 6: return (MF->getSubtarget().checkFeatures("-64bit"));
case 7: return (MF->getSubtarget().checkFeatures("+64bit"));
case 8: return (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 9: return (!Subtarget->is64Bit());
case 10: return (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 11: return (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 12: return (Subtarget->hasStdExtF());
case 13: return (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 14: return (Subtarget->hasStdExtD());
case 15: return (Subtarget->hasStdExtF()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 16: return (Subtarget->hasStdExtD()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 17: return (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 18: return (Subtarget->hasStdExtA());
case 19: return (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 20: return (Subtarget->hasStdExtA()) && (Subtarget->is64Bit());
case 21: return (Subtarget->hasStdExtA()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 22: return (Subtarget->hasStdExtA()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 23: return (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 24: return (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 25: return (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 26: return (Subtarget->hasStdExtM());
case 27: return (Subtarget->hasStdExtM()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 28: return (Subtarget->hasStdExtD()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 29: return (Subtarget->hasStdExtD()) && (Subtarget->is64Bit());
case 30: return (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 31: return (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit());
case 32: return (Subtarget->hasStdExtF()) && (Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 33: return (Subtarget->hasStdExtF()) && (Subtarget->is64Bit());
case 34: return (Subtarget->hasStdExtF()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
case 35: return (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("-64bit"));
case 36: return (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit());
case 37: return (Subtarget->hasStdExtD()) && (!Subtarget->is64Bit()) && (MF->getSubtarget().checkFeatures("+64bit"));
}
}
#endif // GET_DAGISEL_BODY
#ifdef GET_DAGISEL_DECL
bool CheckNodePredicate(SDNode *Node, unsigned PredNo) const override;
#endif
#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE
bool DAGISEL_CLASS_COLONCOLON CheckNodePredicate(SDNode *Node, unsigned PredNo) const
#if DAGISEL_INLINE
override
#endif
{
switch (PredNo) {
default: llvm_unreachable("Invalid predicate in table?");
case 0: {
// Predicate_assertzexti32
// Predicate_assertsexti32
SDNode *N = Node;
(void)N;
return cast<VTSDNode>(N->getOperand(1))->getVT() == MVT::i32;
}
case 1: {
// Predicate_simm12
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
return isInt<12>(Imm);
}
case 2: {
// Predicate_IsOrAdd
SDNode *N = Node;
(void)N;
return isOrEquivalentToAdd(N);
}
case 3: {
// Predicate_unindexedload
SDNode *N = Node;
(void)N;
if (cast<LoadSDNode>(N)->getAddressingMode() != ISD::UNINDEXED) return false;
return true;
}
case 4: {
// Predicate_sextload
SDNode *N = Node;
(void)N;
if (cast<LoadSDNode>(N)->getExtensionType() != ISD::SEXTLOAD) return false;
return true;
}
case 5: {
// Predicate_sextloadi8
// Predicate_extloadi8
// Predicate_zextloadi8
// Predicate_truncstorei8
// Predicate_atomic_store_8
// Predicate_atomic_load_8
SDNode *N = Node;
(void)N;
if (cast<MemSDNode>(N)->getMemoryVT() != MVT::i8) return false;
return true;
}
case 6: {
// Predicate_extload
SDNode *N = Node;
(void)N;
if (cast<LoadSDNode>(N)->getExtensionType() != ISD::EXTLOAD) return false;
return true;
}
case 7: {
// Predicate_sextloadi16
// Predicate_extloadi16
// Predicate_zextloadi16
// Predicate_truncstorei16
// Predicate_atomic_store_16
// Predicate_atomic_load_16
SDNode *N = Node;
(void)N;
if (cast<MemSDNode>(N)->getMemoryVT() != MVT::i16) return false;
return true;
}
case 8: {
// Predicate_load
SDNode *N = Node;
(void)N;
if (cast<LoadSDNode>(N)->getExtensionType() != ISD::NON_EXTLOAD) return false;
return true;
}
case 9: {
// Predicate_zextload
SDNode *N = Node;
(void)N;
if (cast<LoadSDNode>(N)->getExtensionType() != ISD::ZEXTLOAD) return false;
return true;
}
case 10: {
// Predicate_sextloadi32
// Predicate_extloadi32
// Predicate_zextloadi32
// Predicate_truncstorei32
// Predicate_atomic_store_32
// Predicate_atomic_load_32
// Predicate_atomic_swap_32
// Predicate_atomic_load_add_32
// Predicate_atomic_load_and_32
// Predicate_atomic_load_or_32
// Predicate_atomic_load_xor_32
// Predicate_atomic_load_max_32
// Predicate_atomic_load_min_32
// Predicate_atomic_load_umax_32
// Predicate_atomic_load_umin_32
// Predicate_atomic_load_nand_32
// Predicate_atomic_cmp_swap_32
// Predicate_atomic_load_sub_32
SDNode *N = Node;
(void)N;
if (cast<MemSDNode>(N)->getMemoryVT() != MVT::i32) return false;
return true;
}
case 11: {
// Predicate_unindexedstore
SDNode *N = Node;
(void)N;
if (cast<StoreSDNode>(N)->getAddressingMode() != ISD::UNINDEXED) return false;
return true;
}
case 12: {
// Predicate_truncstore
SDNode *N = Node;
(void)N;
if (!cast<StoreSDNode>(N)->isTruncatingStore()) return false;
return true;
}
case 13: {
// Predicate_store
SDNode *N = Node;
(void)N;
if (cast<StoreSDNode>(N)->isTruncatingStore()) return false;
return true;
}
case 14: {
// Predicate_atomic_store_64
// Predicate_atomic_load_64
// Predicate_atomic_swap_64
// Predicate_atomic_load_add_64
// Predicate_atomic_load_and_64
// Predicate_atomic_load_or_64
// Predicate_atomic_load_xor_64
// Predicate_atomic_load_max_64
// Predicate_atomic_load_min_64
// Predicate_atomic_load_umax_64
// Predicate_atomic_load_umin_64
// Predicate_atomic_load_nand_64
// Predicate_atomic_cmp_swap_64
// Predicate_atomic_load_sub_64
SDNode *N = Node;
(void)N;
if (cast<MemSDNode>(N)->getMemoryVT() != MVT::i64) return false;
return true;
}
case 15: {
// Predicate_uimm5
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
return isUInt<5>(Imm);
}
case 16: {
// Predicate_immbottomxlenset
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
if (Subtarget->is64Bit())
return countTrailingOnes<uint64_t>(Imm) >= 6;
return countTrailingOnes<uint64_t>(Imm) >= 5;
}
case 17: {
// Predicate_uimmlog2xlen
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
if (Subtarget->is64Bit())
return isUInt<6>(Imm);
return isUInt<5>(Imm);
}
case 18: {
// Predicate_simm32hi20
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
return isShiftedInt<20, 12>(Imm);
}
case 19: {
// Predicate_simm32
int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
return isInt<32>(Imm);
}
case 20: {
// Predicate_atomic_swap_32_monotonic
// Predicate_atomic_swap_64_monotonic
// Predicate_atomic_load_add_32_monotonic
// Predicate_atomic_load_add_64_monotonic
// Predicate_atomic_load_and_32_monotonic
// Predicate_atomic_load_and_64_monotonic
// Predicate_atomic_load_or_32_monotonic
// Predicate_atomic_load_or_64_monotonic
// Predicate_atomic_load_xor_32_monotonic
// Predicate_atomic_load_xor_64_monotonic
// Predicate_atomic_load_max_32_monotonic
// Predicate_atomic_load_max_64_monotonic
// Predicate_atomic_load_min_32_monotonic
// Predicate_atomic_load_min_64_monotonic
// Predicate_atomic_load_umax_32_monotonic
// Predicate_atomic_load_umax_64_monotonic
// Predicate_atomic_load_umin_32_monotonic
// Predicate_atomic_load_umin_64_monotonic
// Predicate_atomic_load_nand_32_monotonic
// Predicate_atomic_load_nand_64_monotonic
// Predicate_atomic_cmp_swap_32_monotonic
// Predicate_atomic_cmp_swap_64_monotonic
// Predicate_atomic_load_sub_32_monotonic
// Predicate_atomic_load_sub_64_monotonic
SDNode *N = Node;
(void)N;
if (cast<AtomicSDNode>(N)->getOrdering() != AtomicOrdering::Monotonic) return false;
return true;
}
case 21: {
// Predicate_atomic_swap_32_acquire
// Predicate_atomic_swap_64_acquire
// Predicate_atomic_load_add_32_acquire
// Predicate_atomic_load_add_64_acquire
// Predicate_atomic_load_and_32_acquire
// Predicate_atomic_load_and_64_acquire
// Predicate_atomic_load_or_32_acquire
// Predicate_atomic_load_or_64_acquire
// Predicate_atomic_load_xor_32_acquire
// Predicate_atomic_load_xor_64_acquire
// Predicate_atomic_load_max_32_acquire
// Predicate_atomic_load_max_64_acquire
// Predicate_atomic_load_min_32_acquire
// Predicate_atomic_load_min_64_acquire
// Predicate_atomic_load_umax_32_acquire
// Predicate_atomic_load_umax_64_acquire
// Predicate_atomic_load_umin_32_acquire
// Predicate_atomic_load_umin_64_acquire
// Predicate_atomic_load_nand_32_acquire
// Predicate_atomic_load_nand_64_acquire
// Predicate_atomic_cmp_swap_32_acquire
// Predicate_atomic_cmp_swap_64_acquire
// Predicate_atomic_load_sub_32_acquire
// Predicate_atomic_load_sub_64_acquire
SDNode *N = Node;
(void)N;
if (cast<AtomicSDNode>(N)->getOrdering() != AtomicOrdering::Acquire) return false;
return true;
}
case 22: {
// Predicate_atomic_swap_32_release
// Predicate_atomic_swap_64_release
// Predicate_atomic_load_add_32_release
// Predicate_atomic_load_add_64_release
// Predicate_atomic_load_and_32_release
// Predicate_atomic_load_and_64_release
// Predicate_atomic_load_or_32_release
// Predicate_atomic_load_or_64_release
// Predicate_atomic_load_xor_32_release
// Predicate_atomic_load_xor_64_release
// Predicate_atomic_load_max_32_release
// Predicate_atomic_load_max_64_release
// Predicate_atomic_load_min_32_release
// Predicate_atomic_load_min_64_release
// Predicate_atomic_load_umax_32_release
// Predicate_atomic_load_umax_64_release
// Predicate_atomic_load_umin_32_release
// Predicate_atomic_load_umin_64_release
// Predicate_atomic_load_nand_32_release
// Predicate_atomic_load_nand_64_release
// Predicate_atomic_cmp_swap_32_release
// Predicate_atomic_cmp_swap_64_release
// Predicate_atomic_load_sub_32_release
// Predicate_atomic_load_sub_64_release
SDNode *N = Node;
(void)N;
if (cast<AtomicSDNode>(N)->getOrdering() != AtomicOrdering::Release) return false;
return true;
}
case 23: {
// Predicate_atomic_swap_32_acq_rel
// Predicate_atomic_swap_64_acq_rel
// Predicate_atomic_load_add_32_acq_rel
// Predicate_atomic_load_add_64_acq_rel
// Predicate_atomic_load_and_32_acq_rel
// Predicate_atomic_load_and_64_acq_rel
// Predicate_atomic_load_or_32_acq_rel
// Predicate_atomic_load_or_64_acq_rel
// Predicate_atomic_load_xor_32_acq_rel
// Predicate_atomic_load_xor_64_acq_rel
// Predicate_atomic_load_max_32_acq_rel
// Predicate_atomic_load_max_64_acq_rel
// Predicate_atomic_load_min_32_acq_rel
// Predicate_atomic_load_min_64_acq_rel
// Predicate_atomic_load_umax_32_acq_rel
// Predicate_atomic_load_umax_64_acq_rel
// Predicate_atomic_load_umin_32_acq_rel
// Predicate_atomic_load_umin_64_acq_rel
// Predicate_atomic_load_nand_32_acq_rel
// Predicate_atomic_load_nand_64_acq_rel
// Predicate_atomic_cmp_swap_32_acq_rel
// Predicate_atomic_cmp_swap_64_acq_rel
// Predicate_atomic_load_sub_32_acq_rel
// Predicate_atomic_load_sub_64_acq_rel
SDNode *N = Node;
(void)N;
if (cast<AtomicSDNode>(N)->getOrdering() != AtomicOrdering::AcquireRelease) return false;
return true;
}
case 24: {
// Predicate_atomic_swap_32_seq_cst
// Predicate_atomic_swap_64_seq_cst
// Predicate_atomic_load_add_32_seq_cst
// Predicate_atomic_load_add_64_seq_cst
// Predicate_atomic_load_and_32_seq_cst
// Predicate_atomic_load_and_64_seq_cst
// Predicate_atomic_load_or_32_seq_cst
// Predicate_atomic_load_or_64_seq_cst
// Predicate_atomic_load_xor_32_seq_cst
// Predicate_atomic_load_xor_64_seq_cst
// Predicate_atomic_load_max_32_seq_cst
// Predicate_atomic_load_max_64_seq_cst
// Predicate_atomic_load_min_32_seq_cst
// Predicate_atomic_load_min_64_seq_cst
// Predicate_atomic_load_umax_32_seq_cst
// Predicate_atomic_load_umax_64_seq_cst
// Predicate_atomic_load_umin_32_seq_cst
// Predicate_atomic_load_umin_64_seq_cst
// Predicate_atomic_load_nand_32_seq_cst
// Predicate_atomic_load_nand_64_seq_cst
// Predicate_atomic_cmp_swap_32_seq_cst
// Predicate_atomic_cmp_swap_64_seq_cst
// Predicate_atomic_load_sub_32_seq_cst
// Predicate_atomic_load_sub_64_seq_cst
SDNode *N = Node;
(void)N;
if (cast<AtomicSDNode>(N)->getOrdering() != AtomicOrdering::SequentiallyConsistent) return false;
return true;
}
}
}
#endif // GET_DAGISEL_BODY
#ifdef GET_DAGISEL_DECL
bool CheckComplexPattern(SDNode *Root, SDNode *Parent,
SDValue N, unsigned PatternNo,
SmallVectorImpl<std::pair<SDValue, SDNode*>> &Result) override;
#endif
#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE
bool DAGISEL_CLASS_COLONCOLON CheckComplexPattern(SDNode *Root, SDNode *Parent,
SDValue N, unsigned PatternNo,
SmallVectorImpl<std::pair<SDValue, SDNode*>> &Result)
#if DAGISEL_INLINE
override
#endif
{
unsigned NextRes = Result.size();
switch (PatternNo) {
default: llvm_unreachable("Invalid pattern # in table?");
case 0:
Result.resize(NextRes+1);
return SelectAddrFI(N, Result[NextRes+0].first);
}
}
#endif // GET_DAGISEL_BODY
#ifdef GET_DAGISEL_DECL
SDValue RunSDNodeXForm(SDValue V, unsigned XFormNo) override;
#endif
#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE
SDValue DAGISEL_CLASS_COLONCOLON RunSDNodeXForm(SDValue V, unsigned XFormNo)
#if DAGISEL_INLINE
override
#endif
{
switch (XFormNo) {
default: llvm_unreachable("Invalid xform # in table?");
case 0: { // HI20
ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
return CurDAG->getTargetConstant(((N->getZExtValue()+0x800) >> 12) & 0xfffff,
SDLoc(N), N->getValueType(0));
}
case 1: { // LO12Sext
ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
return CurDAG->getTargetConstant(SignExtend64<12>(N->getZExtValue()),
SDLoc(N), N->getValueType(0));
}
}
}
#endif // GET_DAGISEL_BODY
#ifdef DAGISEL_INLINE
#undef DAGISEL_INLINE
#endif
#ifdef DAGISEL_CLASS_COLONCOLON
#undef DAGISEL_CLASS_COLONCOLON
#endif
#ifdef GET_DAGISEL_DECL
#undef GET_DAGISEL_DECL
#endif
#ifdef GET_DAGISEL_BODY
#undef GET_DAGISEL_BODY
#endif
```
|
The High Sheriff of Longford was the British Crown's judicial representative in County Longford, Ireland from the 16th century until 1922, when the office was abolished in the new Free State and replaced by the office of Longford County Sheriff. The sheriff had judicial, electoral, ceremonial and administrative functions and executed High Court Writs. In 1908, an Order in Council made the Lord-Lieutenant the Sovereign's prime representative in a county and reduced the High Sheriff's precedence. However the sheriff retained his responsibilities for the preservation of law and order in the county. The usual procedure for appointing the sheriff from 1660 onwards was that three persons were nominated at the beginning of each year from the county and the Lord Lieutenant then appointed his choice as High Sheriff for the remainder of the year. Often the other nominees were appointed as under-sheriffs. Sometimes a sheriff did not fulfil his entire term through death or other event and another sheriff was then appointed for the remainder of the year. The dates given hereunder are the dates of appointment. All addresses are in County Longford unless stated otherwise.
Longford was created in 1569.
High Sheriffs of County Longford
1590: Fergus O'Farrell
1611: Robert Bellingham
1623: Sir Richard Browne, 1st Baronet
1646: John Edgeworth of Cranallagh Castle
1655: James Shaen
1680: Charles Fox of Fox Hall
1681: Charles Adare
1686: James Nugent
1692: Charles Fox of Fox Hall
1696: Mathew Wilder of Castle Wilder
1698: Anthony Sheppard
Redmund Mulledy
18th century
1799: Alexander Kingston
19th century
20th century
1903: John Arthur Maconchy.
1904:
1905: Willoughby James Bond.
1906: Charles James Clerk of Castlecor.
1908: Henry Bevan Wilson-Slator of Edgeworthstown.
1909: Augustine Hugh Lefroy of Carrigglas Manor.
1910: Lambert John Dopping-Hepenstall of Altadore Castle.
References
Longford
History of County Longford
|
Vizheh (, also Romanized as Vīzheh and Vīzhah) is a village in Kivanat Rural District, Kolyai District, Sonqor County, Kermanshah Province, Iran. At the 2006 census, its population was 150, in 39 families.
References
Populated places in Sonqor County
|
```objective-c
/*
* PTP 1588 clock support - user space interface
*
*
* This program is free software; you can redistribute it and/or modify
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _PTP_CLOCK_H_
#define _PTP_CLOCK_H_
#include <linux/ioctl.h>
#include <linux/types.h>
/* PTP_xxx bits, for the flags field within the request structures. */
#define PTP_ENABLE_FEATURE (1<<0)
#define PTP_RISING_EDGE (1<<1)
#define PTP_FALLING_EDGE (1<<2)
/*
* struct ptp_clock_time - represents a time value
*
* The sign of the seconds field applies to the whole value. The
* nanoseconds field is always unsigned. The reserved field is
* included for sub-nanosecond resolution, should the demand for
* this ever appear.
*
*/
struct ptp_clock_time {
__s64 sec; /* seconds */
__u32 nsec; /* nanoseconds */
__u32 reserved;
};
struct ptp_clock_caps {
int max_adj; /* Maximum frequency adjustment in parts per billon. */
int n_alarm; /* Number of programmable alarms. */
int n_ext_ts; /* Number of external time stamp channels. */
int n_per_out; /* Number of programmable periodic signals. */
int pps; /* Whether the clock supports a PPS callback. */
int n_pins; /* Number of input/output pins. */
/* Whether the clock supports precise system-device cross timestamps */
int cross_timestamping;
int rsv[13]; /* Reserved for future use. */
};
struct ptp_extts_request {
unsigned int index; /* Which channel to configure. */
unsigned int flags; /* Bit field for PTP_xxx flags. */
unsigned int rsv[2]; /* Reserved for future use. */
};
struct ptp_perout_request {
struct ptp_clock_time start; /* Absolute start time. */
struct ptp_clock_time period; /* Desired period, zero means disable. */
unsigned int index; /* Which channel to configure. */
unsigned int flags; /* Reserved for future use. */
unsigned int rsv[4]; /* Reserved for future use. */
};
#define PTP_MAX_SAMPLES 25 /* Maximum allowed offset measurement samples. */
struct ptp_sys_offset {
unsigned int n_samples; /* Desired number of measurements. */
unsigned int rsv[3]; /* Reserved for future use. */
/*
* Array of interleaved system/phc time stamps. The kernel
* will provide 2*n_samples + 1 time stamps, with the last
* one as a system time stamp.
*/
struct ptp_clock_time ts[2 * PTP_MAX_SAMPLES + 1];
};
struct ptp_sys_offset_precise {
struct ptp_clock_time device;
struct ptp_clock_time sys_realtime;
struct ptp_clock_time sys_monoraw;
unsigned int rsv[4]; /* Reserved for future use. */
};
enum ptp_pin_function {
PTP_PF_NONE,
PTP_PF_EXTTS,
PTP_PF_PEROUT,
PTP_PF_PHYSYNC,
};
struct ptp_pin_desc {
/*
* Hardware specific human readable pin name. This field is
* set by the kernel during the PTP_PIN_GETFUNC ioctl and is
* ignored for the PTP_PIN_SETFUNC ioctl.
*/
char name[64];
/*
* Pin index in the range of zero to ptp_clock_caps.n_pins - 1.
*/
unsigned int index;
/*
* Which of the PTP_PF_xxx functions to use on this pin.
*/
unsigned int func;
/*
* The specific channel to use for this function.
* This corresponds to the 'index' field of the
* PTP_EXTTS_REQUEST and PTP_PEROUT_REQUEST ioctls.
*/
unsigned int chan;
/*
* Reserved for future use.
*/
unsigned int rsv[5];
};
#define PTP_CLK_MAGIC '='
#define PTP_CLOCK_GETCAPS _IOR(PTP_CLK_MAGIC, 1, struct ptp_clock_caps)
#define PTP_EXTTS_REQUEST _IOW(PTP_CLK_MAGIC, 2, struct ptp_extts_request)
#define PTP_PEROUT_REQUEST _IOW(PTP_CLK_MAGIC, 3, struct ptp_perout_request)
#define PTP_ENABLE_PPS _IOW(PTP_CLK_MAGIC, 4, int)
#define PTP_SYS_OFFSET _IOW(PTP_CLK_MAGIC, 5, struct ptp_sys_offset)
#define PTP_PIN_GETFUNC _IOWR(PTP_CLK_MAGIC, 6, struct ptp_pin_desc)
#define PTP_PIN_SETFUNC _IOW(PTP_CLK_MAGIC, 7, struct ptp_pin_desc)
#define PTP_SYS_OFFSET_PRECISE \
_IOWR(PTP_CLK_MAGIC, 8, struct ptp_sys_offset_precise)
struct ptp_extts_event {
struct ptp_clock_time t; /* Time event occured. */
unsigned int index; /* Which channel produced the event. */
unsigned int flags; /* Reserved for future use. */
unsigned int rsv[2]; /* Reserved for future use. */
};
#endif
```
|
The Rusty Razor is the debut studio album by Irish folk band Goats Don't Shave, released in 1992.
The album became a success after release, going Gold in Ireland.
History and reception
Goats Don't Shave began performing their Celtic folk-rock in between their day jobs shortly before the release of The Rusty Razor.
Critics hailed the album "a classic".
Track listing
All songs written by Pat Gallagher.
"Let The World Keep on Turning"
"Las Vegas (In the Hills of Donegal)"
"Eyes"
"John Cherokee"
"The Evictions"
"Biddy from Sligo/Connaught Man's Rambles"
"The Ranger"
"Mary Mary"
"Closing Time"
"What She Means To Me"
"Crooked Jack"
"When You're Dead (You're Great)"
Personnel
Pat Gallagher – vocals, banjo, guitar
Jason Phibin – fiddle
Charlie Logue – keyboard
Declan Quinn – tinwhistle, mandolin
Gerry Coyle – bass guitar
Sean Doherty – acoustic guitar
Michael Gallagher – drums
References
1992 albums
Goats Don't Shave albums
|
The Asia-Pacific Advanced Network (APAN) is a not-for-profit association of Asia-Pacific national research and education networks (NRENs) incorporated in Hong Kong as a company limited by guarantee. The organisation was originally formed on 3 June 1997 and was incorporated on 8 August 2009.
Purpose
The objectives of APAN are
to coordinate and promote network technology developments and advances in network-based applications and services across the Asia-Pacific region;
to provide a forum for user communities to come together with network engineers to help promote and exploit opportunities to enhance research and education in disciplines that are relevant to the member economies;
to hold meetings, workshops and conferences relating to network technology, the development of advanced communication services, and the exploitation of these, resulting in compelling new applications;
to arrange and organize education and training workshops, and to operate a fellowship programme to support and develop the next generation of network engineers and network leaders in the Asia-Pacific region;
to work closely with relevant organizations, institutions, groups and individuals around the world to further enhance the adoption of and research into advanced network applications and technologies;
together with peer organizations in North and South America, Europe and Africa, coordinate the building of global infrastructure that will transform the way that education and research is undertaken, leading to improvements in societal benefit.
Full membership of APAN is open to NRENs (one per country or economy). Non-voting membership is available for persons, organisations or corporations that have common interests in the objectives of APAN.
Similar organisations elsewhere in the world include GÉANT, UbuntuNet Alliance, WACREN (West and Central African Research and Education Network), ASREN (Arab States Research and Education Network), and CLARA (Cooperación Latino Americana de Redes Avanzadas).
History
The necessity for high-end internet for researchers in the Asia-Pacific region was recognized at the APEC Symposium in Tsukuba, Japan in March 1996, and then at APII Test-bed Forum in Seoul, Korea in June 1996, the creation of APAN was proposed. Meetings were held with the attendance of the delegates from North America or Europe for one year, and the APAN Consortium was formed under a Memorandum of Understanding in June 1997 to promote advanced research in networking technologies and the development of high-performance broadband applications.
APAN is designed to offer a high-performance network for research and development on advanced next-generation applications and services. APAN provides an advanced networking environment for the research and education community in the Asia-Pacific region, and promotes global collaboration.
Conference
Twice a year, APAN runs a conference for academic networkers called the APAN Meetings. Each conference is hosted by a member NREN and attended by around 200 delegates from academic backgrounds including networking specialists and managers from networking and research organisations.
Conference locations
Seoul (August 1996)
Tokyo (November 1996)
Tokyo (June 1997)
Singapore (October 1997)
Tsukuba (March 1998)
Seoul (July 1998)
Osaka (February 1999)
Canberra (September 1999)
Tsukuba (February 2000)
Beijing (August 2000)
Honolulu (February 2001)
Penang (August 2001)
Phuket (January 2002)
Shanghai (August 2002)
Fukuoka (January 2003)
Busan (August 2003)
Honolulu (January 2004)
Cairns (July 2004)
Bangkok (January 2005)
Taipei (August 2005)
Tokyo (January 2006)
Singapore (July 2006)
Manila (January 2007)
Xi'an (August 2007)
Honolulu (January 2008)
Queenstown (August 2008)
Kaohsiung (March 2009)
Kuala Lumpur (July 2009)
Sydney (February 2010)
Hanoi (August 2010)
Hong Kong (February 2011)
New Delhi (August 2011)
Chiang Mai (February 2012)
Colombo (August 2012)
Honolulu (January 2013)
Daejeon (August 2013),
Bandung (January 2014)
Taipei (August 2014)
Fukuoka (March 2015)
References
External links
Non-profit organisations based in Sri Lanka
|
```go
// go run mksysnum.go path_to_url
// Code generated by the command above; see README.md. DO NOT EDIT.
//go:build arm64 && freebsd
package unix
const (
// SYS_NOSYS = 0; // { int nosys(void); } syscall nosys_args int
SYS_EXIT = 1 // { void sys_exit(int rval); } exit sys_exit_args void
SYS_FORK = 2 // { int fork(void); }
SYS_READ = 3 // { ssize_t read(int fd, void *buf, size_t nbyte); }
SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, size_t nbyte); }
SYS_OPEN = 5 // { int open(char *path, int flags, int mode); }
SYS_CLOSE = 6 // { int close(int fd); }
SYS_WAIT4 = 7 // { int wait4(int pid, int *status, int options, struct rusage *rusage); }
SYS_LINK = 9 // { int link(char *path, char *link); }
SYS_UNLINK = 10 // { int unlink(char *path); }
SYS_CHDIR = 12 // { int chdir(char *path); }
SYS_FCHDIR = 13 // { int fchdir(int fd); }
SYS_CHMOD = 15 // { int chmod(char *path, int mode); }
SYS_CHOWN = 16 // { int chown(char *path, int uid, int gid); }
SYS_BREAK = 17 // { caddr_t break(char *nsize); }
SYS_GETPID = 20 // { pid_t getpid(void); }
SYS_MOUNT = 21 // { int mount(char *type, char *path, int flags, caddr_t data); }
SYS_UNMOUNT = 22 // { int unmount(char *path, int flags); }
SYS_SETUID = 23 // { int setuid(uid_t uid); }
SYS_GETUID = 24 // { uid_t getuid(void); }
SYS_GETEUID = 25 // { uid_t geteuid(void); }
SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, int data); }
SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, int flags); }
SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, int flags); }
SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, int flags, struct sockaddr * __restrict from, __socklen_t * __restrict fromlenaddr); }
SYS_ACCEPT = 30 // { int accept(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen); }
SYS_GETPEERNAME = 31 // { int getpeername(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
SYS_ACCESS = 33 // { int access(char *path, int amode); }
SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); }
SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); }
SYS_SYNC = 36 // { int sync(void); }
SYS_KILL = 37 // { int kill(int pid, int signum); }
SYS_GETPPID = 39 // { pid_t getppid(void); }
SYS_DUP = 41 // { int dup(u_int fd); }
SYS_GETEGID = 43 // { gid_t getegid(void); }
SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, size_t offset, u_int scale); }
SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, int pid); }
SYS_GETGID = 47 // { gid_t getgid(void); }
SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int namelen); }
SYS_SETLOGIN = 50 // { int setlogin(char *namebuf); }
SYS_ACCT = 51 // { int acct(char *path); }
SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t *ss, stack_t *oss); }
SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, caddr_t data); }
SYS_REBOOT = 55 // { int reboot(int opt); }
SYS_REVOKE = 56 // { int revoke(char *path); }
SYS_SYMLINK = 57 // { int symlink(char *path, char *link); }
SYS_READLINK = 58 // { ssize_t readlink(char *path, char *buf, size_t count); }
SYS_EXECVE = 59 // { int execve(char *fname, char **argv, char **envv); }
SYS_UMASK = 60 // { int umask(int newmask); }
SYS_CHROOT = 61 // { int chroot(char *path); }
SYS_MSYNC = 65 // { int msync(void *addr, size_t len, int flags); }
SYS_VFORK = 66 // { int vfork(void); }
SYS_SBRK = 69 // { int sbrk(int incr); }
SYS_SSTK = 70 // { int sstk(int incr); }
SYS_MUNMAP = 73 // { int munmap(void *addr, size_t len); }
SYS_MPROTECT = 74 // { int mprotect(void *addr, size_t len, int prot); }
SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, int behav); }
SYS_MINCORE = 78 // { int mincore(const void *addr, size_t len, char *vec); }
SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, gid_t *gidset); }
SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, gid_t *gidset); }
SYS_GETPGRP = 81 // { int getpgrp(void); }
SYS_SETPGID = 82 // { int setpgid(int pid, int pgid); }
SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval *itv, struct itimerval *oitv); }
SYS_SWAPON = 85 // { int swapon(char *name); }
SYS_GETITIMER = 86 // { int getitimer(u_int which, struct itimerval *itv); }
SYS_GETDTABLESIZE = 89 // { int getdtablesize(void); }
SYS_DUP2 = 90 // { int dup2(u_int from, u_int to); }
SYS_FCNTL = 92 // { int fcntl(int fd, int cmd, long arg); }
SYS_SELECT = 93 // { int select(int nd, fd_set *in, fd_set *ou, fd_set *ex, struct timeval *tv); }
SYS_FSYNC = 95 // { int fsync(int fd); }
SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, int prio); }
SYS_SOCKET = 97 // { int socket(int domain, int type, int protocol); }
SYS_CONNECT = 98 // { int connect(int s, caddr_t name, int namelen); }
SYS_GETPRIORITY = 100 // { int getpriority(int which, int who); }
SYS_BIND = 104 // { int bind(int s, caddr_t name, int namelen); }
SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, caddr_t val, int valsize); }
SYS_LISTEN = 106 // { int listen(int s, int backlog); }
SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval *tp, struct timezone *tzp); }
SYS_GETRUSAGE = 117 // { int getrusage(int who, struct rusage *rusage); }
SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, caddr_t val, int *avalsize); }
SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval *tv, struct timezone *tzp); }
SYS_FCHOWN = 123 // { int fchown(int fd, int uid, int gid); }
SYS_FCHMOD = 124 // { int fchmod(int fd, int mode); }
SYS_SETREUID = 126 // { int setreuid(int ruid, int euid); }
SYS_SETREGID = 127 // { int setregid(int rgid, int egid); }
SYS_RENAME = 128 // { int rename(char *from, char *to); }
SYS_FLOCK = 131 // { int flock(int fd, int how); }
SYS_MKFIFO = 132 // { int mkfifo(char *path, int mode); }
SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen); }
SYS_SHUTDOWN = 134 // { int shutdown(int s, int how); }
SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, int *rsv); }
SYS_MKDIR = 136 // { int mkdir(char *path, int mode); }
SYS_RMDIR = 137 // { int rmdir(char *path); }
SYS_UTIMES = 138 // { int utimes(char *path, struct timeval *tptr); }
SYS_ADJTIME = 140 // { int adjtime(struct timeval *delta, struct timeval *olddelta); }
SYS_SETSID = 147 // { int setsid(void); }
SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, caddr_t arg); }
SYS_NLM_SYSCALL = 154 // { int nlm_syscall(int debug_level, int grace_period, int addr_count, char **addrs); }
SYS_NFSSVC = 155 // { int nfssvc(int flag, caddr_t argp); }
SYS_LGETFH = 160 // { int lgetfh(char *fname, struct fhandle *fhp); }
SYS_GETFH = 161 // { int getfh(char *fname, struct fhandle *fhp); }
SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); }
SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, struct rtprio *rtp); }
SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, int a5); }
SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, int a5, int a6); }
SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); }
SYS_SETFIB = 175 // { int setfib(int fibnum); }
SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); }
SYS_SETGID = 181 // { int setgid(gid_t gid); }
SYS_SETEGID = 182 // { int setegid(gid_t egid); }
SYS_SETEUID = 183 // { int seteuid(uid_t euid); }
SYS_PATHCONF = 191 // { int pathconf(char *path, int name); }
SYS_FPATHCONF = 192 // { int fpathconf(int fd, int name); }
SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, struct rlimit *rlp); } getrlimit __getrlimit_args int
SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, struct rlimit *rlp); } setrlimit __setrlimit_args int
SYS___SYSCTL = 202 // { int __sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen); } __sysctl sysctl_args int
SYS_MLOCK = 203 // { int mlock(const void *addr, size_t len); }
SYS_MUNLOCK = 204 // { int munlock(const void *addr, size_t len); }
SYS_UNDELETE = 205 // { int undelete(char *path); }
SYS_FUTIMES = 206 // { int futimes(int fd, struct timeval *tptr); }
SYS_GETPGID = 207 // { int getpgid(pid_t pid); }
SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, int timeout); }
SYS_SEMGET = 221 // { int semget(key_t key, int nsems, int semflg); }
SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, size_t nsops); }
SYS_MSGGET = 225 // { int msgget(key_t key, int msgflg); }
SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
SYS_MSGRCV = 227 // { ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, int shmflg); }
SYS_SHMDT = 230 // { int shmdt(const void *shmaddr); }
SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, int shmflg); }
SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, struct timespec *tp); }
SYS_CLOCK_SETTIME = 233 // { int clock_settime(clockid_t clock_id, const struct timespec *tp); }
SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, struct timespec *tp); }
SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, struct sigevent *evp, int *timerid); }
SYS_KTIMER_DELETE = 236 // { int ktimer_delete(int timerid); }
SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue); }
SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct itimerspec *value); }
SYS_KTIMER_GETOVERRUN = 239 // { int ktimer_getoverrun(int timerid); }
SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); }
SYS_FFCLOCK_GETCOUNTER = 241 // { int ffclock_getcounter(ffcounter *ffcount); }
SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate(struct ffclock_estimate *cest); }
SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate(struct ffclock_estimate *cest); }
SYS_CLOCK_NANOSLEEP = 244 // { int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp); }
SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id, int which, clockid_t *clock_id); }
SYS_NTP_GETTIME = 248 // { int ntp_gettime(struct ntptimeval *ntvp); }
SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, int inherit); }
SYS_RFORK = 251 // { int rfork(int flags); }
SYS_ISSETUGID = 253 // { int issetugid(void); }
SYS_LCHOWN = 254 // { int lchown(char *path, int uid, int gid); }
SYS_AIO_READ = 255 // { int aio_read(struct aiocb *aiocbp); }
SYS_AIO_WRITE = 256 // { int aio_write(struct aiocb *aiocbp); }
SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, struct aiocb* const *acb_list, int nent, struct sigevent *sig); }
SYS_LCHMOD = 274 // { int lchmod(char *path, mode_t mode); }
SYS_LUTIMES = 276 // { int lutimes(char *path, struct timeval *tptr); }
SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, int flags); }
SYS_MODNEXT = 300 // { int modnext(int modid); }
SYS_MODSTAT = 301 // { int modstat(int modid, struct module_stat* stat); }
SYS_MODFNEXT = 302 // { int modfnext(int modid); }
SYS_MODFIND = 303 // { int modfind(const char *name); }
SYS_KLDLOAD = 304 // { int kldload(const char *file); }
SYS_KLDUNLOAD = 305 // { int kldunload(int fileid); }
SYS_KLDFIND = 306 // { int kldfind(const char *file); }
SYS_KLDNEXT = 307 // { int kldnext(int fileid); }
SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct kld_file_stat *stat); }
SYS_KLDFIRSTMOD = 309 // { int kldfirstmod(int fileid); }
SYS_GETSID = 310 // { int getsid(pid_t pid); }
SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
SYS_AIO_RETURN = 314 // { ssize_t aio_return(struct aiocb *aiocbp); }
SYS_AIO_SUSPEND = 315 // { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, struct aiocb *aiocbp); }
SYS_AIO_ERROR = 317 // { int aio_error(struct aiocb *aiocbp); }
SYS_YIELD = 321 // { int yield(void); }
SYS_MLOCKALL = 324 // { int mlockall(int how); }
SYS_MUNLOCKALL = 325 // { int munlockall(void); }
SYS___GETCWD = 326 // { int __getcwd(char *buf, size_t buflen); }
SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, const struct sched_param *param); }
SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct sched_param *param); }
SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
SYS_SCHED_GETSCHEDULER = 330 // { int sched_getscheduler (pid_t pid); }
SYS_SCHED_YIELD = 331 // { int sched_yield (void); }
SYS_SCHED_GET_PRIORITY_MAX = 332 // { int sched_get_priority_max (int policy); }
SYS_SCHED_GET_PRIORITY_MIN = 333 // { int sched_get_priority_min (int policy); }
SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
SYS_UTRACE = 335 // { int utrace(const void *addr, size_t len); }
SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, void *data); }
SYS_JAIL = 338 // { int jail(struct jail *jail); }
SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t *set, sigset_t *oset); }
SYS_SIGSUSPEND = 341 // { int sigsuspend(const sigset_t *sigmask); }
SYS_SIGPENDING = 343 // { int sigpending(sigset_t *set); }
SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout); }
SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t *set, siginfo_t *info); }
SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char *path, acl_type_t type, struct acl *aclp); }
SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char *path, acl_type_t type, struct acl *aclp); }
SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp); }
SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp); }
SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, acl_type_t type); }
SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, acl_type_t type); }
SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, acl_type_t type, struct acl *aclp); }
SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp); }
SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, const char *filename, int attrnamespace, const char *attrname); }
SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, int attrnamespace, const char *attrname); }
SYS_AIO_WAITCOMPLETE = 359 // { ssize_t aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
SYS_GETRESUID = 360 // { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
SYS_GETRESGID = 361 // { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
SYS_KQUEUE = 362 // { int kqueue(void); }
SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, int attrnamespace, const char *attrname); }
SYS___SETUGID = 374 // { int __setugid(int flag); }
SYS_EACCESS = 376 // { int eaccess(char *path, int amode); }
SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, unsigned int iovcnt, int flags); }
SYS___MAC_GET_PROC = 384 // { int __mac_get_proc(struct mac *mac_p); }
SYS___MAC_SET_PROC = 385 // { int __mac_set_proc(struct mac *mac_p); }
SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, struct mac *mac_p); }
SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char *path_p, struct mac *mac_p); }
SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, struct mac *mac_p); }
SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, struct mac *mac_p); }
SYS_KENV = 390 // { int kenv(int what, const char *name, char *value, int len); }
SYS_LCHFLAGS = 391 // { int lchflags(const char *path, u_long flags); }
SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, int count); }
SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, int call, void *arg); }
SYS_KSEM_CLOSE = 400 // { int ksem_close(semid_t id); }
SYS_KSEM_POST = 401 // { int ksem_post(semid_t id); }
SYS_KSEM_WAIT = 402 // { int ksem_wait(semid_t id); }
SYS_KSEM_TRYWAIT = 403 // { int ksem_trywait(semid_t id); }
SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, unsigned int value); }
SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t *idp, const char *name, int oflag, mode_t mode, unsigned int value); }
SYS_KSEM_UNLINK = 406 // { int ksem_unlink(const char *name); }
SYS_KSEM_GETVALUE = 407 // { int ksem_getvalue(semid_t id, int *val); }
SYS_KSEM_DESTROY = 408 // { int ksem_destroy(semid_t id); }
SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, struct mac *mac_p); }
SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, struct mac *mac_p); }
SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, struct mac *mac_p); }
SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link(const char *path, int attrnamespace, const char *attrname); }
SYS___MAC_EXECVE = 415 // { int __mac_execve(char *fname, char **argv, char **envv, struct mac *mac_p); }
SYS_SIGACTION = 416 // { int sigaction(int sig, const struct sigaction *act, struct sigaction *oact); }
SYS_SIGRETURN = 417 // { int sigreturn(const struct __ucontext *sigcntxp); }
SYS_GETCONTEXT = 421 // { int getcontext(struct __ucontext *ucp); }
SYS_SETCONTEXT = 422 // { int setcontext(const struct __ucontext *ucp); }
SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext *oucp, const struct __ucontext *ucp); }
SYS_SWAPOFF = 424 // { int swapoff(const char *name); }
SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char *path, acl_type_t type, struct acl *aclp); }
SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char *path, acl_type_t type, struct acl *aclp); }
SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, acl_type_t type); }
SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char *path, acl_type_t type, struct acl *aclp); }
SYS_SIGWAIT = 429 // { int sigwait(const sigset_t *set, int *sig); }
SYS_THR_CREATE = 430 // { int thr_create(ucontext_t *ctx, long *id, int flags); }
SYS_THR_EXIT = 431 // { void thr_exit(long *state); }
SYS_THR_SELF = 432 // { int thr_self(long *id); }
SYS_THR_KILL = 433 // { int thr_kill(long id, int sig); }
SYS_JAIL_ATTACH = 436 // { int jail_attach(int jid); }
SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes); }
SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file(const char *path, int attrnamespace, void *data, size_t nbytes); }
SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link(const char *path, int attrnamespace, void *data, size_t nbytes); }
SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, const struct timespec *abstime); }
SYS_THR_SUSPEND = 442 // { int thr_suspend(const struct timespec *timeout); }
SYS_THR_WAKE = 443 // { int thr_wake(long id); }
SYS_KLDUNLOADF = 444 // { int kldunloadf(int fileid, int flags); }
SYS_AUDIT = 445 // { int audit(const void *record, u_int length); }
SYS_AUDITON = 446 // { int auditon(int cmd, void *data, u_int length); }
SYS_GETAUID = 447 // { int getauid(uid_t *auid); }
SYS_SETAUID = 448 // { int setauid(uid_t *auid); }
SYS_GETAUDIT = 449 // { int getaudit(struct auditinfo *auditinfo); }
SYS_SETAUDIT = 450 // { int setaudit(struct auditinfo *auditinfo); }
SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr(struct auditinfo_addr *auditinfo_addr, u_int length); }
SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr(struct auditinfo_addr *auditinfo_addr, u_int length); }
SYS_AUDITCTL = 453 // { int auditctl(char *path); }
SYS__UMTX_OP = 454 // { int _umtx_op(void *obj, int op, u_long val, void *uaddr1, void *uaddr2); }
SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, int param_size); }
SYS_SIGQUEUE = 456 // { int sigqueue(pid_t pid, int signum, void *value); }
SYS_KMQ_OPEN = 457 // { int kmq_open(const char *path, int flags, mode_t mode, const struct mq_attr *attr); }
SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, const struct mq_attr *attr, struct mq_attr *oattr); }
SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, char *msg_ptr, size_t msg_len, unsigned *msg_prio, const struct timespec *abs_timeout); }
SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, const char *msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout); }
SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, const struct sigevent *sigev); }
SYS_KMQ_UNLINK = 462 // { int kmq_unlink(const char *path); }
SYS_ABORT2 = 463 // { int abort2(const char *why, int nargs, void **args); }
SYS_THR_SET_NAME = 464 // { int thr_set_name(long id, const char *name); }
SYS_AIO_FSYNC = 465 // { int aio_fsync(int op, struct aiocb *aiocbp); }
SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp); }
SYS_SCTP_PEELOFF = 471 // { int sctp_peeloff(int sd, uint32_t name); }
SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo *sinfo, int flags); }
SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec *iov, int iovlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo *sinfo, int flags); }
SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec *iov, int iovlen, struct sockaddr *from, __socklen_t *fromlenaddr, struct sctp_sndrcvinfo *sinfo, int *msg_flags); }
SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset); }
SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset); }
SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos); }
SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, int whence); }
SYS_TRUNCATE = 479 // { int truncate(char *path, off_t length); }
SYS_FTRUNCATE = 480 // { int ftruncate(int fd, off_t length); }
SYS_THR_KILL2 = 481 // { int thr_kill2(pid_t pid, long id, int sig); }
SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, mode_t mode); }
SYS_SHM_UNLINK = 483 // { int shm_unlink(const char *path); }
SYS_CPUSET = 484 // { int cpuset(cpusetid_t *setid); }
SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, cpusetid_t setid); }
SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, cpuwhich_t which, id_t id, cpusetid_t *setid); }
SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, cpuset_t *mask); }
SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, const cpuset_t *mask); }
SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, int flag); }
SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, int flag); }
SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, gid_t gid, int flag); }
SYS_FEXECVE = 492 // { int fexecve(int fd, char **argv, char **envv); }
SYS_FUTIMESAT = 494 // { int futimesat(int fd, char *path, struct timeval *times); }
SYS_LINKAT = 495 // { int linkat(int fd1, char *path1, int fd2, char *path2, int flag); }
SYS_MKDIRAT = 496 // { int mkdirat(int fd, char *path, mode_t mode); }
SYS_MKFIFOAT = 497 // { int mkfifoat(int fd, char *path, mode_t mode); }
SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, mode_t mode); }
SYS_READLINKAT = 500 // { ssize_t readlinkat(int fd, char *path, char *buf, size_t bufsize); }
SYS_RENAMEAT = 501 // { int renameat(int oldfd, char *old, int newfd, char *new); }
SYS_SYMLINKAT = 502 // { int symlinkat(char *path1, int fd, char *path2); }
SYS_UNLINKAT = 503 // { int unlinkat(int fd, char *path, int flag); }
SYS_POSIX_OPENPT = 504 // { int posix_openpt(int flags); }
SYS_GSSD_SYSCALL = 505 // { int gssd_syscall(char *path); }
SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, unsigned int iovcnt, int flags); }
SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, unsigned int iovcnt, int flags); }
SYS_JAIL_REMOVE = 508 // { int jail_remove(int jid); }
SYS_CLOSEFROM = 509 // { int closefrom(int lowfd); }
SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, int cmd, union semun *arg); }
SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, struct msqid_ds *buf); }
SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, struct shmid_ds *buf); }
SYS_LPATHCONF = 513 // { int lpathconf(char *path, int name); }
SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, int fd, cap_rights_t *rightsp); }
SYS_CAP_ENTER = 516 // { int cap_enter(void); }
SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }
SYS_PDFORK = 518 // { int pdfork(int *fdp, int flags); }
SYS_PDKILL = 519 // { int pdkill(int fd, int signum); }
SYS_PDGETPID = 520 // { int pdgetpid(int fd, pid_t *pidp); }
SYS_PSELECT = 522 // { int pselect(int nd, fd_set *in, fd_set *ou, fd_set *ex, const struct timespec *ts, const sigset_t *sm); }
SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, size_t namelen); }
SYS_SETLOGINCLASS = 524 // { int setloginclass(const char *namebuf); }
SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void *inbufp, size_t inbuflen, void *outbufp, size_t outbuflen); }
SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void *inbufp, size_t inbuflen, void *outbufp, size_t outbuflen); }
SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void *inbufp, size_t inbuflen, void *outbufp, size_t outbuflen); }
SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void *inbufp, size_t inbuflen, void *outbufp, size_t outbuflen); }
SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, size_t inbuflen, void *outbufp, size_t outbuflen); }
SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, off_t offset, off_t len); }
SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, off_t len, int advice); }
SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, int *status, int options, struct __wrusage *wrusage, siginfo_t *info); }
SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, cap_rights_t *rightsp); }
SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, const u_long *cmds, size_t ncmds); }
SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, u_long *cmds, size_t maxcmds); }
SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, uint32_t fcntlrights); }
SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, uint32_t *fcntlrightsp); }
SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, int namelen); }
SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, int namelen); }
SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, u_long flags, int atflag); }
SYS_ACCEPT4 = 541 // { int accept4(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen, int flags); }
SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); }
SYS_AIO_MLOCK = 543 // { int aio_mlock(struct aiocb *aiocbp); }
SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, int com, void *data); }
SYS_PPOLL = 545 // { int ppoll(struct pollfd *fds, u_int nfds, const struct timespec *ts, const sigset_t *set); }
SYS_FUTIMENS = 546 // { int futimens(int fd, struct timespec *times); }
SYS_UTIMENSAT = 547 // { int utimensat(int fd, char *path, struct timespec *times, int flag); }
SYS_FDATASYNC = 550 // { int fdatasync(int fd); }
SYS_FSTAT = 551 // { int fstat(int fd, struct stat *sb); }
SYS_FSTATAT = 552 // { int fstatat(int fd, char *path, struct stat *buf, int flag); }
SYS_FHSTAT = 553 // { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
SYS_GETDIRENTRIES = 554 // { ssize_t getdirentries(int fd, char *buf, size_t count, off_t *basep); }
SYS_STATFS = 555 // { int statfs(char *path, struct statfs *buf); }
SYS_FSTATFS = 556 // { int fstatfs(int fd, struct statfs *buf); }
SYS_GETFSSTAT = 557 // { int getfsstat(struct statfs *buf, long bufsize, int mode); }
SYS_FHSTATFS = 558 // { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
SYS_MKNODAT = 559 // { int mknodat(int fd, char *path, mode_t mode, dev_t dev); }
SYS_KEVENT = 560 // { int kevent(int fd, struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, const struct timespec *timeout); }
SYS_CPUSET_GETDOMAIN = 561 // { int cpuset_getdomain(cpulevel_t level, cpuwhich_t which, id_t id, size_t domainsetsize, domainset_t *mask, int *policy); }
SYS_CPUSET_SETDOMAIN = 562 // { int cpuset_setdomain(cpulevel_t level, cpuwhich_t which, id_t id, size_t domainsetsize, domainset_t *mask, int policy); }
SYS_GETRANDOM = 563 // { int getrandom(void *buf, size_t buflen, unsigned int flags); }
SYS_GETFHAT = 564 // { int getfhat(int fd, char *path, struct fhandle *fhp, int flags); }
SYS_FHLINK = 565 // { int fhlink(struct fhandle *fhp, const char *to); }
SYS_FHLINKAT = 566 // { int fhlinkat(struct fhandle *fhp, int tofd, const char *to,); }
SYS_FHREADLINK = 567 // { int fhreadlink(struct fhandle *fhp, char *buf, size_t bufsize); }
SYS___SYSCTLBYNAME = 570 // { int __sysctlbyname(const char *name, size_t namelen, void *old, size_t *oldlenp, void *new, size_t newlen); }
SYS_CLOSE_RANGE = 575 // { int close_range(u_int lowfd, u_int highfd, int flags); }
)
```
|
Changsha Economic and Technological Development Zone (CETZ) () is an economic and technical development zone at state level in Changsha, Hunan, China. The zone was established in August 1992, its old name was Xingsha Development Zone of Changsha (), changed to the present name on 29 March, 1994. CETZ was upgraded to an economic and technical development zone at state-level in February, 2000. The headquarters for CETZ is situated in Xingsha in the eastern suburb of Changsha,
including Xingsha, Langli and Huanghua 3 Industrial parks, its planning area covers .
The zone attracts many foreign investments, such as Mitsubishi Motor, NEC, Bosch, Philips, LG, HEG, Coca-Cola and Pepsi. Major industries in the zone include machinery processing and manufacturing, electronics and information, building materials, food and beverage, and printing.
Link
Changsha Economic and Technological Development Zone
References
Changsha County
Economy of Changsha
1992 establishments in China
Special Economic Zones of China
|
```java
/*
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.oracle.truffle.llvm.runtime.nodes.others;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.instrumentation.GenerateWrapper;
import com.oracle.truffle.api.instrumentation.InstrumentableNode;
import com.oracle.truffle.api.instrumentation.ProbeNode;
import com.oracle.truffle.llvm.runtime.nodes.api.LLVMControlFlowNode;
import com.oracle.truffle.llvm.runtime.nodes.api.LLVMStatementNode;
@GenerateWrapper
public abstract class LLVMUnreachableNode extends LLVMControlFlowNode {
@Override
public int getSuccessorCount() {
return 0;
}
@Override
public int[] getSuccessors() {
return new int[]{};
}
@Override
public LLVMStatementNode getPhiNode(int successorIndex) {
return null;
}
public abstract void execute(VirtualFrame frame);
@Specialization
void doUnreachable() {
throw CompilerDirectives.shouldNotReachHere("LLVMUnreachableNode");
}
@Override
public InstrumentableNode.WrapperNode createWrapper(ProbeNode probe) {
return new LLVMUnreachableNodeWrapper(this, probe);
}
}
```
|
Harry Nolte (born 11 June 1961, Zwickau) is an East German sprint canoeist who competed in the 1980s. He won two a bronze medal in the K-1 1000 m event at the 1986 ICF Canoe Sprint World Championships in Montreal.
Nolte also finished fifth in the K-2 1000 m event at the 1980 Summer Olympics in Moscow.
References
Sports-reference.com profile
1961 births
Canoeists at the 1980 Summer Olympics
German male canoeists
Living people
Olympic canoeists for East Germany
ICF Canoe Sprint World Championships medalists in kayak
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.